Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

13 files changed, 4008 insertions, 0 deletions

diff --git a/swext/mediawiki/src/com/sun/star/wiki/EditPageParser.java b/swext/mediawiki/src/com/sun/star/wiki/EditPageParser.java
new file mode 100644
index 000000000..114709fae
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/EditPageParser.java
@@ -0,0 +1,176 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import javax.swing.text.html.*;
+import javax.swing.text.MutableAttributeSet;
+
+public class EditPageParser extends HTMLEditorKit.ParserCallback
+{
+
+    protected String m_sEditTime = "";
+    protected String m_sEditToken = "";
+    protected String m_sLoginToken = "";
+    protected String m_sMainURL = "";
+
+    private boolean m_bHTMLStartFound = false;
+    private boolean m_bInHead = false;
+
+    protected int m_nWikiArticleStart = -1;
+    protected int m_nWikiArticleEnd = -1;
+    protected int m_nHTMLArticleStart = -1;
+    protected int m_nHTMLArticleEnd = -1;
+    protected int m_nNoArticleInd = -1;
+    protected int m_nErrorInd = -1;
+
+    @Override
+    public void handleComment( char[] data,int pos )
+    {
+        // insert code to handle comments
+    }
+
+    @Override
+    public void handleEndTag( HTML.Tag t,int pos )
+    {
+        if ( t == HTML.Tag.TEXTAREA )
+        {
+            m_nWikiArticleEnd = pos;
+        }
+        else if ( t == HTML.Tag.DIV )
+        {
+            if ( m_bHTMLStartFound )
+            {
+                m_nHTMLArticleStart = pos+6;
+                m_bHTMLStartFound = false;
+            }
+        }
+        else if ( t == HTML.Tag.HEAD )
+        {
+            m_bInHead = false;
+        }
+    }
+
+    @Override
+    public void handleError( String errorMsg,int pos )
+    {
+    }
+
+    @Override
+    public void handleSimpleTag( HTML.Tag t, MutableAttributeSet a,int pos )
+    {
+        // insert code to handle simple tags
+
+        if ( t == HTML.Tag.INPUT )
+        {
+            String sName = ( String ) a.getAttribute( HTML.Attribute.NAME );
+            if ( sName != null )
+            {
+                if ( sName.equalsIgnoreCase( "wpEdittime" ) )
+                {
+                    this.m_sEditTime = ( String ) a.getAttribute( HTML.Attribute.VALUE );
+                }
+                else if ( sName.equalsIgnoreCase( "wpEditToken" ) )
+                {
+                    this.m_sEditToken = ( String ) a.getAttribute( HTML.Attribute.VALUE );
+                }
+                else if ( sName.equalsIgnoreCase( "wpLoginToken" ) )
+                {
+                    this.m_sLoginToken = ( String ) a.getAttribute( HTML.Attribute.VALUE );
+                }
+            }
+
+        }
+        else if ( t == HTML.Tag.LINK )
+        {
+            if ( m_bInHead )
+            {
+                String sName = ( String ) a.getAttribute( HTML.Attribute.HREF );
+                if ( sName != null )
+                {
+                    // get the main URL from the first header-link with load.php (which is used for stylesheet)
+                    int nPhpFileStart = sName.indexOf( "load.php" );
+                    if (nPhpFileStart < 0)
+                        // if not found, try header-link with opensearch_desc.php
+                        nPhpFileStart = sName.indexOf( "opensearch_desc.php" );
+
+                    if ( nPhpFileStart >= 0
+                      && m_sMainURL.length() == 0 )
+                    {
+                        m_sMainURL = sName.substring( 0, nPhpFileStart );
+                    }
+                }
+            }
+        }
+
+    }
+
+    @Override
+    public void handleStartTag( HTML.Tag t, MutableAttributeSet a,int pos )
+    {
+        // insert code to handle starting tags
+        String sClass;
+
+        if ( t == HTML.Tag.HEAD )
+        {
+            m_bInHead = true;
+        }
+        else if ( t == HTML.Tag.TEXTAREA )
+        {
+            String sName = ( String ) a.getAttribute( HTML.Attribute.NAME );
+            if ( sName != null && sName.equalsIgnoreCase( "wpTextbox1" ) )
+            {
+                m_nWikiArticleStart = pos;
+            }
+        }
+        else if ( t == HTML.Tag.DIV )
+        {
+            String sId = ( String ) a.getAttribute( HTML.Attribute.ID );
+            sClass = ( String ) a.getAttribute( HTML.Attribute.CLASS );
+            if ( sId != null  && sId.equalsIgnoreCase( "contentSub" ) )
+            {
+                m_bHTMLStartFound = true;
+            }
+            if ( sClass != null )
+            {
+                if ( sClass.equalsIgnoreCase( "printfooter" ) )
+                {
+                    m_nHTMLArticleEnd = pos;
+                }
+                else if ( sClass.equalsIgnoreCase( "noarticletext" ) )
+                {
+                    m_nNoArticleInd = pos;
+                }
+                else if ( sClass.equalsIgnoreCase( "errorbox" ) )
+                {
+                    m_nErrorInd = pos;
+                }
+            }
+        }
+        else if ( t == HTML.Tag.P )
+        {
+            sClass = ( String ) a.getAttribute( HTML.Attribute.CLASS );
+            if ( sClass != null && sClass.equalsIgnoreCase( "error" ) )
+            {
+                m_nErrorInd = pos;
+            }
+        }
+    }
+
+
+}
diff --git a/swext/mediawiki/src/com/sun/star/wiki/Helper.java b/swext/mediawiki/src/com/sun/star/wiki/Helper.java
new file mode 100644
index 000000000..bde53b39f
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/Helper.java
@@ -0,0 +1,1051 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import com.sun.star.awt.MessageBoxButtons;
+import com.sun.star.awt.MessageBoxType;
+import com.sun.star.awt.XControl;
+import com.sun.star.awt.XDialog;
+import com.sun.star.awt.XMessageBox;
+import com.sun.star.awt.XMessageBoxFactory;
+import com.sun.star.awt.XWindowPeer;
+import com.sun.star.beans.NamedValue;
+import com.sun.star.beans.PropertyValue;
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.container.XContainerQuery;
+import com.sun.star.container.XEnumeration;
+import com.sun.star.container.XNameAccess;
+import com.sun.star.container.XNameContainer;
+import com.sun.star.document.XDocumentPropertiesSupplier;
+import com.sun.star.document.XDocumentProperties;
+import com.sun.star.frame.XModel;
+import com.sun.star.frame.XModuleManager;
+import com.sun.star.io.XInputStream;
+import com.sun.star.io.XOutputStream;
+import com.sun.star.lang.XMultiComponentFactory;
+import com.sun.star.lang.XMultiServiceFactory;
+import com.sun.star.lang.XComponent;
+import com.sun.star.system.SystemShellExecuteFlags;
+import com.sun.star.system.XSystemShellExecute;
+import com.sun.star.task.UrlRecord;
+import com.sun.star.task.XInteractionHandler;
+import com.sun.star.task.XMasterPasswordHandling;
+import com.sun.star.task.XPasswordContainer;
+import com.sun.star.uno.AnyConverter;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+import com.sun.star.util.XChangesBatch;
+import java.net.*;
+import java.io.*;
+import javax.net.ssl.HttpsURLConnection;
+import javax.net.ssl.SSLException;
+import javax.swing.text.html.HTMLEditorKit;
+
+
+public class Helper
+{
+    public static final int GENERALSEND_ERROR = 0;
+    public static final int NOWIKIFILTER_ERROR = 1;
+    public static final int NOURLCONNECTION_ERROR = 2;
+    public static final int WRONGLOGIN_ERROR = 3;
+    public static final int INVALIDURL_ERROR = 4;
+    public static final int NOURL_ERROR = 5;
+
+    public static final int DLG_SENDTITLE = 6;
+    public static final int DLG_WIKIARTICLE = 7;
+
+    public static final int DLG_OK = 9;
+
+    // 11 is reserved
+    public static final int DLG_ADDBUTTON = 12;
+    public static final int DLG_EDITBUTTON = 13;
+    public static final int DLG_SENDBUTTON = 14;
+    public static final int DLG_REMOVEBUTTON = 15;
+
+    public static final int DLG_EDITSETTING_URLLABEL = 16;
+    public static final int DLG_EDITSETTING_USERNAMELABEL = 17;
+    public static final int DLG_EDITSETTING_PASSWORDLABEL = 18;
+
+    public static final int DLG_SENDTOMEDIAWIKI_LABEL1 = 20;
+    public static final int DLG_SENDTOMEDIAWIKI_LABEL2 = 21;
+    public static final int DLG_SENDTOMEDIAWIKI_LABEL3 = 22;
+    public static final int DLG_SENDTOMEDIAWIKI_MINORCHECK = 23;
+    public static final int DLG_SENDTOMEDIAWIKI_BROWSERCHECK = 24;
+    public static final int UNKNOWNCERT_ERROR = 25;
+    public static final int DLG_MEDIAWIKI_TITLE = 26;
+    public static final int DLG_EDITSETTING_ACCOUNTLINE = 27;
+    public static final int DLG_EDITSETTING_WIKILINE = 28;
+    public static final int DLG_EDITSETTING_SAVEBOX = 29;
+    public static final int CANCELSENDING_ERROR = 30;
+    public static final int DLG_MEDIAWIKIEXTENSION_STRING = 31;
+    public static final int DLG_WIKIPAGEEXISTS_LABEL1 = 32;
+
+    private static final int STRINGS_NUM = 33;
+
+    private static final String[] m_pEntryNames = { "GeneralSendError",
+                                                    "NoWikiFilter",
+                                                    "NoConnectionToURL",
+                                                    "WrongLogin",
+                                                    "InvalidURL",
+                                                    "NoURL",
+                                                    "Dlg_SendTitle",
+                                                    "Dlg_WikiArticle",
+                                                    "Dlg_No",
+                                                    "Dlg_OK",
+                                                    "Dlg_Yes",
+                                                    null, // reserved
+                                                    "Dlg_AddButton",
+                                                    "Dlg_EditButton",
+                                                    "Dlg_SendButton",
+                                                    "Dlg_RemoveButton",
+                                                    "Dlg_EditSetting_UrlLabel",
+                                                    "Dlg_EditSetting_UsernameLabel",
+                                                    "Dlg_EditSetting_PasswordLabel",
+                                                    "Dlg_NewWikiPage_Label1",
+                                                    "Dlg_SendToMediaWiki_Label1",
+                                                    "Dlg_SendToMediaWiki_Label2",
+                                                    "Dlg_SendToMediaWiki_Label3",
+                                                    "Dlg_SendToMediaWiki_MinorCheck",
+                                                    "Dlg_SendToMediaWiki_BrowserCheck",
+                                                    "UnknownCert",
+                                                    "Dlg_MediaWiki_Title",
+                                                    "Dlg_EditSetting_AccountLine",
+                                                    "Dlg_EditSetting_WikiLine",
+                                                    "Dlg_EditSetting_SaveBox",
+                                                    "CancelSending",
+                                                    "Dlg_MediaWiki_Extension_String",
+                                                    "Dlg_WikiPageExists_Label1" };
+
+    private static String[] m_pConfigStrings;
+
+    private static boolean m_bAllowConnection = true;
+
+    private static Boolean m_bShowInBrowser = null;
+
+    private static XPasswordContainer m_xPasswordContainer;
+    private static XInteractionHandler m_xInteractionHandler;
+
+    synchronized protected static String GetLocalizedString( XComponentContext xContext, int nID )
+        throws com.sun.star.uno.Exception
+    {
+        if ( nID >= STRINGS_NUM )
+            throw new com.sun.star.uno.RuntimeException();
+
+        if ( m_pConfigStrings == null )
+        {
+            XNameAccess xNameAccess = GetConfigNameAccess( xContext, "org.openoffice.Office.Custom.WikiExtension/Strings" );
+
+            String[] pStrings = new String[STRINGS_NUM];
+            for ( int nInd = 0; nInd < STRINGS_NUM; nInd++ )
+                if ( m_pEntryNames[nInd] != null )
+                    pStrings[nInd] = AnyConverter.toString( xNameAccess.getByName( m_pEntryNames[nInd] ) );
+                else
+                    pStrings[nInd] = "";
+
+            m_pConfigStrings = pStrings;
+        }
+
+        return m_pConfigStrings[nID];
+    }
+
+    synchronized protected static void AllowConnection( boolean bAllow )
+    {
+        m_bAllowConnection = bAllow;
+        // TODO: how to shut down any pending connections?
+        // hope it doesn't matter?
+    }
+
+    synchronized protected static boolean IsConnectionAllowed()
+    {
+        return m_bAllowConnection;
+    }
+
+    synchronized protected static boolean GetShowInBrowserByDefault( XComponentContext xContext )
+    {
+        if ( m_bShowInBrowser == null )
+        {
+            try
+            {
+                XNameAccess xAccess = Helper.GetConfigNameAccess( xContext, "org.openoffice.Office.Custom.WikiExtension/Settings" );
+                m_bShowInBrowser = Boolean.valueOf( AnyConverter.toBoolean( xAccess.getByName( "PreselectShowBrowser" ) ) );
+            }
+            catch( com.sun.star.uno.Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+
+        return m_bShowInBrowser != null ? m_bShowInBrowser.booleanValue() : false;
+    }
+
+    synchronized protected static void SetShowInBrowserByDefault( XComponentContext xContext, boolean bValue )
+    {
+        try
+        {
+            m_bShowInBrowser = Boolean.valueOf( bValue );
+
+            XPropertySet xProps = Helper.GetConfigProps( xContext, "org.openoffice.Office.Custom.WikiExtension/Settings" );
+            xProps.setPropertyValue( "PreselectShowBrowser", Boolean.valueOf( bValue ) );
+            XChangesBatch xBatch = UnoRuntime.queryInterface( XChangesBatch.class, xProps );
+            if ( xBatch != null )
+                xBatch.commitChanges();
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    synchronized protected static XPasswordContainer GetPasswordContainer( XComponentContext xContext )
+        throws com.sun.star.uno.Exception
+    {
+        if ( m_xPasswordContainer == null && xContext != null )
+        {
+            XMultiComponentFactory xFactory = xContext.getServiceManager();
+            if ( xFactory != null )
+                m_xPasswordContainer = UnoRuntime.queryInterface(
+                                        XPasswordContainer.class,
+                                        xFactory.createInstanceWithContext( "com.sun.star.task.PasswordContainer", xContext ) );
+        }
+
+        if ( m_xPasswordContainer == null )
+            throw new com.sun.star.uno.RuntimeException();
+
+        return m_xPasswordContainer;
+    }
+
+    synchronized protected static XInteractionHandler GetInteractionHandler( XComponentContext xContext )
+        throws com.sun.star.uno.Exception
+    {
+        if ( m_xInteractionHandler == null && xContext != null )
+        {
+            XMultiComponentFactory xFactory = xContext.getServiceManager();
+            if ( xFactory != null )
+                m_xInteractionHandler = UnoRuntime.queryInterface(
+                                        XInteractionHandler.class,
+                                        xFactory.createInstanceWithContext( "com.sun.star.task.InteractionHandler", xContext ) );
+        }
+
+        if ( m_xInteractionHandler == null )
+            throw new com.sun.star.uno.RuntimeException();
+
+        return m_xInteractionHandler;
+    }
+
+    protected static String GetMainURL( String sWebPage, String sVURL )
+    {
+        String sResultURL = "";
+        try
+        {
+            StringReader aReader = new StringReader( sWebPage );
+            HTMLEditorKit.Parser aParser = GetHTMLParser();
+            EditPageParser aCallback = new EditPageParser();
+
+            aParser.parse( aReader, aCallback, true );
+            sResultURL = aCallback.m_sMainURL;
+
+            if ( !sResultURL.startsWith( "http" ) )
+            {
+                //if the url is only relative then complete it
+                URL aURL = new URL( sVURL );
+                sResultURL = aURL.getProtocol() + "://" + aURL.getHost() + sResultURL;
+            }
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+
+        if ( sResultURL.length() == 0 )
+        {
+            // usually that should not happen
+            // workaround: try to get index.php from the provided URL
+            int nIndex = sVURL.indexOf( "index.php" );
+            if ( nIndex >= 0 )
+                sResultURL = sVURL.substring( 0, nIndex );
+        }
+
+        return sResultURL;
+    }
+
+    protected static String GetRedirectURL( String sWebPage, String sURL )
+    {
+        //scrape the HTML source and find the EditURL
+        // TODO/LATER: Use parser in future
+
+        int nInd = sWebPage.indexOf( "http-equiv=\"refresh\"" );
+        if ( nInd == -1 )
+            return "";
+
+        String sResultURL = "";
+        int nContent = sWebPage.indexOf( "content=", nInd );
+        if ( nContent > 0 )
+        {
+            int nURL = sWebPage.indexOf( "URL=", nContent );
+            if ( nURL > 0 )
+            {
+                int nEndURL = sWebPage.indexOf('"', nURL );
+                if ( nEndURL > 0 )
+                    sResultURL = sWebPage.substring( nURL + 4, nEndURL );
+            }
+        }
+
+        try
+        {
+            URL aURL = new URL( sURL );
+            if ( !sResultURL.startsWith( aURL.getProtocol() ))
+            {
+                //if the url is only relative then complete it
+                if ( sResultURL.startsWith( "/" ) )
+                    sResultURL = aURL.getProtocol() + "://" + aURL.getHost() + sResultURL;
+                else
+                    sResultURL = aURL.getProtocol() + "://" + aURL.getHost() + aURL.getPath() + sResultURL;
+            }
+        }
+        catch ( MalformedURLException ex )
+        {
+            ex.printStackTrace();
+        }
+
+        return sResultURL;
+
+    }
+
+    protected static String CreateTempFile( XComponentContext xContext )
+    {
+        String sURL = "";
+        try
+        {
+            Object oTempFile = xContext.getServiceManager().createInstanceWithContext( "com.sun.star.io.TempFile", xContext );
+            XPropertySet xPropertySet = UnoRuntime.queryInterface( XPropertySet.class, oTempFile );
+            xPropertySet.setPropertyValue( "RemoveFile", Boolean.FALSE );
+            sURL = ( String ) xPropertySet.getPropertyValue( "Uri" );
+
+            XInputStream xInputStream = UnoRuntime.queryInterface( XInputStream.class, oTempFile );
+            xInputStream.closeInput();
+            XOutputStream xOutputStream = UnoRuntime.queryInterface( XOutputStream.class, oTempFile );
+            xOutputStream.closeOutput();
+        } catch ( com.sun.star.uno.Exception ex )
+        {
+            ex.printStackTrace();
+        }
+        return sURL;
+    }
+
+    private static void close(BufferedReader c) {
+        if (c == null) return;
+        try {
+            c.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    protected static String EachLine( String sURL )
+    {
+        String sText = "";
+        BufferedReader aBufReader = null;
+        try
+        {
+            URL aURL = new URL( sURL );
+            File aFile = new File( aURL.getFile() );
+            InputStreamReader aInputReader = new InputStreamReader( new FileInputStream( aFile ), "UTF-8" );
+            aBufReader = new BufferedReader( aInputReader );
+
+            StringBuffer aBuf = new StringBuffer();
+            String sEachLine = aBufReader.readLine();
+
+            while( sEachLine != null )
+            {
+                aBuf.append( sEachLine );
+                aBuf.append( "\n" );
+
+                sEachLine = aBufReader.readLine();
+            }
+            sText = aBuf.toString();
+
+            aBufReader.close();
+        } catch ( Exception e ) {
+            e.printStackTrace();
+        }
+        finally {
+            close(aBufReader);
+        }
+        return sText;
+    }
+
+    protected static String GetDocTitle( XModel xDoc )
+    {
+        XDocumentPropertiesSupplier xDocPropSup =
+            UnoRuntime.queryInterface(XDocumentPropertiesSupplier.class, xDoc);
+        XDocumentProperties xDocProps = xDocPropSup.getDocumentProperties();
+        return xDocProps.getTitle();
+    }
+
+    protected static void SetDocTitle( XModel xDoc, String sTitle )
+    {
+        XDocumentPropertiesSupplier xDocPropSup =
+            UnoRuntime.queryInterface(XDocumentPropertiesSupplier.class, xDoc);
+        XDocumentProperties xDocProps = xDocPropSup.getDocumentProperties();
+        xDocProps.setTitle(sTitle);
+    }
+
+    protected static String GetDocServiceName( XComponentContext xContext, XModel xModel )
+    {
+        String aDocServiceName = "";
+        if ( xModel != null && xContext != null )
+        {
+            try
+            {
+                XMultiComponentFactory xFactory = xContext.getServiceManager();
+                if ( xFactory == null )
+                    throw new com.sun.star.uno.RuntimeException();
+
+                Object oModuleManager = xFactory.createInstanceWithContext( "com.sun.star.frame.ModuleManager", xContext );
+                XModuleManager xModuleManager = UnoRuntime.queryInterface( XModuleManager.class, oModuleManager );
+                if ( xModuleManager != null )
+                    aDocServiceName = xModuleManager.identify( xModel );
+            }
+            catch( java.lang.Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+
+        return aDocServiceName;
+    }
+
+    protected static String GetFilterName( XComponentContext xContext, String aTypeName, String aDocServiceName )
+    {
+        if ( xContext == null || aTypeName == null || aTypeName.length() == 0
+                || aDocServiceName == null || aDocServiceName.length() == 0 ) {
+            return "";
+        }
+        String aFilterName = "";
+        try
+        {
+            Object oFilterFactory = xContext.getServiceManager().createInstanceWithContext( "com.sun.star.document.FilterFactory", xContext );
+            XContainerQuery xQuery = UnoRuntime.queryInterface( XContainerQuery.class, oFilterFactory );
+            if ( xQuery != null )
+            {
+                NamedValue[] aRequest = new NamedValue[2];
+                aRequest[0] = new NamedValue( "Type", aTypeName );
+                aRequest[1] = new NamedValue( "DocumentService", aDocServiceName );
+
+                XEnumeration xSet = xQuery.createSubSetEnumerationByProperties( aRequest );
+                if ( xSet != null )
+                {
+                    boolean bAcceptable = false;
+                    while ( xSet.hasMoreElements() && !bAcceptable )
+                    {
+                        PropertyValue[] pFilterProps = ( PropertyValue[] )AnyConverter.toArray( xSet.nextElement() );
+                        if ( pFilterProps != null )
+                        {
+                            int nLen = pFilterProps.length;
+                            String aTmpFilter = null;
+
+                            for ( int nInd = 0; nInd < nLen; nInd++ )
+                            {
+                                if ( pFilterProps[nInd].Name.equals( "Name" ) )
+                                    aTmpFilter = AnyConverter.toString( pFilterProps[nInd].Value );
+                                else if ( pFilterProps[nInd].Name.equals( "Flags" ) )
+                                    bAcceptable = ( ( AnyConverter.toInt( pFilterProps[nInd].Value ) & 2 ) == 2 ); // must allow export
+                            }
+
+                            if ( bAcceptable )
+                                aFilterName = aTmpFilter;
+                        }
+                    }
+                }
+            }
+        }
+        catch( java.lang.Exception e )
+        {
+            e.printStackTrace();
+        }
+
+        return aFilterName;
+    }
+
+    private static XMultiServiceFactory GetConfigurationProvider( XComponentContext xContext )
+        throws com.sun.star.uno.Exception
+    {
+        XMultiServiceFactory xConfigurationProvider = null;
+        if ( xContext != null )
+        {
+            XMultiComponentFactory xFactory = xContext.getServiceManager();
+            Object oConfigProvider = xFactory.createInstanceWithContext( "com.sun.star.configuration.ConfigurationProvider", xContext );
+            xConfigurationProvider = UnoRuntime.queryInterface( XMultiServiceFactory.class, oConfigProvider );
+        }
+
+        if ( xConfigurationProvider == null )
+            throw new com.sun.star.uno.RuntimeException();
+
+        return xConfigurationProvider;
+    }
+
+    private static Object GetConfig( XComponentContext xContext, String sNodepath, boolean bWriteAccess )
+        throws com.sun.star.uno.Exception
+    {
+        if ( xContext == null || sNodepath == null )
+            throw new com.sun.star.uno.RuntimeException();
+
+        PropertyValue aVal = new PropertyValue();
+        aVal.Name = "nodepath";
+        aVal.Value = sNodepath;
+        Object[] aArgs = new Object[1];
+        aArgs[0] = aVal;
+
+        return GetConfigurationProvider( xContext ).createInstanceWithArguments(
+                                    ( bWriteAccess ? "com.sun.star.configuration.ConfigurationUpdateAccess"
+                                                   : "com.sun.star.configuration.ConfigurationAccess" ),
+                                    aArgs );
+    }
+
+    private static XPropertySet GetConfigProps( XComponentContext xContext, String sNodepath )
+        throws com.sun.star.uno.Exception
+    {
+        XPropertySet xProps = UnoRuntime.queryInterface( XPropertySet.class, GetConfig( xContext, sNodepath, true ) );
+        if ( xProps == null )
+            throw new com.sun.star.uno.RuntimeException();
+
+        return xProps;
+    }
+
+
+    protected static XNameContainer GetConfigNameContainer( XComponentContext xContext, String sNodepath )
+        throws com.sun.star.uno.Exception
+    {
+        XNameContainer xContainer = UnoRuntime.queryInterface( XNameContainer.class, GetConfig( xContext, sNodepath, true ) );
+        if ( xContainer == null )
+            throw new com.sun.star.uno.RuntimeException();
+
+        return xContainer;
+    }
+
+    protected static XNameAccess GetConfigNameAccess( XComponentContext xContext, String sNodepath )
+        throws com.sun.star.uno.Exception
+    {
+        XNameAccess xNameAccess = UnoRuntime.queryInterface( XNameAccess.class, GetConfig( xContext, sNodepath, false ) );
+        if ( xNameAccess == null )
+            throw new com.sun.star.uno.RuntimeException();
+
+        return xNameAccess;
+    }
+
+    private static Proxy GetConfigurationProxy(URI uri, XComponentContext xContext)
+    {
+        assert(uri != null);
+        assert(xContext != null);
+
+        try
+        {
+            XNameAccess xNameAccess = GetConfigNameAccess( xContext, "org.openoffice.Inet/Settings" );
+
+            int nProxyType = AnyConverter.toInt( xNameAccess.getByName( "ooInetProxyType" ) );
+            if ( nProxyType == 0 ) {
+                return Proxy.NO_PROXY;
+            } else {
+                if ( nProxyType == 1 )
+                {
+                    // system proxy
+                    return null;
+                }
+                else if ( nProxyType == 2 )
+                {
+                    String aProxyNameProp = "ooInetHTTPProxyName";
+                    String aProxyPortProp = "ooInetHTTPProxyPort";
+
+                    if (uri.getScheme().equals("https"))
+                    {
+                        aProxyNameProp = "ooInetHTTPSProxyName";
+                        aProxyPortProp = "ooInetHTTPSProxyPort";
+                    }
+
+                    String aProxyName = AnyConverter.toString( xNameAccess.getByName( aProxyNameProp ) );
+
+                    int nProxyPort = 80;
+
+                    Object aPortNo = xNameAccess.getByName( aProxyPortProp );
+                    if ( !AnyConverter.isVoid( aPortNo ) )
+                        nProxyPort = AnyConverter.toInt( aPortNo );
+
+                    if ( nProxyPort == -1 )
+                        nProxyPort = 80;
+
+                    // TODO: check whether the URL is in the NoProxy list
+                    InetSocketAddress address = new InetSocketAddress(aProxyName, nProxyPort);
+                    return new Proxy(Proxy.Type.HTTP, address);
+                }
+            }
+        }
+        catch( java.lang.Exception e )
+        {
+            e.printStackTrace();
+        }
+        return null; // invalid configuration value?
+    }
+
+    protected static void ShowURLInBrowser( XComponentContext xContext, String sURL )
+    {
+        if ( xContext != null && sURL != null && sURL.length() > 0 )
+        {
+            try
+            {
+                Object oSystemShell = xContext.getServiceManager().createInstanceWithContext( "com.sun.star.system.SystemShellExecute", xContext );
+                XSystemShellExecute xSystemShell = UnoRuntime.queryInterface( XSystemShellExecute.class, oSystemShell );
+                if ( xSystemShell != null )
+                    xSystemShell.execute( sURL, "", SystemShellExecuteFlags.URIS_ONLY );
+            }
+            catch( Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    protected static HttpURLConnection PrepareMethod(String method, URI uri, XComponentContext xContext)
+        throws WikiCancelException, IOException, SSLException
+    {
+        assert(method != null);
+        assert(uri != null);
+        assert(xContext != null);
+
+        if (!IsConnectionAllowed()) {
+            throw new WikiCancelException();
+        }
+
+        if (java.net.CookieHandler.getDefault() == null) {
+            // set a cookie manager so cookies don't get lost
+            // apparently it's not possible to do that on a per-connection
+            // basis but only globally?
+            java.net.CookieHandler.setDefault(new java.net.CookieManager());
+        }
+
+        Proxy proxy = GetConfigurationProxy(uri, xContext);
+        HttpURLConnection conn = null;
+        if (proxy != null) {
+            conn = (HttpURLConnection) uri.toURL().openConnection(proxy);
+        } else {
+            conn = (HttpURLConnection) uri.toURL().openConnection();
+        }
+        if (uri.getScheme().equals("https") && AllowUnknownCert(xContext, uri.getHost()))
+        {
+            // let unknown certificates be accepted
+            ((HttpsURLConnection) conn).setSSLSocketFactory(new WikiProtocolSocketFactory());
+        }
+
+// enable this to help debug connections where TLS gets in the way
+//        ((HttpsURLConnection) conn).setSSLSocketFactory(new LoggingProtocolSocketFactory());
+
+        conn.setRequestMethod(method);
+        // TODO: is it possible to read the version from the extension metadata?
+        conn.setRequestProperty("User-Agent", "LibreOffice Wiki Publisher 1.2.0");
+        // note: don't connect yet so that the caller can do some further setup
+
+        return conn;
+    }
+
+    protected static String ReadResponseBody(HttpURLConnection conn)
+        throws IOException
+    {
+        String ret = null;
+        InputStream stream = conn.getInputStream();
+        try {
+            // there doesn't seem to be an easier way get the content encoding
+            String type = conn.getContentType();
+            String charset = "ISO-8859-1"; // default in RFC2616
+            for (String param : type.split(";")) {
+                if (param.trim().toLowerCase().startsWith("charset=")) {
+                    charset = param.trim().substring("charset=".length());
+                    break;
+                }
+            }
+            BufferedReader br =
+                new BufferedReader(new InputStreamReader(stream, charset));
+            StringBuilder buf = new StringBuilder();
+            String line;
+            while ((line = br.readLine()) != null) {
+                buf.append(line);
+            }
+            ret = buf.toString();
+        } finally {
+            stream.close();
+        }
+        return ret;
+    }
+
+    private static class HTMLParse extends HTMLEditorKit
+    {
+
+        @Override
+        public HTMLEditorKit.Parser getParser()
+        {
+            return super.getParser();
+        }
+    }
+
+    protected static HTMLEditorKit.Parser GetHTMLParser()
+    {
+        return new HTMLParse().getParser();
+    }
+
+    private static boolean LoginReportsError( String sRespond )
+    {
+        boolean bResult = true;
+        if ( sRespond != null )
+        {
+            try
+            {
+                StringReader aReader = new StringReader( sRespond );
+                HTMLEditorKit.Parser aParser = GetHTMLParser();
+                EditPageParser aCallback = new EditPageParser();
+
+                aParser.parse( aReader, aCallback, true );
+                bResult = ( aCallback.m_nErrorInd >= 0 );
+            }
+            catch( Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+
+        return bResult;
+    }
+
+    private static String GetLoginToken( String sLoginPage )
+    {
+        String sResult = "";
+        if ( sLoginPage != null && sLoginPage.length() > 0 )
+        {
+            try
+            {
+                StringReader aReader = new StringReader( sLoginPage );
+                HTMLEditorKit.Parser aParser = Helper.GetHTMLParser();
+                EditPageParser aCallbacks = new EditPageParser();
+
+                aParser.parse( aReader, aCallbacks, true );
+                sResult = aCallbacks.m_sLoginToken;
+            }
+            catch( Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+
+        return sResult;
+    }
+
+    protected static boolean Login(URI aMainURL, String sWikiUser, String sWikiPass, XComponentContext xContext)
+        throws java.io.IOException, WikiCancelException, URISyntaxException
+    {
+        boolean success = false;
+
+        if ( sWikiUser != null && sWikiPass != null && xContext != null )
+        {
+            String sLoginPage = null;
+            URI aURI = new URI(aMainURL.toString() + "index.php?title=Special:Userlogin");
+            HttpURLConnection connGet = PrepareMethod("GET", aURI, xContext);
+            connGet.setInstanceFollowRedirects(true);
+
+            connGet.connect();
+            int nResultCode = connGet.getResponseCode();
+            if (nResultCode == 200) {
+                sLoginPage = ReadResponseBody(connGet);
+            }
+
+            if ( sLoginPage != null )
+            {
+                String sLoginToken = GetLoginToken( sLoginPage );
+
+                URI aPostURI = new URI(aMainURL.toString() + "index.php?title=Special:Userlogin&action=submitlogin");
+
+                HttpURLConnection connPost = PrepareMethod("POST", aPostURI, xContext);
+                connPost.setInstanceFollowRedirects(true);
+                connPost.setDoInput(true);
+                connPost.setDoOutput(true);
+                connPost.connect();
+
+                OutputStreamWriter post = new OutputStreamWriter(connPost.getOutputStream(), "UTF-8");
+                post.write("wpName=");
+                post.write(URLEncoder.encode(sWikiUser, "UTF-8"));
+                post.write("&wpRemember=1");
+                post.write("&wpPassword=");
+                post.write(URLEncoder.encode(sWikiPass, "UTF-8"));
+
+                if (sLoginToken.length() > 0) {
+                    post.write("&wpLoginToken=");
+                    post.write(URLEncoder.encode(sLoginToken, "UTF-8"));
+                }
+
+                String[][] pArgs = GetSpecialArgs( xContext, aMainURL.getHost() );
+                if ( pArgs != null )
+                    for ( int nArgInd = 0; nArgInd < pArgs.length; nArgInd++ )
+                        if ( pArgs[nArgInd].length == 2 && pArgs[nArgInd][0] != null && pArgs[nArgInd][1] != null )
+                        {
+                            post.write("&");
+                            post.write(URLEncoder.encode(pArgs[nArgInd][0], "UTF-8"));
+                            post.write("=");
+                            post.write(URLEncoder.encode(pArgs[nArgInd][0], "UTF-8"));
+                        }
+
+                post.flush();
+                post.close();
+
+                nResultCode = connPost.getResponseCode();
+
+                if ( nResultCode == 200 )
+                {
+                    String sResult = ReadResponseBody(connPost);
+                    if ( !LoginReportsError( sResult ) )
+                        success = true;
+                }
+            }
+        }
+
+        return success;
+    }
+
+    protected static String[] GetPasswordsForURLAndUser( XComponentContext xContext, String sURL, String sUserName )
+    {
+        String[] aResult = null;
+
+        try
+        {
+            if ( xContext != null && sURL != null && sURL.length() > 0 && sUserName != null && sUserName.length() > 0 )
+            {
+                UrlRecord aRec = GetPasswordContainer( xContext ).findForName( sURL, sUserName, GetInteractionHandler( xContext ) );
+                if ( aRec != null && aRec.UserList != null && aRec.UserList.length > 0
+                  && aRec.UserList[0].UserName.equals( sUserName ) )
+                    aResult = aRec.UserList[0].Passwords;
+            }
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+
+        return aResult;
+    }
+
+    protected static boolean PasswordStoringIsAllowed( XComponentContext xContext )
+    {
+        boolean bResult = false;
+        try
+        {
+            XMasterPasswordHandling xMasterHdl = UnoRuntime.queryInterface( XMasterPasswordHandling.class, GetPasswordContainer( xContext ) );
+            if ( xMasterHdl != null )
+                bResult = xMasterHdl.isPersistentStoringAllowed();
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+
+        return bResult;
+    }
+
+    protected static void ShowError( XComponentContext xContext, XDialog xDialog, int nTitleID, int nErrorID, String sArg, boolean bQuery )
+    {
+        XWindowPeer xPeer = null;
+        XControl xControl = UnoRuntime.queryInterface( XControl.class, xDialog );
+        if ( xControl != null )
+            xPeer = xControl.getPeer();
+        ShowError( xContext, xPeer, nTitleID, nErrorID, sArg, bQuery );
+    }
+
+    protected static boolean ShowError( XComponentContext xContext, XWindowPeer xParentPeer, int nTitleID, int nErrorID, String sArg, boolean bQuery )
+    {
+        boolean bResult = false;
+
+        if ( xContext != null && nErrorID >= 0 && nErrorID < STRINGS_NUM )
+        {
+            String sError = null;
+            String sTitle = "";
+
+            try
+            {
+                sError = GetLocalizedString( xContext, nErrorID );
+                if ( sError != null && sArg != null )
+                    sError = sError.replaceAll( "\\$ARG1", sArg );
+
+                sTitle = GetLocalizedString( xContext, nTitleID );
+            }
+            catch( Exception e )
+            {
+                e.printStackTrace();
+            }
+
+            if ( sError == null )
+                sError = "Error: " + nErrorID;
+
+            if ( xParentPeer != null )
+            {
+                XMessageBoxFactory xMBFactory = null;
+                XMessageBox xMB = null;
+                try
+                {
+                    XMultiComponentFactory xFactory = xContext.getServiceManager();
+                    if ( xFactory != null )
+                        xMBFactory = UnoRuntime.queryInterface(
+                                     XMessageBoxFactory.class,
+                                     xFactory.createInstanceWithContext( "com.sun.star.awt.Toolkit", xContext ) );
+
+                    if ( xMBFactory != null )
+                    {
+                        if ( bQuery )
+                        {
+                            xMB = xMBFactory.createMessageBox(
+                                                     xParentPeer,
+                                                     MessageBoxType.QUERYBOX,
+                                                     MessageBoxButtons.BUTTONS_YES_NO | MessageBoxButtons.DEFAULT_BUTTON_NO,
+                                                     sTitle,
+                                                     sError );
+                        }
+                        else
+                        {
+                            xMB = xMBFactory.createMessageBox(
+                                                     xParentPeer,
+                                                     MessageBoxType.ERRORBOX,
+                                                     MessageBoxButtons.BUTTONS_OK,
+                                                     sTitle,
+                                                     sError );
+                        }
+                        if ( xMB != null )
+                        {
+                            bResult = MainThreadDialogExecutor.Execute( xContext, xMB );
+                        }
+                    }
+                }
+                catch( Exception e )
+                {
+                    e.printStackTrace();
+                }
+                finally
+                {
+                    if ( xMB != null )
+                        Dispose( xMB );
+                }
+            }
+        }
+
+        return bResult;
+    }
+
+    private static boolean AllowUnknownCert( XComponentContext xContext, String aURL )
+    {
+        try
+        {
+            XNameAccess xNameAccess = GetConfigNameAccess( xContext, "org.openoffice.Office.Custom.WikiExtension/SpecialData" );
+            if ( xNameAccess.hasByName( aURL ) )
+            {
+                XNameAccess xEntry = UnoRuntime.queryInterface( XNameAccess.class, xNameAccess.getByName( aURL ) );
+                if ( xEntry != null && xEntry.hasByName( "AllowUnknownCertificate" ) )
+                    return AnyConverter.toBoolean( xEntry.getByName( "AllowUnknownCertificate" ) );
+            }
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+
+        return false;
+    }
+
+    private static String[][] GetSpecialArgs( XComponentContext xContext, String aURL )
+    {
+        try
+        {
+            XNameAccess xNameAccess = GetConfigNameAccess( xContext, "org.openoffice.Office.Custom.WikiExtension/SpecialData" );
+            if ( xNameAccess.hasByName( aURL ) )
+            {
+                XNameAccess xEntry = UnoRuntime.queryInterface( XNameAccess.class, xNameAccess.getByName( aURL ) );
+                if ( xEntry != null )
+                {
+                    XNameAccess xArgs = UnoRuntime.queryInterface( XNameAccess.class, xEntry.getByName( "AdditionalLoginArguments" ) );
+                    if ( xArgs != null )
+                    {
+                        String[] pNames = xArgs.getElementNames();
+                        if ( pNames != null && pNames.length > 0 )
+                        {
+                            String[][] pResult = new String[pNames.length][2];
+                            for ( int nInd = 0; nInd < pNames.length; nInd++ )
+                            {
+                                XNameAccess xArgument = UnoRuntime.queryInterface( XNameAccess.class, xArgs.getByName( pNames[nInd] ) );
+                                if ( xArgument == null )
+                                    throw new com.sun.star.uno.RuntimeException();
+
+                                pResult[nInd][0] = pNames[nInd];
+                                pResult[nInd][1] = AnyConverter.toString( xArgument.getByName( "Value" ) );
+                            }
+
+                            return pResult;
+                        }
+                    }
+                }
+            }
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    protected static boolean AllowThreadUsage( XComponentContext xContext )
+    {
+        if ( xContext != null )
+        {
+            try
+            {
+                XMultiComponentFactory xFactory = xContext.getServiceManager();
+                if ( xFactory == null )
+                    throw new com.sun.star.uno.RuntimeException();
+
+                Object oCheckCallback = xFactory.createInstanceWithContext( "com.sun.star.awt.AsyncCallback", xContext );
+                return ( oCheckCallback != null );
+            }
+            catch( Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+
+        return false;
+    }
+
+    public static void Dispose( Object oObject )
+    {
+        if ( oObject != null )
+        {
+            try
+            {
+                XComponent xComp = UnoRuntime.queryInterface( XComponent.class, oObject );
+                if ( xComp != null )
+                    xComp.dispose();
+            }
+            catch( Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+
diff --git a/swext/mediawiki/src/com/sun/star/wiki/MANIFEST.MF b/swext/mediawiki/src/com/sun/star/wiki/MANIFEST.MF
new file mode 100644
index 000000000..6f900e21f
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/MANIFEST.MF
@@ -0,0 +1 @@
+RegistrationClassName: com.sun.star.wiki.WikiEditorImpl
diff --git a/swext/mediawiki/src/com/sun/star/wiki/MainThreadDialogExecutor.java b/swext/mediawiki/src/com/sun/star/wiki/MainThreadDialogExecutor.java
new file mode 100644
index 000000000..a6ee07fc8
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/MainThreadDialogExecutor.java
@@ -0,0 +1,158 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import com.sun.star.uno.Any;
+import com.sun.star.awt.XDialog;
+import com.sun.star.awt.XCallback;
+import com.sun.star.awt.XMessageBox;
+import com.sun.star.awt.XRequestCallback;
+import com.sun.star.lang.XMultiComponentFactory;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+
+public class MainThreadDialogExecutor implements XCallback
+{
+    private WikiDialog m_aWikiDialog;
+    private XDialog    m_xDialog;
+    private XMessageBox m_xMessageBox;
+    private boolean    m_bResult = false;
+    private boolean    m_bCalled = false;
+    private boolean    m_bClose = false;
+
+    public static boolean Show( XComponentContext xContext, WikiDialog aWikiDialog )
+    {
+        MainThreadDialogExecutor aExecutor = new MainThreadDialogExecutor( aWikiDialog );
+        return GetCallback( xContext, aExecutor );
+    }
+
+
+
+    public static boolean Execute( XComponentContext xContext, XMessageBox xMessageBox )
+    {
+        MainThreadDialogExecutor aExecutor = new MainThreadDialogExecutor( xMessageBox );
+        return GetCallback( xContext, aExecutor );
+    }
+
+    public static boolean Close( XComponentContext xContext, XDialog xDialog )
+    {
+        MainThreadDialogExecutor aExecutor = new MainThreadDialogExecutor( xDialog );
+        aExecutor.m_bClose = true;
+        aExecutor.m_bCalled = true; // no yielding, asynchronous closing
+        return GetCallback( xContext, aExecutor );
+    }
+
+    private static boolean GetCallback( XComponentContext xContext, MainThreadDialogExecutor aExecutor )
+    {
+        if (aExecutor == null)
+          return false;
+
+        try
+        {
+            String aThreadName = null;
+            Thread aCurThread = Thread.currentThread();
+            if ( aCurThread != null )
+                aThreadName = aCurThread.getName();
+
+            if ( aThreadName != null && aThreadName.equals( "com.sun.star.thread.WikiEditorSendingThread" ) )
+            {
+                // the main thread should be accessed asynchronously
+                XMultiComponentFactory xFactory = xContext.getServiceManager();
+                if ( xFactory == null )
+                    throw new com.sun.star.uno.RuntimeException();
+
+                XRequestCallback xRequest = UnoRuntime.queryInterface(
+                    XRequestCallback.class,
+                    xFactory.createInstanceWithContext( "com.sun.star.awt.AsyncCallback", xContext ) );
+                if ( xRequest != null )
+                {
+                    xRequest.addCallback( aExecutor, Any.VOID );
+                    do
+                    {
+                        Thread.yield();
+                    }
+                    while( !aExecutor.m_bCalled );
+                }
+            }
+            else
+            {
+                // handle it as a main thread
+                aExecutor.notify( Any.VOID );
+            }
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+
+        return aExecutor.GetResult();
+    }
+
+    private MainThreadDialogExecutor( WikiDialog aWikiDialog )
+    {
+        m_aWikiDialog = aWikiDialog;
+    }
+
+    private MainThreadDialogExecutor( XDialog xDialog )
+    {
+        m_xDialog = xDialog;
+    }
+
+    private MainThreadDialogExecutor( XMessageBox xMessageBox )
+    {
+        m_xMessageBox = xMessageBox;
+    }
+
+    private boolean GetResult()
+    {
+        return m_bResult;
+    }
+
+    public void notify( Object aData )
+    {
+        if ( m_aWikiDialog != null )
+            m_bResult = m_aWikiDialog.show();
+        else if ( m_xDialog != null )
+        {
+            if ( !m_bClose )
+                m_bResult = ( m_xDialog.execute() == 1 );
+            else
+            {
+                try
+                {
+                    m_xDialog.endExecute();
+                }
+                catch( Exception e )
+                {
+                    e.printStackTrace();
+                }
+                m_bResult = true;
+            }
+        }
+        else if ( m_xMessageBox != null )
+        {
+            int nRes = m_xMessageBox.execute();
+            m_bResult = ( nRes == com.sun.star.awt.MessageBoxResults.OK
+                          || nRes == com.sun.star.awt.MessageBoxResults.YES );
+        }
+
+        m_bCalled = true;
+    }
+}
+
diff --git a/swext/mediawiki/src/com/sun/star/wiki/Settings.java b/swext/mediawiki/src/com/sun/star/wiki/Settings.java
new file mode 100644
index 000000000..34e11e13e
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/Settings.java
@@ -0,0 +1,310 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.container.XNameAccess;
+import com.sun.star.container.XNameContainer;
+import com.sun.star.container.XNameReplace;
+import com.sun.star.lang.XSingleServiceFactory;
+import com.sun.star.uno.AnyConverter;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+import com.sun.star.util.XChangesBatch;
+
+public class Settings
+{
+
+    /* Singleton */
+    private static Settings m_instance;
+
+
+    private final XComponentContext m_xContext;
+    private final List<Map<String, String>> m_WikiConnections = new ArrayList<Map<String, String>>();
+    private final List<Map<String, Object>> m_aWikiDocs = new ArrayList<Map<String, Object>>();
+
+    private Settings( XComponentContext ctx )
+    {
+        m_xContext=ctx;
+        loadConfiguration();
+    }
+
+
+    public static synchronized Settings getSettings( XComponentContext ctx )
+    {
+        if ( m_instance == null )
+            m_instance = new Settings( ctx );
+        return m_instance;
+    }
+
+
+    public void addWikiCon ( Map<String, String> wikiCon )
+    {
+        m_WikiConnections.add( wikiCon );
+    }
+
+
+    private String getWikiConUrlByNumber( int num )
+    {
+        String url = "";
+        if ( num >=0 && num < m_WikiConnections.size() )
+        {
+            Map<String,String> ht = m_WikiConnections.get( num );
+            url = ht.get( "Url" );
+        }
+        return url;
+    }
+
+
+    public void addWikiDoc ( Map<String, Object> aWikiDoc )
+    {
+        String sURL = ( String ) aWikiDoc.get( "CompleteUrl" );
+        Map<String,Object> aEntry = getDocByCompleteUrl( sURL );
+
+        if ( aEntry != null )
+        {
+            // add doc to the end, even if it has been added before
+            m_aWikiDocs.remove( aEntry );
+        }
+        else if ( m_aWikiDocs.size() > 10 )
+        {
+            // if the number of elements has reached maximum the oldest element should be removed
+            m_aWikiDocs.remove( 0 );
+        }
+
+        m_aWikiDocs.add( aWikiDoc );
+    }
+
+
+    public Object[] getWikiDocList( int serverid )
+    {
+        String wikiserverurl = getWikiConUrlByNumber( serverid );
+        List<String> theDocs = new ArrayList<String>();
+        String [] docs = new String[0];
+        for ( int i=0; i<m_aWikiDocs.size(); i++ )
+        {
+            Map<String,Object> ht = m_aWikiDocs.get( i );
+            String docurl = ( String ) ht.get( "Url" );
+            if ( docurl.equals( wikiserverurl ) )
+            {
+                theDocs.add( (String ) ht.get( "Doc" ) );
+            }
+        }
+        return theDocs.toArray( docs );
+    }
+
+    public String[] getWikiURLs()
+    {
+        String [] WikiList = new String [m_WikiConnections.size()];
+        for ( int i=0; i<m_WikiConnections.size(); i++ )
+        {
+            Map<String,String> ht = m_WikiConnections.get( i );
+            WikiList[i] = ht.get( "Url" );
+        }
+        return WikiList;
+    }
+
+
+    public Map<String, String> getSettingByUrl( String sUrl )
+    {
+        Map<String, String> ht = null;
+        for( int i=0;i<m_WikiConnections.size();i++ )
+        {
+            Map<String, String> h1 = m_WikiConnections.get( i );
+            String u1 = h1.get( "Url" );
+            if ( u1.equals( sUrl ) )
+            {
+                ht = h1;
+                try
+                {
+                    String sUserName = ht.get( "Username" );
+                    String aPassword = ht.get( "Password" );
+                    if ( sUserName != null && sUserName.length() > 0 && ( aPassword == null || aPassword.length() == 0 ) )
+                    {
+                        String[] pPasswords = Helper.GetPasswordsForURLAndUser( m_xContext, sUrl, sUserName );
+                        if ( pPasswords != null && pPasswords.length > 0 )
+                            ht.put( "Password", pPasswords[0] );
+                    }
+                }
+                catch( Exception e )
+                {
+                    e.printStackTrace();
+                }
+
+                break;
+            }
+        }
+        return ht;
+    }
+
+    private Map<String,Object> getDocByCompleteUrl( String curl )
+    {
+        Map<String,Object> ht = null;
+        for( int i=0;i<m_aWikiDocs.size();i++ )
+        {
+            Map<String,Object> h1 = m_aWikiDocs.get( i );
+            String u1 = ( String ) h1.get( "CompleteUrl" );
+            if ( u1.equals( curl ) )
+            {
+                ht = h1;
+            }
+        }
+        return ht;
+    }
+
+
+    public void removeSettingByUrl( String sUrl )
+    {
+        for( int i=0;i<m_WikiConnections.size();i++ )
+        {
+            Map<String,String> h1 = m_WikiConnections.get( i );
+            String u1 = h1.get( "Url" );
+            if ( u1.equals( sUrl ) )
+            {
+                m_WikiConnections.remove( i );
+            }
+        }
+    }
+
+
+    public void storeConfiguration()
+    {
+        try
+        {
+            {
+                // remove stored connection information
+                XNameContainer xContainer = Helper.GetConfigNameContainer(m_xContext, "org.openoffice.Office.Custom.WikiExtension/ConnectionList");
+                String[] pNames = xContainer.getElementNames();
+                for (String pName : pNames)
+                {
+                    xContainer.removeByName(pName);
+                }
+                // store all connections
+                XSingleServiceFactory xConnectionFactory = UnoRuntime.queryInterface(XSingleServiceFactory.class, xContainer);
+                for (Map<String, String> ht : m_WikiConnections)
+                {
+                    Object oNewConnection = xConnectionFactory.createInstance();
+                    XNameReplace xNewConn = UnoRuntime.queryInterface(XNameReplace.class, oNewConnection);
+                    if (xNewConn != null)
+                    {
+                        xNewConn.replaceByName("UserName", ht.get("Username"));
+                    }
+                    xContainer.insertByName(ht.get("Url"), xNewConn);
+                }
+                // commit changes
+                XChangesBatch xBatch = UnoRuntime.queryInterface(XChangesBatch.class, xContainer);
+                xBatch.commitChanges();
+            }
+
+            {
+                // remove stored connection information
+                XNameContainer xContainer = Helper.GetConfigNameContainer(m_xContext, "org.openoffice.Office.Custom.WikiExtension/RecentDocs");
+                String[] pNames = xContainer.getElementNames();
+                for (String pName : pNames)
+                {
+                    xContainer.removeByName(pName);
+                }
+                // store all Docs
+                XSingleServiceFactory xDocListFactory = UnoRuntime.queryInterface(XSingleServiceFactory.class, xContainer);
+                int i = 0;
+                for (Map<String, Object> ht : m_aWikiDocs)
+                {
+                    Object oNewDoc = xDocListFactory.createInstance();
+                    XNameReplace xNewDoc = UnoRuntime.queryInterface(XNameReplace.class, oNewDoc);
+                    for (Map.Entry<String, Object> entry : ht.entrySet())
+                    {
+                        xNewDoc.replaceByName(entry.getKey(), entry.getValue());
+                    }
+                    xContainer.insertByName("d" + i++, xNewDoc);
+                }
+                // commit changes
+                XChangesBatch xBatch = UnoRuntime.queryInterface(XChangesBatch.class, xContainer);
+                xBatch.commitChanges();
+            }
+
+        }
+        catch ( Exception ex )
+        {
+            ex.printStackTrace();
+        }
+    }
+
+    public void loadConfiguration()
+    {
+        m_WikiConnections.clear();
+        try
+        {
+            // get configuration service
+            // connect to configmanager
+            XNameAccess xAccess = Helper.GetConfigNameAccess( m_xContext, "org.openoffice.Office.Custom.WikiExtension" );
+
+            if ( xAccess != null )
+            {
+                Object oList = xAccess.getByName( "ConnectionList" );
+                XNameAccess xConnectionList = UnoRuntime.queryInterface( XNameAccess.class, oList );
+                String [] allCons = xConnectionList.getElementNames();
+                for (String aConnection : allCons)
+                {
+                    Map<String, String> ht = new HashMap<String, String>();
+                    ht.put("Url", aConnection);
+                    ht.put( "Username", "" );
+                    ht.put( "Password", "" );
+                    try
+                    {
+                        XPropertySet xProps = UnoRuntime.queryInterface(XPropertySet.class, xConnectionList.getByName(aConnection));
+                        if ( xProps != null )
+                        {
+                            String aUsername = AnyConverter.toString( xProps.getPropertyValue( "UserName" ) );
+                            if ( aUsername != null && aUsername.length() > 0 )
+                                ht.put( "Username", aUsername );
+                        }
+                    }
+                    catch( Exception e )
+                    {
+                        e.printStackTrace();
+                    }
+                    addWikiCon( ht );
+                }
+
+                Object oDocs = xAccess.getByName( "RecentDocs" );
+                XNameAccess xRecentDocs = UnoRuntime.queryInterface( XNameAccess.class, oDocs );
+                String [] allDocs = xRecentDocs.getElementNames();
+                for (String aDocument : allDocs)
+                {
+                    Object oDoc = xRecentDocs.getByName(aDocument);
+                    XNameAccess xDoc = UnoRuntime.queryInterface( XNameAccess.class, oDoc );
+                    Map<String, Object> ht = new HashMap<String, Object>();
+                    ht.put( "Url", xDoc.getByName( "Url" ) );
+                    ht.put( "CompleteUrl", xDoc.getByName( "CompleteUrl" ) );
+                    ht.put( "Doc", xDoc.getByName( "Doc" ) );
+                    addWikiDoc( ht );
+                }
+            }
+        }
+        catch ( Exception ex )
+        {
+            ex.printStackTrace();
+        }
+    }
+}
diff --git a/swext/mediawiki/src/com/sun/star/wiki/WikiArticle.java b/swext/mediawiki/src/com/sun/star/wiki/WikiArticle.java
new file mode 100644
index 000000000..a576ef9c7
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/WikiArticle.java
@@ -0,0 +1,255 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import java.io.StringReader;
+import java.io.OutputStreamWriter;
+import java.util.Map;
+import java.net.URLEncoder;
+import java.net.URI;
+import java.net.HttpURLConnection;
+
+import javax.swing.text.html.HTMLEditorKit;
+
+import com.sun.star.uno.XComponentContext;
+
+
+public class WikiArticle
+{
+    private final XComponentContext m_xContext;
+
+    private String m_sEditTime = "";
+    private String m_sEditToken = "";
+
+    private String m_sHTMLCode;
+    private boolean m_bNoArticle = true;
+
+    private String m_sWikiUser;
+    private String m_sWikiPass;
+
+    private final String m_sTitle;
+
+    private final URI m_aMainURI;
+    private boolean m_isLoggedIn = false;
+
+    /** Creates a new instance of WikiArticle */
+    public WikiArticle( XComponentContext xContext, String sTitle, Map<String,String> wikiSettings, boolean bLogin, WikiPropDialog aPropDialog )
+        throws java.net.URISyntaxException, java.io.IOException, WikiCancelException
+    {
+        m_xContext = xContext;
+
+        String sMainUrl = wikiSettings.get("Url");
+        m_sWikiUser = wikiSettings.get("Username");
+        m_sWikiPass = wikiSettings.get("Password");
+        m_sTitle = sTitle;
+
+        m_aMainURI = new URI(sMainUrl);
+
+        if ( bLogin )
+        {
+            WikiEditSettingDialog aDialog = new WikiEditSettingDialog(m_xContext, "vnd.sun.star.script:WikiEditor.EditSetting?location=application", wikiSettings, false );
+            try
+            {
+                while( !Login() )
+                {
+                    if ( aPropDialog != null )
+                        aPropDialog.SetThrobberActive( false );
+
+                    if ( MainThreadDialogExecutor.Show( xContext, aDialog ) )
+                    {
+                        m_sWikiUser = wikiSettings.get("Username");
+                        m_sWikiPass = wikiSettings.get("Password");
+                    }
+                    else
+                        throw new WikiCancelException();
+
+                    if ( aPropDialog != null )
+                    {
+                        aPropDialog.SetThrobberActive( true );
+                        Thread.yield();
+                    }
+                }
+            }
+            finally
+            {
+                aDialog.DisposeDialog();
+            }
+        }
+
+        // in case of loading the html contents are used
+        // in case of saving the contents should be checked whether they are empty
+        InitArticleHTML();
+    }
+
+    public String GetMainURL()
+    {
+        return m_aMainURI.toString();
+    }
+
+    public String GetTitle()
+    {
+        return m_sTitle;
+    }
+
+
+
+    private String getArticleWiki()
+        throws java.net.URISyntaxException, java.io.IOException, WikiCancelException
+    {
+        String sWikiCode = null;
+
+        if (m_isLoggedIn)
+        {
+            URI aURI = new URI(m_aMainURI.toString() + "index.php?title=" + m_sTitle + "&action=edit");
+            HttpURLConnection connGet = Helper.PrepareMethod("GET", aURI, m_xContext);
+            connGet.connect();
+
+            int nResultCode = connGet.getResponseCode();
+            String sWebPage = null;
+            if (nResultCode == 200) {
+                sWebPage = Helper.ReadResponseBody(connGet);
+            }
+
+            if ( sWebPage != null )
+            {
+                StringReader r = new StringReader(sWebPage);
+                HTMLEditorKit.Parser parse = Helper.GetHTMLParser();
+                EditPageParser callback = new EditPageParser();
+
+                parse.parse(r,callback,true);
+                m_sEditTime = callback.m_sEditTime;
+                m_sEditToken = callback.m_sEditToken;
+
+                int iPosStart = callback.m_nWikiArticleStart;
+                int iPosEnd = callback.m_nWikiArticleEnd;
+
+                if ( iPosStart >= 0 && iPosEnd > 0 )
+                {
+                    String sArticle = sWebPage.substring(iPosStart, iPosEnd);
+                    iPosStart = sArticle.indexOf('>') + 1;
+                    sWikiCode = sArticle.substring( iPosStart, sArticle.length() );
+                }
+            }
+        }
+
+        return sWikiCode;
+    }
+
+    private void InitArticleHTML()
+        throws java.net.URISyntaxException, java.io.IOException, WikiCancelException
+    {
+        if (m_isLoggedIn)
+        {
+            URI uri = new URI(m_aMainURI.toString() + "index.php?title=" + m_sTitle);
+            HttpURLConnection connGet = Helper.PrepareMethod("GET", uri, m_xContext);
+            connGet.connect();
+
+            int nResultCode = connGet.getResponseCode();
+            String sWebPage = null;
+            if (nResultCode == 200) {
+                sWebPage = Helper.ReadResponseBody(connGet);
+            }
+
+            if ( sWebPage != null )
+            {
+                StringReader r = new StringReader(sWebPage);
+                HTMLEditorKit.Parser parse = Helper.GetHTMLParser();
+                EditPageParser callback = new EditPageParser();
+
+                parse.parse(r,callback,true);
+
+                int iPosStart = callback.m_nHTMLArticleStart;
+                int iPosEnd = callback.m_nHTMLArticleEnd;
+                int nPosNoArt = callback.m_nNoArticleInd;
+
+                if ( iPosStart >= 0 && iPosEnd > 0 )
+                {
+                    m_sHTMLCode = sWebPage.substring(iPosStart, iPosEnd);
+                    m_bNoArticle = ( nPosNoArt >= 0 && nPosNoArt >= iPosStart && nPosNoArt <= iPosEnd );
+                }
+            }
+        }
+    }
+
+    protected boolean setArticle( String sWikiCode, String sWikiComment, boolean bMinorEdit )
+        throws java.net.URISyntaxException, java.io.IOException, WikiCancelException
+    {
+        boolean bResult = false;
+
+        if (m_isLoggedIn && sWikiCode != null && sWikiComment != null)
+        {
+            // get the edit time and token
+            getArticleWiki();
+
+            URI uri = new URI(m_aMainURI.toString() + "index.php?title=" + m_sTitle + "&action=submit");
+
+            HttpURLConnection connPost = Helper.PrepareMethod("POST", uri, m_xContext);
+            connPost.setDoInput(true);
+            connPost.setDoOutput(true);
+            connPost.connect();
+
+            OutputStreamWriter post = new OutputStreamWriter(connPost.getOutputStream(), "UTF-8");
+            post.write("wpTextbox1=");
+            post.write(URLEncoder.encode(sWikiCode, "UTF-8"));
+            post.write("&wpSummary=");
+            post.write(URLEncoder.encode(sWikiComment, "UTF-8"));
+            post.write("&wpSection=");
+            post.write("&wpEdittime=");
+            post.write(URLEncoder.encode(m_sEditTime, "UTF-8"));
+            post.write("&wpSave=Save%20page");
+            post.write("&wpEditToken=");
+            post.write(URLEncoder.encode(m_sEditToken, "UTF-8"));
+
+            if (bMinorEdit) {
+                post.write("&wpMinoredit=1");
+            }
+
+            post.flush();
+            post.close();
+
+            int nResultCode = connPost.getResponseCode();
+            if ( nResultCode < 400 )
+                bResult = true;
+
+            String aResult = Helper.ReadResponseBody(connPost);
+
+            // TODO: remove the debug printing, try to detect the error
+            System.out.print( "nSubmitCode = " + nResultCode + "\n===\n" + aResult );
+        }
+
+        return bResult;
+    }
+
+    private boolean Login()
+        throws java.net.URISyntaxException, java.io.IOException, WikiCancelException
+    {
+        m_isLoggedIn = Helper.Login( m_aMainURI, m_sWikiUser, m_sWikiPass, m_xContext );
+        return m_isLoggedIn;
+    }
+
+    protected boolean NotExist()
+    {
+        boolean bResult = true;
+        if ( m_sHTMLCode != null )
+            bResult = m_bNoArticle;
+
+        return bResult;
+    }
+
+}
diff --git a/swext/mediawiki/src/com/sun/star/wiki/WikiCancelException.java b/swext/mediawiki/src/com/sun/star/wiki/WikiCancelException.java
new file mode 100644
index 000000000..0a6c81ebe
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/WikiCancelException.java
@@ -0,0 +1,24 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+class WikiCancelException extends java.lang.Exception
+{
+}
+
diff --git a/swext/mediawiki/src/com/sun/star/wiki/WikiDialog.java b/swext/mediawiki/src/com/sun/star/wiki/WikiDialog.java
new file mode 100644
index 000000000..66bef678e
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/WikiDialog.java
@@ -0,0 +1,283 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import com.sun.star.awt.XControl;
+import com.sun.star.awt.XControlContainer;
+import com.sun.star.awt.XControlModel;
+import com.sun.star.awt.XDialog;
+import com.sun.star.awt.XDialogEventHandler;
+import com.sun.star.awt.XDialogProvider2;
+import com.sun.star.awt.XAnimation;
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.lang.XMultiComponentFactory;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+import com.sun.star.awt.XTopWindow;
+import com.sun.star.awt.XTopWindowListener;
+import com.sun.star.awt.XWindow;
+import com.sun.star.container.XNameContainer;
+import com.sun.star.lang.EventObject;
+import com.sun.star.lang.XMultiServiceFactory;
+
+public class WikiDialog implements XDialogEventHandler, XTopWindowListener
+{
+    protected XComponentContext m_xContext;
+    private XControlContainer m_xControlContainer;
+    protected XDialog m_xDialog;
+    private String[] m_aMethods;
+    protected boolean m_bAction = false;
+    protected Settings m_aSettings;
+    protected Thread m_aThread;
+    protected boolean m_bThreadFinished = false;
+
+
+    /** Creates a new instance of WikiDialog */
+    public WikiDialog(XComponentContext c, String DialogURL)
+    {
+        this.m_xContext = c;
+        XMultiComponentFactory xMCF = m_xContext.getServiceManager();
+        m_aSettings = Settings.getSettings(m_xContext);
+        try
+        {
+            Object obj;
+            obj = xMCF.createInstanceWithContext("com.sun.star.awt.DialogProvider2", m_xContext );
+            XDialogProvider2 xDialogProvider = UnoRuntime.queryInterface( XDialogProvider2.class, obj );
+
+            m_xDialog = xDialogProvider.createDialogWithHandler( DialogURL, this );
+            m_xControlContainer = UnoRuntime.queryInterface( XControlContainer.class, m_xDialog );
+            XTopWindow xTopWindow = UnoRuntime.queryInterface( XTopWindow.class, m_xDialog );
+            if ( xTopWindow != null )
+                xTopWindow.addTopWindowListener( this );
+        }
+        catch (com.sun.star.uno.Exception ex)
+        {
+            ex.printStackTrace();
+        }
+    }
+
+    public synchronized void ThreadStop( boolean bSelf )
+    {
+        if ( bSelf || m_aThread != null && !m_bThreadFinished )
+        {
+            try
+            {
+                Helper.AllowConnection( bSelf );
+            }
+            catch( Exception ex )
+            {
+                ex.printStackTrace();
+            }
+        }
+
+        m_aThread = null;
+        m_bThreadFinished = true;
+    }
+
+    protected void setMethods (String [] Methods)
+    {
+        this.m_aMethods = Methods;
+    }
+
+
+    public boolean show( )
+    {
+        m_bThreadFinished = false;
+
+        if( m_xDialog != null ) m_xDialog.execute();
+        return m_bAction;
+    }
+
+
+    public String[] getSupportedMethodNames()
+    {
+        return m_aMethods;
+    }
+
+
+    public boolean callHandlerMethod( XDialog xDialog, Object EventObject, String MethodName )
+    {
+        return true;
+    }
+
+    public void SetTitle( String sTitle )
+        throws Exception
+    {
+        SetTitle( m_xDialog, sTitle );
+    }
+
+    private static void SetTitle( XDialog xDialog, String sTitle )
+        throws Exception
+    {
+        if ( xDialog == null || sTitle == null ) {
+            return;
+        }
+        XControl xDialogControl = UnoRuntime.queryInterface( XControl.class, xDialog );
+        if ( xDialogControl != null )
+        {
+            XPropertySet xPropSet = UnoRuntime.queryInterface( XPropertySet.class, xDialogControl.getModel() );
+            if ( xPropSet != null )
+                xPropSet.setPropertyValue( "Title", sTitle );
+        }
+    }
+
+    protected XPropertySet GetPropSet(String sControl)
+    {
+        return GetPropSet( m_xControlContainer, sControl );
+    }
+
+    private static XPropertySet GetPropSet( XControlContainer xControlContainer, String sControl )
+    {
+        XPropertySet xPS = null;
+
+        if ( xControlContainer != null && sControl != null )
+        {
+            XControl xControl = xControlContainer.getControl(sControl);
+            xPS = UnoRuntime.queryInterface(XPropertySet.class, xControl.getModel() );
+        }
+
+        if ( xPS == null )
+            throw new com.sun.star.uno.RuntimeException();
+
+        return xPS;
+    }
+
+
+
+    protected void InsertThrobber( int X, int Y, int Width, int Height )
+    {
+        try
+        {
+            XControl xDialogControl = UnoRuntime.queryInterface( XControl.class, m_xDialog );
+            XControlModel xDialogModel = null;
+            if ( xDialogControl != null )
+                xDialogModel = xDialogControl.getModel();
+
+            XMultiServiceFactory xDialogFactory = UnoRuntime.queryInterface( XMultiServiceFactory.class, xDialogModel );
+            if ( xDialogFactory != null )
+            {
+                XControlModel xThrobberModel = UnoRuntime.queryInterface( XControlModel.class, xDialogFactory.createInstance( "com.sun.star.awt.SpinningProgressControlModel" ) );
+                XPropertySet xThrobberProps = UnoRuntime.queryInterface( XPropertySet.class, xThrobberModel );
+                if ( xThrobberProps != null )
+                {
+                    xThrobberProps.setPropertyValue( "Name", "WikiThrobber" );
+                    xThrobberProps.setPropertyValue( "PositionX", Integer.valueOf( X ) );
+                    xThrobberProps.setPropertyValue( "PositionY", Integer.valueOf( Y ) );
+                    xThrobberProps.setPropertyValue( "Width", Integer.valueOf( Width ) );
+                    xThrobberProps.setPropertyValue( "Height", Integer.valueOf( Height ) );
+
+                    XNameContainer xDialogContainer = UnoRuntime.queryInterface( XNameContainer.class, xDialogModel );
+                    xDialogContainer.insertByName( "WikiThrobber", xThrobberModel );
+                }
+            }
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+
+        SetThrobberVisible( false );
+    }
+
+    public void SetThrobberActive( boolean bActive )
+    {
+        if ( m_xControlContainer != null )
+        {
+            try
+            {
+                XAnimation xThrobber = UnoRuntime.queryInterface( XAnimation.class, m_xControlContainer.getControl( "WikiThrobber" ) );
+                if ( xThrobber != null )
+                {
+                    if ( bActive )
+                        xThrobber.startAnimation();
+                    else
+                        xThrobber.stopAnimation();
+                }
+            }
+            catch( Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public void SetThrobberVisible( boolean bVisible )
+    {
+        if ( m_xControlContainer != null )
+        {
+            try
+            {
+                XWindow xWindow = UnoRuntime.queryInterface( XWindow.class, m_xControlContainer.getControl( "WikiThrobber" ) );
+                if ( xWindow != null )
+                    xWindow.setVisible( bVisible );
+            }
+            catch ( Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public void SetFocusTo( String aControl )
+    {
+        if ( m_xControlContainer != null )
+        {
+            try
+            {
+                XWindow xWindow = UnoRuntime.queryInterface( XWindow.class, m_xControlContainer.getControl( aControl ) );
+                if ( xWindow != null )
+                    xWindow.setFocus();
+            }
+            catch ( Exception e )
+            {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public void DisposeDialog()
+    {
+        Helper.Dispose( m_xDialog );
+    }
+
+    public void windowOpened( EventObject e )
+    {}
+
+    public void windowClosing( EventObject e )
+    {}
+
+    public void windowClosed( EventObject e )
+    {}
+
+    public void windowMinimized( EventObject e )
+    {}
+
+    public void windowNormalized( EventObject e )
+    {}
+
+    public void windowActivated( EventObject e )
+    {}
+
+    public void windowDeactivated( EventObject e )
+    {}
+
+    public void disposing( EventObject e )
+    {}
+}
+
diff --git a/swext/mediawiki/src/com/sun/star/wiki/WikiEditSettingDialog.java b/swext/mediawiki/src/com/sun/star/wiki/WikiEditSettingDialog.java
new file mode 100644
index 000000000..e1f1aac35
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/WikiEditSettingDialog.java
@@ -0,0 +1,416 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import java.net.URI;
+import java.net.HttpURLConnection;
+import javax.net.ssl.SSLException;
+
+import com.sun.star.awt.XDialog;
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.lang.EventObject;
+import com.sun.star.uno.XComponentContext;
+
+public class WikiEditSettingDialog extends WikiDialog
+{
+
+    private static final String sOKMethod = "OK";
+
+    private final String[] Methods = {sOKMethod };
+    private final Map<String,String> setting;
+    private final boolean addMode;
+    private boolean m_bAllowURLChange = true;
+
+    public WikiEditSettingDialog( XComponentContext xContext, String DialogURL )
+    {
+        super( xContext, DialogURL );
+        super.setMethods( Methods );
+        setting = new HashMap<String,String>();
+        addMode = true;
+
+        InsertThrobber( 184, 20, 10, 10 );
+        InitStrings( xContext );
+        InitSaveCheckbox( xContext, false );
+    }
+
+    public WikiEditSettingDialog( XComponentContext xContext, String DialogURL, Map<String,String> ht, boolean bAllowURLChange )
+    {
+        super( xContext, DialogURL );
+        super.setMethods( Methods );
+        setting = ht;
+
+        boolean bInitSaveCheckBox = false;
+
+        try
+        {
+            XPropertySet xUrlField = GetPropSet( "UrlField" );
+
+            xUrlField.setPropertyValue( "Text", ht.get( "Url" ) );
+
+            GetPropSet( "UsernameField" ).setPropertyValue( "Text", ht.get( "Username" ) );
+
+            if ( Helper.PasswordStoringIsAllowed( m_xContext ) )
+            {
+                String[] pPasswords = Helper.GetPasswordsForURLAndUser( m_xContext, ht.get( "Url" ), ht.get( "Username" ) );
+                bInitSaveCheckBox = ( pPasswords != null && pPasswords.length > 0 && pPasswords[0].equals( ht.get( "Password" ) ) );
+            }
+
+            // the password should be entered by the user or the Cancel should be pressed
+            // GetPropSet( "PasswordField" ).setPropertyValue( "Text", ht.get( "Password" ));
+        }
+        catch ( Exception ex )
+        {
+            ex.printStackTrace();
+        }
+
+        addMode = false;
+        m_bAllowURLChange = bAllowURLChange;
+
+        InsertThrobber( 184, 20, 10, 10 );
+        InitStrings( xContext );
+        InitSaveCheckbox( xContext, bInitSaveCheckBox );
+    }
+
+    @Override
+    public boolean show( )
+    {
+        SetThrobberVisible( false );
+        EnableControls( true );
+        boolean bResult = super.show();
+
+        try
+        {
+            if ( bResult && Helper.PasswordStoringIsAllowed( m_xContext )
+              && ( (Short)( GetPropSet( "SaveBox" ).getPropertyValue("State") ) ).shortValue() != (short)0 )
+            {
+                String sURL = setting.get( "Url" );
+                String sUserName = setting.get( "Username" );
+                String sPassword = setting.get( "Password" );
+
+                if ( sURL != null && sURL.length() > 0 && sUserName != null && sUserName.length() > 0 && sPassword != null && sPassword.length() > 0 )
+                {
+                    String[] pPasswords = { sPassword };
+                    Helper.GetPasswordContainer( m_xContext ).addPersistent( sURL, sUserName, pPasswords, Helper.GetInteractionHandler( m_xContext ) );
+                }
+            }
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+
+        return bResult;
+    }
+
+    private void EnableControls( boolean bEnable )
+    {
+        if ( !bEnable )
+            SetFocusTo( "CancelButton" );
+
+        try
+        {
+            GetPropSet( "UsernameField" ).setPropertyValue( "Enabled", Boolean.valueOf( bEnable ) );
+            GetPropSet( "PasswordField" ).setPropertyValue( "Enabled", Boolean.valueOf( bEnable ) );
+            GetPropSet( "OkButton" ).setPropertyValue( "Enabled", Boolean.valueOf( bEnable ) );
+            GetPropSet( "HelpButton" ).setPropertyValue( "Enabled", Boolean.valueOf( bEnable ) );
+
+            if ( bEnable )
+            {
+                GetPropSet( "UrlField" ).setPropertyValue( "Enabled", Boolean.valueOf( m_bAllowURLChange ) );
+                GetPropSet( "SaveBox" ).setPropertyValue( "Enabled", Boolean.valueOf( Helper.PasswordStoringIsAllowed( m_xContext ) ) );
+                if ( m_bAllowURLChange )
+                    SetFocusTo( "UrlField" );
+                else
+                    SetFocusTo( "UsernameField" );
+            }
+            else
+            {
+                GetPropSet( "UrlField" ).setPropertyValue( "Enabled", Boolean.FALSE );
+                GetPropSet( "SaveBox" ).setPropertyValue( "Enabled", Boolean.FALSE );
+            }
+        }
+        catch ( Exception ex )
+        {
+            ex.printStackTrace();
+        }
+    }
+
+    private void InitStrings( XComponentContext xContext )
+    {
+        try
+        {
+            SetTitle( Helper.GetLocalizedString( xContext, Helper.DLG_MEDIAWIKI_TITLE ) );
+            GetPropSet( "UrlLabel" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_EDITSETTING_URLLABEL ) );
+            GetPropSet( "UsernameLabel" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_EDITSETTING_USERNAMELABEL ) );
+            GetPropSet( "PasswordLabel" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_EDITSETTING_PASSWORDLABEL ) );
+            GetPropSet( "AccountLine" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_EDITSETTING_ACCOUNTLINE ) );
+            GetPropSet( "WikiLine" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_EDITSETTING_WIKILINE ) );
+            GetPropSet( "SaveBox" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_EDITSETTING_SAVEBOX ) );
+            GetPropSet( "OkButton" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_OK ) );
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    private void InitSaveCheckbox( XComponentContext xContext, boolean bInitSaveCheckBox )
+    {
+        XPropertySet xSaveCheck = GetPropSet( "SaveBox" );
+        try
+        {
+            xSaveCheck.setPropertyValue( "State", Short.valueOf( bInitSaveCheckBox ? (short)1 : (short)0 ) );
+            xSaveCheck.setPropertyValue( "Enabled", Boolean.valueOf( Helper.PasswordStoringIsAllowed( xContext ) ) );
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    private void DoLogin()
+    {
+        String sRedirectURL = "";
+        String sURL = "";
+        try
+        {
+            sURL = ( String ) GetPropSet( "UrlField" ).getPropertyValue( "Text" );
+            String sUserName = ( String ) GetPropSet( "UsernameField" ).getPropertyValue( "Text" );
+            String sPassword = ( String ) GetPropSet( "PasswordField" ).getPropertyValue( "Text" );
+
+            boolean bAllowIndex = true;
+
+            do
+            {
+                if ( sRedirectURL.length() > 0 )
+                {
+                    sURL = sRedirectURL;
+                    sRedirectURL = "";
+                }
+
+                if ( sURL.length() > 0 )
+                {
+                    URI aURI = new URI(sURL);
+                    HttpURLConnection connGet = Helper.PrepareMethod("GET", aURI, m_xContext);
+                    connGet.setInstanceFollowRedirects(false);
+                    connGet.connect();
+
+                    int nResultCode = connGet.getResponseCode();
+                    String sWebPage = null;
+                    if ( nResultCode == 200 )
+                        sWebPage = Helper.ReadResponseBody(connGet);
+                    else if ( nResultCode >= 301 && nResultCode <= 303 || nResultCode == 307 )
+                        sRedirectURL = connGet.getHeaderField("Location");
+
+                    if ( sWebPage != null && sWebPage.length() > 0 )
+                    {
+                        //the URL is valid
+                        String sMainURL = Helper.GetMainURL( sWebPage, sURL );
+
+                        if ( sMainURL.length() == 0 )
+                        {
+                            // TODO:
+                            // it's not a Wiki Page, check first whether a redirect is requested
+                            // happens usually in case of https
+                            sRedirectURL = Helper.GetRedirectURL( sWebPage, sURL );
+                            if ( sRedirectURL.length() == 0 )
+                            {
+                                // show error
+                                Helper.ShowError( m_xContext,
+                                                  m_xDialog,
+                                                  Helper.DLG_MEDIAWIKI_TITLE,
+                                                  Helper.NOURLCONNECTION_ERROR,
+                                                  sURL,
+                                                  false );
+                            }
+                        }
+                        else
+                        {
+                            URI aMainURI = new URI(sMainURL);
+
+                            if ( ( sUserName.length() > 0 || sPassword.length() > 0 )
+                              && !Helper.Login(aMainURI, sUserName, sPassword, m_xContext))
+                            {
+                                // a wrong login information is provided
+                                // show error
+                                Helper.ShowError( m_xContext,
+                                                  m_xDialog,
+                                                  Helper.DLG_MEDIAWIKI_TITLE,
+                                                  Helper.WRONGLOGIN_ERROR,
+                                                  null,
+                                                  false );
+                            }
+                            else
+                            {
+                                setting.put( "Url", aMainURI.toASCIIString() );
+                                setting.put( "Username", sUserName );
+                                setting.put( "Password", sPassword );
+                                if ( addMode )
+                                {
+                                    // no cleaning of the settings is necessary
+                                    Settings.getSettings( m_xContext ).addWikiCon( setting );
+                                    Settings.getSettings( m_xContext ).storeConfiguration();
+                                }
+
+                                m_bAction = true;
+                            }
+                        }
+                    }
+                    else if ( sRedirectURL == null || sRedirectURL.length() == 0 )
+                    {
+                        if ( sURL.length() > 0 && !sURL.endsWith( "index.php" ) && bAllowIndex )
+                        {
+                            // the used MainURL is not always directly accessible
+                            // add the suffix as workaround, but only once
+                            sRedirectURL = sURL + "/index.php";
+                            bAllowIndex = false;
+                        }
+                        else
+                        {
+                            // URL invalid
+                            // show error
+                            Helper.ShowError( m_xContext,
+                                              m_xDialog,
+                                              Helper.DLG_MEDIAWIKI_TITLE,
+                                              Helper.INVALIDURL_ERROR,
+                                              null,
+                                              false );
+                        }
+                    }
+                }
+                else
+                {
+                    // URL field empty
+                    // show error
+                    Helper.ShowError( m_xContext,
+                                      m_xDialog,
+                                      Helper.DLG_MEDIAWIKI_TITLE,
+                                      Helper.NOURL_ERROR,
+                                      null,
+                                      false );
+                }
+            } while (sRedirectURL != null && sRedirectURL.length() > 0);
+        }
+        catch ( WikiCancelException ce )
+        {
+        }
+        catch ( SSLException essl )
+        {
+            if ( Helper.IsConnectionAllowed() )
+            {
+                Helper.ShowError( m_xContext,
+                                  m_xDialog,
+                                  Helper.DLG_MEDIAWIKI_TITLE,
+                                  Helper.UNKNOWNCERT_ERROR,
+                                  null,
+                                  false );
+            }
+            essl.printStackTrace();
+        }
+        catch ( Exception ex )
+        {
+            if ( Helper.IsConnectionAllowed() )
+            {
+                Helper.ShowError( m_xContext,
+                                  m_xDialog,
+                                  Helper.DLG_MEDIAWIKI_TITLE,
+                                  Helper.NOURLCONNECTION_ERROR,
+                                  sURL,
+                                  false );
+            }
+            ex.printStackTrace();
+        }
+    }
+
+    @Override
+    public boolean callHandlerMethod( XDialog xDialog, Object EventObject, String MethodName )
+    {
+        if ( MethodName.equals( sOKMethod ) )
+        {
+            EnableControls( false );
+            SetThrobberVisible( true );
+            SetThrobberActive( true );
+
+            if ( Helper.AllowThreadUsage( m_xContext ) )
+            {
+                final XDialog xDialogForThread = xDialog;
+                final XComponentContext xContext = m_xContext;
+
+                // the thread name is used to allow the error dialogs
+                m_bThreadFinished = false;
+                m_aThread = new Thread( "com.sun.star.thread.WikiEditorSendingThread" )
+                {
+                    @Override
+                    public void run()
+                    {
+                        try
+                        {
+                            Thread.yield();
+                        } catch( java.lang.Exception e ){}
+
+                        DoLogin();
+                        WikiEditSettingDialog.this.EnableControls( true );
+                        WikiEditSettingDialog.this.SetThrobberActive( false );
+                        WikiEditSettingDialog.this.SetThrobberVisible( false );
+
+                        ThreadStop( true );
+
+                        if ( m_bAction )
+                            MainThreadDialogExecutor.Close( xContext, xDialogForThread );
+                    }
+                };
+
+                m_aThread.start();
+            }
+            else
+            {
+                try
+                {
+                    DoLogin();
+                } catch( java.lang.Exception e )
+                {}
+                finally
+                {
+                    EnableControls( true );
+                    SetThrobberActive( false );
+                    SetThrobberVisible( false );
+
+                    if ( m_bAction )
+                        xDialog.endExecute();
+
+                    Helper.AllowConnection( true );
+                }
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public void windowClosed( EventObject e )
+    {
+        ThreadStop( false );
+    }
+}
+
diff --git a/swext/mediawiki/src/com/sun/star/wiki/WikiEditorImpl.java b/swext/mediawiki/src/com/sun/star/wiki/WikiEditorImpl.java
new file mode 100644
index 000000000..3d1bee21e
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/WikiEditorImpl.java
@@ -0,0 +1,353 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import java.io.File;
+import java.net.URI;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.net.ssl.SSLException;
+
+import com.sun.star.awt.XWindowPeer;
+import com.sun.star.beans.PropertyValue;
+import com.sun.star.frame.DispatchDescriptor;
+import com.sun.star.frame.XController;
+import com.sun.star.frame.XDispatch;
+import com.sun.star.frame.XDispatchProvider;
+import com.sun.star.frame.XFrame;
+import com.sun.star.frame.XModel;
+import com.sun.star.frame.XStorable;
+import com.sun.star.lang.XInitialization;
+import com.sun.star.lang.XSingleComponentFactory;
+import com.sun.star.lib.uno.helper.Factory;
+import com.sun.star.lib.uno.helper.WeakBase;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+
+
+public final class WikiEditorImpl extends WeakBase
+   implements com.sun.star.lang.XServiceInfo, XDispatchProvider, XDispatch, XInitialization
+{
+
+    private static final String m_implementationName = WikiEditorImpl.class.getName();
+    private static final String[] m_serviceNames = {"com.sun.star.wiki.WikiEditor" };
+
+
+
+    // protocol name that this protocol handler handles
+    private static final String protocolName = "vnd.com.sun.star.wiki:";
+
+    private final XComponentContext m_xContext;
+    private XFrame m_xFrame;
+    private XModel m_xModel;
+    private final Settings m_aSettings;
+    private String m_aFilterName;
+
+    public WikiEditorImpl( XComponentContext xContext )
+    {
+        // Helper.trustAllSSL();
+        m_xContext = xContext;
+        m_aSettings = Settings.getSettings( m_xContext );
+    }
+
+    public static XSingleComponentFactory __getComponentFactory( String sImplementationName )
+    {
+        XSingleComponentFactory xFactory = null;
+
+        if ( sImplementationName.equals( m_implementationName ) )
+            xFactory = Factory.createComponentFactory( WikiEditorImpl.class, m_serviceNames );
+        else if ( sImplementationName.equals( WikiOptionsEventHandlerImpl.m_sImplementationName ) )
+            xFactory = Factory.createComponentFactory( WikiOptionsEventHandlerImpl.class,
+                                                       WikiOptionsEventHandlerImpl.m_pServiceNames );
+
+        return xFactory;
+    }
+
+    // com.sun.star.lang.XServiceInfo:
+    public String getImplementationName()
+    {
+         return m_implementationName;
+    }
+
+    public boolean supportsService( String sService )
+    {
+        int len = m_serviceNames.length;
+
+        for( int i=0; i < len; i++ )
+        {
+            if ( sService.equals( m_serviceNames[i] ))
+                return true;
+        }
+        return false;
+    }
+
+    public String[] getSupportedServiceNames()
+    {
+        return m_serviceNames;
+    }
+
+
+    public synchronized void initialize( Object[] args ) throws com.sun.star.uno.Exception
+    {
+        if ( args.length > 0 )
+        {
+            m_xFrame = UnoRuntime.queryInterface( XFrame.class, args[0] );
+        }
+    }
+
+
+
+    public void dispatch(
+        final com.sun.star.util.URL aURL,
+        com.sun.star.beans.PropertyValue[] propertyValue )
+    {
+        final com.sun.star.util.URL myURL = aURL;
+        if ( aURL.Protocol.equals(protocolName) )
+        {
+            try
+            {
+                if ( myURL.Path.equals("send") )
+                {
+                    sendArticle();
+                }
+            } catch( java.lang.Throwable t )
+            {
+            }
+        }
+    }
+
+
+    public com.sun.star.frame.XDispatch queryDispatch(
+        com.sun.star.util.URL aURL,
+        String str,
+        int param )
+    {
+            if ( aURL.Protocol.equals( protocolName ))
+            {
+
+                // by default, we are responsible
+                return this;
+            } else
+            {
+                return null;
+            }
+    }
+
+    public XDispatch[] queryDispatches( DispatchDescriptor[] seqDescripts )
+    {
+        int nCount = seqDescripts.length;
+        XDispatch[] lDispatcher = new XDispatch[nCount];
+
+        for( int i=0; i<nCount; ++i )
+            lDispatcher[i] = queryDispatch(
+                seqDescripts[i].FeatureURL,
+                seqDescripts[i].FrameName,
+                seqDescripts[i].SearchFlags );
+        return lDispatcher;
+   }
+
+
+    public void removeStatusListener(
+        com.sun.star.frame.XStatusListener xStatusListener,
+        com.sun.star.util.URL aURL )
+    {
+    }
+
+
+    public void addStatusListener(
+        com.sun.star.frame.XStatusListener listener,
+        com.sun.star.util.URL url )
+    {
+    }
+
+    private void sendArticle()
+    {
+        if ( m_xFrame != null )
+        {
+            WikiPropDialog aSendDialog = null;
+            try
+            {
+                if ( m_xModel == null )
+                {
+                    XController xController = m_xFrame.getController();
+                    if ( xController != null )
+                        m_xModel = xController.getModel();
+                }
+
+                if ( m_xModel != null )
+                {
+                    // The related Wiki filter must be detected from the typename
+                    String aServiceName = Helper.GetDocServiceName( m_xContext, m_xModel );
+                    m_aFilterName = Helper.GetFilterName( m_xContext, "MediaWiki", aServiceName );
+
+                    if ( m_aFilterName == null || m_aFilterName.length() == 0 )
+                    {
+                        Helper.ShowError( m_xContext,
+                                          UnoRuntime.queryInterface( XWindowPeer.class, m_xFrame.getContainerWindow() ),
+                                          Helper.DLG_SENDTITLE,
+                                          Helper.NOWIKIFILTER_ERROR,
+                                          null,
+                                          false );
+                        throw new com.sun.star.uno.RuntimeException();
+                    }
+
+                    m_aSettings.loadConfiguration(); // throw away all the noncommitted changes
+                    // show the send dialog
+                    aSendDialog = new WikiPropDialog( m_xContext, "vnd.sun.star.script:WikiEditor.SendToMediaWiki?location=application", this );
+                    aSendDialog.fillWikiList();
+                    aSendDialog.SetWikiTitle( Helper.GetDocTitle( m_xModel ) );
+                    aSendDialog.show(); // triggers the sending
+                }
+            }
+            catch ( Exception e )
+            {
+                // TODO: Error handling here
+                e.printStackTrace();
+            }
+            finally
+            {
+                if ( aSendDialog != null )
+                    aSendDialog.DisposeDialog();
+            }
+        }
+    }
+
+    public boolean SendArticleImpl( WikiPropDialog aSendDialog, Map<String,String> aWikiSetting )
+    {
+        boolean bResult = false;
+
+        if ( aSendDialog != null )
+        {
+            String sTemp2Url = null;
+
+            try
+            {
+                // TODO: stop progress spinning
+                WikiArticle aArticle = new WikiArticle( m_xContext, aSendDialog.GetWikiTitle(), aWikiSetting, true, aSendDialog );
+
+                boolean bAllowSending = true;
+                if ( !aArticle.NotExist() )
+                {
+                    // ask whether creation of a new page is allowed
+                    aSendDialog.SetThrobberActive( false );
+                    bAllowSending = Helper.ShowError(
+                                      m_xContext,
+                                      UnoRuntime.queryInterface( XWindowPeer.class, m_xFrame.getContainerWindow() ),
+                                      Helper.DLG_SENDTITLE,
+                                      Helper.DLG_WIKIPAGEEXISTS_LABEL1,
+                                      aSendDialog.GetWikiTitle(),
+                                      true );
+                    aSendDialog.SetThrobberActive( true );
+                }
+
+                if ( bAllowSending )
+                {
+                    PropertyValue[] lProperties = new PropertyValue[2];
+                    lProperties[0]       = new PropertyValue();
+                    lProperties[0].Name  = "FilterName";
+                    lProperties[0].Value = m_aFilterName;
+                    lProperties[1]       = new PropertyValue();
+                    lProperties[1].Name  = "Overwrite";
+                    lProperties[1].Value = Boolean.TRUE;
+
+                    sTemp2Url = Helper.CreateTempFile( m_xContext );
+
+                    XStorable xStore = UnoRuntime.queryInterface ( XStorable.class, m_xModel );
+                    if ( xStore == null )
+                        throw new com.sun.star.uno.RuntimeException();
+
+                    xStore.storeToURL( sTemp2Url, lProperties );
+                    String sWikiCode = Helper.EachLine( sTemp2Url );
+
+                    if ( aArticle.setArticle( sWikiCode, aSendDialog.m_sWikiComment, aSendDialog.m_bWikiMinorEdit ) )
+                    {
+                        bResult = true;
+                        Helper.SetDocTitle( m_xModel, aArticle.GetTitle() );
+                        Map<String,Object> aDocInfo = new HashMap<String,Object>();
+                        aDocInfo.put( "Doc", aArticle.GetTitle() );
+                        aDocInfo.put( "Url", aArticle.GetMainURL() );
+                        aDocInfo.put( "CompleteUrl", aArticle.GetMainURL() + aArticle.GetTitle() );
+                        m_aSettings.addWikiDoc( aDocInfo );
+                        m_aSettings.storeConfiguration();
+                    }
+                    else
+                    {
+                        Helper.ShowError( m_xContext,
+                                          UnoRuntime.queryInterface( XWindowPeer.class, m_xFrame.getContainerWindow() ),
+                                          Helper.DLG_SENDTITLE,
+                                          Helper.GENERALSEND_ERROR,
+                                          null,
+                                          false );
+                    }
+                }
+            }
+            catch( WikiCancelException ec )
+            {
+                // nothing to do, the sending was cancelled
+            }
+            catch( SSLException essl )
+            {
+                if ( Helper.IsConnectionAllowed() )
+                {
+                    // report the error only if sending was not cancelled
+                    Helper.ShowError( m_xContext,
+                                      UnoRuntime.queryInterface( XWindowPeer.class, m_xFrame.getContainerWindow() ),
+                                      Helper.DLG_SENDTITLE,
+                                      Helper.UNKNOWNCERT_ERROR,
+                                      null,
+                                      false );
+                }
+            }
+            catch( Exception e )
+            {
+                if ( Helper.IsConnectionAllowed() )
+                {
+                    // report the error only if sending was not cancelled
+                    Helper.ShowError( m_xContext,
+                                      UnoRuntime.queryInterface( XWindowPeer.class, m_xFrame.getContainerWindow() ),
+                                      Helper.DLG_SENDTITLE,
+                                      Helper.GENERALSEND_ERROR,
+                                      null,
+                                      false );
+                }
+                e.printStackTrace();
+            }
+
+            if ( sTemp2Url != null )
+            {
+                try
+                {
+                    // remove the temporary file
+                    File aFile = new File( new URI( sTemp2Url ) );
+                    if (!aFile.delete()) {
+                        throw new java.lang.Exception("could not remove" + sTemp2Url);
+                    }
+                }
+                catch ( java.lang.Exception e )
+                {
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        return bResult;
+    }
+
+}
diff --git a/swext/mediawiki/src/com/sun/star/wiki/WikiOptionsEventHandlerImpl.java b/swext/mediawiki/src/com/sun/star/wiki/WikiOptionsEventHandlerImpl.java
new file mode 100644
index 000000000..c35246be4
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/WikiOptionsEventHandlerImpl.java
@@ -0,0 +1,279 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import com.sun.star.awt.XContainerWindowEventHandler;
+import com.sun.star.awt.XControl;
+import com.sun.star.awt.XControlContainer;
+import com.sun.star.awt.XDialog;
+import com.sun.star.awt.XDialogEventHandler;
+import com.sun.star.awt.XWindow;
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.lang.WrappedTargetException;
+import com.sun.star.lang.XServiceInfo;
+import com.sun.star.lib.uno.helper.WeakBase;
+import com.sun.star.uno.AnyConverter;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+import java.util.Map;
+
+public final class WikiOptionsEventHandlerImpl extends WeakBase
+    implements XServiceInfo, XContainerWindowEventHandler, XDialogEventHandler
+{
+    static final String[] m_pServiceNames = { "com.sun.star.wiki.WikiOptionsEventHandler" };
+    static final String m_sImplementationName = WikiOptionsEventHandlerImpl.class.getName();
+
+    private static final String sExternalEvent = "external_event";
+    private static final String sAdd = "Add";
+    private static final String sEdit = "Edit";
+    private static final String sRemove = "Remove";
+    private static final String sListStatus = "ListStatus";
+    private static final String sListEdit = "ListEdit";
+    private static final String sInitialize = "initialize";
+    private static final String sOk = "ok";
+    private static final String sBack = "back";
+
+    private final XComponentContext m_xContext;
+    private XDialog m_xDialog;
+    private XControlContainer m_xControlContainer;
+
+    private Settings m_aSettings;
+
+    public WikiOptionsEventHandlerImpl( XComponentContext xContext )
+    {
+        m_xContext = xContext;
+    }
+
+    private XPropertySet GetPropSet( String sControl )
+    {
+        if ( m_xControlContainer != null )
+        {
+            XControl xControl = m_xControlContainer.getControl(sControl);
+            XPropertySet xListProps = UnoRuntime.queryInterface(XPropertySet.class, xControl.getModel() );
+            return xListProps;
+        }
+
+        return null;
+    }
+
+    private void RefreshView()
+    {
+        if ( m_aSettings != null )
+        {
+            String[] pWikiList = m_aSettings.getWikiURLs();
+            XPropertySet xListProps = GetPropSet( "WikiList" );
+            if ( xListProps != null )
+            {
+                try
+                {
+                    xListProps.setPropertyValue( "StringItemList", pWikiList );
+                }
+                catch ( Exception ex )
+                {
+                    ex.printStackTrace();
+                }
+            }
+        }
+    }
+
+    private void CheckButtonState()
+    {
+        XPropertySet xListProps = GetPropSet( "WikiList" );
+        if ( xListProps != null )
+        {
+            try
+            {
+                short [] pSel = (short []) xListProps.getPropertyValue( "SelectedItems" );
+                XPropertySet xEditProps = GetPropSet( "EditButton" );
+                XPropertySet xRemoveProps = GetPropSet( "RemoveButton" );
+                Boolean bState = Boolean.valueOf( pSel.length != 0 );
+
+                xEditProps.setPropertyValue( "Enabled", bState );
+                xRemoveProps.setPropertyValue( "Enabled", bState );
+            }
+            catch ( Exception ex )
+            {
+                ex.printStackTrace();
+            }
+        }
+    }
+
+    private void AddSetting()
+    {
+        WikiEditSettingDialog aSettingDialog = new WikiEditSettingDialog( m_xContext, "vnd.sun.star.script:WikiEditor.EditSetting?location=application" );
+        if ( aSettingDialog.show() )
+            RefreshView();
+
+        aSettingDialog.DisposeDialog();
+    }
+
+    private void EditSetting()
+    {
+        XPropertySet xListProps = GetPropSet( "WikiList" );
+        if ( xListProps != null )
+        {
+            Map<String,String> ht = null;
+            try
+            {
+                short[] pSel = (short []) xListProps.getPropertyValue( "SelectedItems" );
+                String[] pItems = (String []) xListProps.getPropertyValue("StringItemList");
+                if ( pSel.length > 0 && pItems.length > pSel[0] )
+                {
+                    String selName = pItems[pSel[0]];
+                    ht = m_aSettings.getSettingByUrl( selName );
+                }
+            }
+            catch ( Exception ex )
+            {
+                ex.printStackTrace();
+            }
+
+            WikiEditSettingDialog aSettingDialog = new WikiEditSettingDialog(m_xContext, "vnd.sun.star.script:WikiEditor.EditSetting?location=application", ht, true );
+            if ( aSettingDialog.show() )
+                RefreshView();
+
+            aSettingDialog.DisposeDialog();
+        }
+    }
+
+    private void RemoveSetting()
+    {
+        XPropertySet xListProps = GetPropSet("WikiList");
+        if ( xListProps != null )
+        {
+            try
+            {
+                short[] pSel = (short []) xListProps.getPropertyValue("SelectedItems");
+                String[] pItems = (String []) GetPropSet("WikiList").getPropertyValue("StringItemList");
+                if ( pSel.length > 0 && pItems.length > pSel[0] )
+                {
+                    m_aSettings.removeSettingByUrl( pItems[pSel[0]] );
+                    RefreshView();
+                }
+            }
+            catch (Exception ex)
+            {
+                ex.printStackTrace();
+            }
+        }
+    }
+
+    private void InitStrings()
+    {
+        try
+        {
+            GetPropSet( "FixedLine1" ).setPropertyValue( "Label", Helper.GetLocalizedString( m_xContext, Helper.DLG_MEDIAWIKIEXTENSION_STRING ) );
+            GetPropSet( "AddButton" ).setPropertyValue( "Label", Helper.GetLocalizedString( m_xContext, Helper.DLG_ADDBUTTON ) );
+            GetPropSet( "EditButton" ).setPropertyValue( "Label", Helper.GetLocalizedString( m_xContext, Helper.DLG_EDITBUTTON ) );
+            GetPropSet( "RemoveButton" ).setPropertyValue( "Label", Helper.GetLocalizedString( m_xContext, Helper.DLG_REMOVEBUTTON ) );
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    // com.sun.star.lang.XServiceInfo:
+    public String getImplementationName()
+    {
+         return m_sImplementationName;
+    }
+
+    public boolean supportsService( String sService )
+    {
+        int len = m_pServiceNames.length;
+
+        for( int i=0; i < len; i++ )
+        {
+            if ( sService.equals( m_pServiceNames[i] ))
+                return true;
+        }
+        return false;
+    }
+
+    public String[] getSupportedServiceNames()
+    {
+        return m_pServiceNames;
+    }
+
+    // XContainerWindowEventHandler
+    public boolean callHandlerMethod( XWindow xWindow, Object aEventObject, String sMethod )
+        throws WrappedTargetException, com.sun.star.uno.RuntimeException
+    {
+        if ( sMethod.equals( sExternalEvent ) )
+        {
+            String sEvent = AnyConverter.toString( aEventObject );
+            if ( sEvent != null )
+            {
+                if ( sEvent.equals( sOk ) )
+                {
+                    if ( m_aSettings != null )
+                        m_aSettings.storeConfiguration();
+                }
+                else if ( sEvent.equals( sInitialize ) || sEvent.equals( sBack ) )
+                {
+                    if ( sEvent.equals( sInitialize ) )
+                    {
+                        m_xDialog = UnoRuntime.queryInterface( XDialog.class, xWindow );
+                        m_xControlContainer = UnoRuntime.queryInterface( XControlContainer.class, m_xDialog );
+                        m_aSettings = Settings.getSettings( m_xContext );
+                        m_aSettings.loadConfiguration(); // throw away all the noncommitted changes
+                        InitStrings();
+                    }
+                    else if ( m_aSettings != null )
+                        m_aSettings.loadConfiguration(); // throw away all the noncommitted changes
+
+                    RefreshView();
+                    CheckButtonState();
+                }
+            }
+        }
+        else if ( sMethod.equals( sAdd ) )
+        {
+            AddSetting();
+        }
+        else if ( sMethod.equals( sEdit ) || sMethod.equals( sListEdit ) )
+        {
+            EditSetting();
+        }
+        else if ( sMethod.equals( sRemove ) )
+        {
+            RemoveSetting();
+            CheckButtonState();
+        }
+        else if ( sMethod.equals( sListStatus ) )
+        {
+            CheckButtonState();
+        }
+
+        return true;
+    }
+
+    public boolean callHandlerMethod( XDialog xDialog, Object aEventObject, String sMethod )
+        throws WrappedTargetException, com.sun.star.uno.RuntimeException
+    {
+        return true;
+    }
+
+    public String[] getSupportedMethodNames()
+    {
+        return new String[] { sExternalEvent, sAdd, sEdit, sRemove };
+    }
+}
+
diff --git a/swext/mediawiki/src/com/sun/star/wiki/WikiPropDialog.java b/swext/mediawiki/src/com/sun/star/wiki/WikiPropDialog.java
new file mode 100644
index 000000000..9ac41d4d3
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/WikiPropDialog.java
@@ -0,0 +1,372 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import java.util.Map;
+
+import com.sun.star.awt.XDialog;
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.lang.EventObject;
+import com.sun.star.uno.XComponentContext;
+
+public class WikiPropDialog extends WikiDialog{
+
+    private WikiEditorImpl m_aWikiEditor;
+
+    private static final String sSendMethod = "Send";
+    private static final String sWikiListMethod = "WikiListChange";
+    private static final String sArticleTextMethod = "ArticleTextChange";
+    private static final String sAddWikiMethod = "AddWiki";
+
+    private final String[] m_pMethods = {sSendMethod, sWikiListMethod, sArticleTextMethod, sAddWikiMethod};
+
+    private String m_sWikiTitle = "";
+    private String m_sWikiEngineURL = "";
+    protected String m_sWikiComment = "";
+    protected boolean m_bWikiMinorEdit = false;
+
+    /** Creates a new instance of WikiPropDialog */
+    public WikiPropDialog(XComponentContext xContext, String DialogURL, WikiEditorImpl aWikiEditorForThrobber )
+    {
+        super(xContext, DialogURL);
+        super.setMethods(m_pMethods);
+
+        if ( aWikiEditorForThrobber != null )
+        {
+            InsertThrobber( 224, 122, 10, 10 );
+            m_aWikiEditor = aWikiEditorForThrobber;
+        }
+
+        InitStrings( xContext );
+        InitShowBrowser();
+        InitControls();
+    }
+
+    private void InitControls()
+    {
+        try
+        {
+            GetPropSet( "CommentText" ).setPropertyValue( "AutoVScroll", Boolean.TRUE );
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    private void InitStrings( XComponentContext xContext )
+    {
+        try
+        {
+            SetTitle( Helper.GetLocalizedString( xContext, Helper.DLG_SENDTITLE ) );
+            GetPropSet( "Label1" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_SENDTOMEDIAWIKI_LABEL1 ) );
+            GetPropSet( "FixedLine2" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_WIKIARTICLE ) );
+            GetPropSet( "Label2" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_SENDTOMEDIAWIKI_LABEL2 ) );
+            GetPropSet( "Label3" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_SENDTOMEDIAWIKI_LABEL3 ) );
+            GetPropSet( "MinorCheck" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_SENDTOMEDIAWIKI_MINORCHECK ) );
+            GetPropSet( "BrowserCheck" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_SENDTOMEDIAWIKI_BROWSERCHECK ) );
+            GetPropSet( "AddButton" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_ADDBUTTON ) );
+            GetPropSet( "SendButton" ).setPropertyValue( "Label", Helper.GetLocalizedString( xContext, Helper.DLG_SENDBUTTON ) );
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    private void InitShowBrowser()
+    {
+        try
+        {
+            GetPropSet( "BrowserCheck" ).setPropertyValue( "State", Short.valueOf( Helper.GetShowInBrowserByDefault( m_xContext ) ? (short)1 : (short)0 ) );
+        }
+        catch( Exception e )
+        {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public boolean show()
+    {
+        EnableControls( true );
+        boolean bResult = super.show();
+
+        if ( bResult && Helper.GetShowInBrowserByDefault( m_xContext ) )
+           Helper.ShowURLInBrowser( m_xContext, m_sWikiEngineURL + "index.php?title=" + m_sWikiTitle );
+
+        return bResult;
+    }
+
+    @Override
+    public synchronized void ThreadStop( boolean bSelf )
+    {
+        boolean bShowError = ( !bSelf && m_aThread != null && !m_bThreadFinished );
+
+        super.ThreadStop( bSelf );
+
+        if ( bShowError )
+            Helper.ShowError( m_xContext,
+                              m_xDialog,
+                              Helper.DLG_SENDTITLE,
+                              Helper.CANCELSENDING_ERROR,
+                              null,
+                              false );
+    }
+
+    public void fillWikiList()
+    {
+        String [] WikiList = m_aSettings.getWikiURLs();
+
+        try
+        {
+            XPropertySet xPS = GetPropSet("WikiList");
+            xPS.setPropertyValue("StringItemList", WikiList);
+        }
+        catch (Exception ex)
+        {
+            ex.printStackTrace();
+        }
+    }
+
+    private void fillDocList()
+    {
+        XPropertySet xPS = GetPropSet("ArticleText");
+        try
+        {
+            short [] sel = (short[]) GetPropSet("WikiList").getPropertyValue("SelectedItems");
+            xPS.setPropertyValue("StringItemList", m_aSettings.getWikiDocList(sel[0]));
+        }
+        catch (Exception ex)
+        {
+            ex.printStackTrace();
+        }
+    }
+
+
+    public String GetWikiTitle()
+    {
+        return m_sWikiTitle;
+    }
+
+    public void SetWikiTitle(String sArticle)
+    {
+        m_sWikiTitle = sArticle;
+        try
+        {
+            XPropertySet xPS = GetPropSet("ArticleText");
+            xPS.setPropertyValue("Text", sArticle);
+        }
+        catch (Exception ex)
+        {
+            ex.printStackTrace();
+        }
+    }
+
+
+    private void switchSendButtonIfNecessary()
+    {
+        XPropertySet xSendButton = GetPropSet( "SendButton" );
+        if ( xSendButton != null )
+        {
+            XPropertySet xWikiListProps = GetPropSet( "WikiList" );
+            XPropertySet xArticleProps = GetPropSet( "ArticleText" );
+            if ( xWikiListProps != null && xArticleProps != null )
+            {
+                try
+                {
+                    short [] pSel = (short[]) GetPropSet("WikiList").getPropertyValue("SelectedItems");
+                    String sArticle = (String)xArticleProps.getPropertyValue( "Text" );
+                    if ( pSel != null && pSel.length > 0 && sArticle != null && sArticle.length() != 0 )
+                        xSendButton.setPropertyValue( "Enabled", Boolean.TRUE );
+                    else
+                        xSendButton.setPropertyValue( "Enabled", Boolean.FALSE );
+                }
+                catch (Exception ex)
+                {
+                    ex.printStackTrace();
+                }
+            }
+        }
+    }
+
+    private void EnableControls( boolean bEnable )
+    {
+        try
+        {
+            String[] pControls = { "WikiList",
+                                   "ArticleText",
+                                   "CommentText",
+                                   "MinorCheck",
+                                   "BrowserCheck",
+                                   "HelpButton",
+                                   "AddButton" };
+
+            for ( int nInd = 0; nInd < pControls.length; nInd++ )
+                GetPropSet( pControls[nInd] ).setPropertyValue( "Enabled", Boolean.valueOf( bEnable ) );
+
+            if ( bEnable )
+            {
+                SetFocusTo( "WikiList" );
+                switchSendButtonIfNecessary();
+            }
+            else
+            {
+                GetPropSet( "SendButton" ).setPropertyValue( "Enabled", Boolean.valueOf( bEnable ) );
+                SetFocusTo( "CancelButton" );
+            }
+        }
+        catch (Exception ex)
+        {
+            ex.printStackTrace();
+        }
+    }
+
+    @Override
+    public boolean callHandlerMethod( XDialog xDialog, Object EventObject, String MethodName )
+    {
+        if ( MethodName.equals( sSendMethod ) )
+        {
+            try
+            {
+                XPropertySet aWikiListProps = GetPropSet( "WikiList" );
+                XPropertySet aArticleTextProps = GetPropSet( "ArticleText" );
+                XPropertySet aCommentTextProps = GetPropSet( "CommentText" );
+                XPropertySet aMinorCheckProps = GetPropSet( "MinorCheck" );
+                XPropertySet aBrowserCheckProps = GetPropSet( "BrowserCheck" );
+
+                short [] sel = (short[]) aWikiListProps.getPropertyValue("SelectedItems");
+                String [] items = (String []) aWikiListProps.getPropertyValue("StringItemList");
+                m_sWikiEngineURL = items[sel[0]];
+                m_sWikiTitle = (String) aArticleTextProps.getPropertyValue("Text");
+                m_sWikiComment = (String) aCommentTextProps.getPropertyValue("Text");
+
+                short minorState = ((Short) aMinorCheckProps.getPropertyValue("State")).shortValue();
+                if (minorState != 0)
+                    m_bWikiMinorEdit = true;
+                else
+                    m_bWikiMinorEdit = false;
+
+                short nBrowserState = ((Short) aBrowserCheckProps.getPropertyValue("State")).shortValue();
+                Helper.SetShowInBrowserByDefault( m_xContext, nBrowserState != 0 );
+
+                // allow to disable other buttons
+                EnableControls( false );
+            }
+            catch (Exception ex)
+            {
+                ex.printStackTrace();
+            }
+
+            final XDialog xDialogToClose = xDialog;
+            final XComponentContext xContext = m_xContext;
+
+            // start spinning
+            SetThrobberVisible( true );
+            SetThrobberActive( true );
+
+            // the following method might show a dialog, should be used in main thread
+            final Map<String,String> aWikiSettings = m_aSettings.getSettingByUrl( m_sWikiEngineURL );
+            if ( Helper.AllowThreadUsage( m_xContext ) )
+            {
+                m_aThread = new Thread( "com.sun.star.thread.WikiEditorSendingThread" )
+                {
+                    @Override
+                    public void run()
+                    {
+                        try
+                        {
+                            if ( m_aWikiEditor != null )
+                            {
+                                Thread.yield();
+                                m_bAction = m_aWikiEditor.SendArticleImpl(
+                                        WikiPropDialog.this, aWikiSettings);
+                            }
+                        }
+                        finally
+                        {
+                            EnableControls( true );
+                            SetThrobberActive( false );
+                            SetThrobberVisible( false );
+
+                            ThreadStop( true );
+                            if ( m_bAction )
+                                MainThreadDialogExecutor.Close( xContext, xDialogToClose );
+                        }
+                    }
+                };
+
+                m_aThread.start();
+            }
+            else
+            {
+                try
+                {
+                    if (m_aWikiEditor != null && aWikiSettings != null)
+                    {
+                        m_bAction = m_aWikiEditor.SendArticleImpl(
+                                WikiPropDialog.this, aWikiSettings);
+                    }
+                } catch( java.lang.Exception e )
+                {}
+                finally
+                {
+                    EnableControls( true );
+                    SetThrobberActive( false );
+                    SetThrobberVisible( false );
+
+                    if ( m_bAction )
+                        xDialogToClose.endExecute();
+                }
+            }
+
+            return true;
+        }
+        else if ( MethodName.equals( sWikiListMethod ) )
+        {
+            fillDocList();
+            switchSendButtonIfNecessary();
+            return true;
+        }
+        else if ( MethodName.equals( sArticleTextMethod ) )
+        {
+            switchSendButtonIfNecessary();
+            return true;
+        }
+        else if ( MethodName.equals( sAddWikiMethod ) )
+        {
+            WikiEditSettingDialog xAddDialog = new WikiEditSettingDialog(m_xContext, "vnd.sun.star.script:WikiEditor.EditSetting?location=application");
+            if ( xAddDialog.show() )
+                fillWikiList();
+
+            xAddDialog.DisposeDialog();
+
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public void windowClosed( EventObject e )
+    {
+        ThreadStop( false );
+    }
+}
+
diff --git a/swext/mediawiki/src/com/sun/star/wiki/WikiProtocolSocketFactory.java b/swext/mediawiki/src/com/sun/star/wiki/WikiProtocolSocketFactory.java
new file mode 100644
index 000000000..17527cad1
--- /dev/null
+++ b/swext/mediawiki/src/com/sun/star/wiki/WikiProtocolSocketFactory.java
@@ -0,0 +1,330 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   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 .
+ */
+
+package com.sun.star.wiki;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.UnknownHostException;
+import java.security.KeyStore;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+
+class WikiProtocolSocketFactory extends SSLSocketFactory
+{
+    private SSLContext m_aSSLContext;
+
+    private synchronized SSLContext GetNotSoSecureSSLContext()
+    {
+        if ( m_aSSLContext != null ) {
+            return m_aSSLContext;
+        }
+        TrustManager[] pTrustUnknownCerts = new TrustManager[]
+        {
+            new X509TrustManager() {
+                private X509TrustManager m_aOrgTrustManager;
+
+                private X509TrustManager GetOrgTrustManager()
+                {
+                    if ( m_aOrgTrustManager == null )
+                    {
+                        try
+                        {
+                            TrustManagerFactory aFactory = TrustManagerFactory.getInstance( TrustManagerFactory.getDefaultAlgorithm() );
+                            aFactory.init( (KeyStore)null );
+                            TrustManager[] pTrustmanagers = aFactory.getTrustManagers();
+                            if ( pTrustmanagers.length != 0 && pTrustmanagers[0] != null )
+                                m_aOrgTrustManager = (X509TrustManager)pTrustmanagers[0];
+                        }
+                        catch( Exception e )
+                        {
+                            throw new RuntimeException( "No access to the default trust manager!", e );
+                        }
+                    }
+
+                    return m_aOrgTrustManager;
+                }
+
+                public X509Certificate[] getAcceptedIssuers()
+                {
+                    return GetOrgTrustManager().getAcceptedIssuers();
+                }
+
+                public void checkClientTrusted(X509Certificate[] certs, String authType) throws CertificateException
+                {
+                    GetOrgTrustManager().checkClientTrusted( certs, authType );
+                }
+
+                public void checkServerTrusted(X509Certificate[] certs, String authType) throws CertificateException
+                {
+                    if ( certs == null || certs.length == 0 )
+                        GetOrgTrustManager().checkServerTrusted( certs, authType );
+                    else
+                        for ( int nInd = 0; nInd < certs.length; nInd++ )
+                            certs[nInd].checkValidity();
+                }
+            }
+        };
+
+        try
+        {
+            SSLContext aContext = SSLContext.getInstance("SSL");
+            if ( aContext != null )
+            {
+                aContext.init( null, pTrustUnknownCerts, null );
+                m_aSSLContext = aContext;
+            }
+        }
+        catch ( Exception e )
+        {
+        }
+
+        if ( m_aSSLContext == null )
+            throw new RuntimeException("failed to create SSLContext");
+
+        return m_aSSLContext;
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port)
+        throws IOException
+    {
+        return GetNotSoSecureSSLContext().getSocketFactory().createSocket(address, port);
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)
+        throws IOException
+    {
+        return GetNotSoSecureSSLContext().getSocketFactory().createSocket(address, port, localAddress, localPort);
+    }
+
+    @Override
+    public Socket createSocket( String sHost, int nPort, InetAddress clientHost, int clientPort )
+        throws IOException, UnknownHostException
+    {
+        return GetNotSoSecureSSLContext().getSocketFactory().createSocket( sHost, nPort, clientHost, clientPort );
+    }
+
+    @Override
+    public Socket createSocket( String sHost, int nPort )
+        throws IOException, UnknownHostException
+    {
+        return GetNotSoSecureSSLContext().getSocketFactory().createSocket( sHost, nPort );
+    }
+
+    @Override
+    public Socket createSocket( Socket aSocket, String sHost, int nPort, boolean bAutoClose )
+        throws IOException
+    {
+        return GetNotSoSecureSSLContext().getSocketFactory().createSocket( aSocket, sHost, nPort, bAutoClose );
+    }
+
+    @Override
+    public String[] getDefaultCipherSuites()
+    {
+        return GetNotSoSecureSSLContext().getSocketFactory().getDefaultCipherSuites();
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites()
+    {
+        return GetNotSoSecureSSLContext().getSocketFactory().getSupportedCipherSuites();
+    }
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        return (obj != null) && (obj instanceof WikiProtocolSocketFactory);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return WikiProtocolSocketFactory.class.hashCode();
+    }
+}
+
+// A factory that creates streams that log everything that's written
+// to stderr - useful for debugging encrypted TLS connections
+class LoggingProtocolSocketFactory extends SSLSocketFactory
+{
+    private static class LogSocket extends SSLSocket
+    {
+        private final SSLSocket m_Socket;
+
+        public LogSocket(SSLSocket socket)
+        {
+            m_Socket = socket;
+        }
+
+        private static class LogStream extends java.io.FilterOutputStream
+        {
+            public LogStream(java.io.OutputStream stream)
+            {
+                super(stream);
+            }
+
+            @Override
+            public void write(byte[] buf, int offset, int len)
+                throws IOException
+            {
+                System.err.println("LogStream.write: \"" + new String(buf, offset, len, "UTF-8") + "\"");
+                out.write(buf, offset, len);
+            }
+        }
+
+        @Override
+        public java.io.OutputStream getOutputStream() throws IOException
+        {
+            return new LogStream(m_Socket.getOutputStream());
+        }
+
+        @Override public void addHandshakeCompletedListener(javax.net.ssl.HandshakeCompletedListener listener) { m_Socket.addHandshakeCompletedListener(listener); }
+        @Override public String[] getEnabledCipherSuites() { return m_Socket.getEnabledCipherSuites(); }
+        @Override public String[] getEnabledProtocols() { return m_Socket.getEnabledProtocols(); }
+        @Override public boolean getEnableSessionCreation() { return m_Socket.getEnableSessionCreation(); }
+        @Override public boolean getNeedClientAuth() { return m_Socket.getNeedClientAuth(); }
+        @Override public javax.net.ssl.SSLSession getSession() { return m_Socket.getSession(); }
+        @Override public javax.net.ssl.SSLParameters getSSLParameters() { return m_Socket.getSSLParameters(); }
+        @Override public String[] getSupportedCipherSuites() { return m_Socket.getSupportedCipherSuites(); }
+        @Override public String[] getSupportedProtocols() { return m_Socket.getSupportedProtocols(); }
+        @Override public boolean getUseClientMode() { return m_Socket.getUseClientMode(); }
+        @Override public boolean getWantClientAuth() { return m_Socket.getWantClientAuth(); }
+        @Override public void removeHandshakeCompletedListener(javax.net.ssl.HandshakeCompletedListener listener) { m_Socket.removeHandshakeCompletedListener(listener); }
+        @Override public void setEnabledCipherSuites(String[] suites) { m_Socket.setEnabledCipherSuites(suites); }
+        @Override public void setEnabledProtocols(String[] protocols) { m_Socket.setEnabledProtocols(protocols); }
+        @Override public void setEnableSessionCreation(boolean flag) { m_Socket.setEnableSessionCreation(flag); }
+        @Override public void setNeedClientAuth(boolean need) { m_Socket.setNeedClientAuth(need); }
+        @Override public void setSSLParameters(javax.net.ssl.SSLParameters params) { m_Socket.setSSLParameters(params); }
+        @Override public void setUseClientMode(boolean mode) { m_Socket.setUseClientMode(mode); }
+        @Override public void setWantClientAuth(boolean want) { m_Socket.setWantClientAuth(want); }
+        @Override public void startHandshake() throws IOException { m_Socket.startHandshake(); }
+
+        @Override public void bind(java.net.SocketAddress bindpoint) throws IOException { m_Socket.bind(bindpoint); }
+        @Override public void close() throws IOException { m_Socket.close(); }
+        @Override public void connect(java.net.SocketAddress endpoint) throws IOException { m_Socket.connect(endpoint); }
+        @Override public void connect(java.net.SocketAddress endpoint, int timeout) throws IOException { m_Socket.connect(endpoint, timeout); }
+        @Override public java.nio.channels.SocketChannel getChannel() { return m_Socket.getChannel(); }
+        @Override public InetAddress getInetAddress() { return m_Socket.getInetAddress(); }
+        @Override public java.io.InputStream getInputStream() throws IOException { return m_Socket.getInputStream(); }
+        @Override public boolean getKeepAlive() throws java.net.SocketException { return m_Socket.getKeepAlive(); }
+        @Override public InetAddress getLocalAddress() { return m_Socket.getLocalAddress(); }
+        @Override public int getLocalPort() { return m_Socket.getLocalPort(); }
+        @Override public java.net.SocketAddress getLocalSocketAddress() { return m_Socket.getLocalSocketAddress(); }
+        @Override public boolean getOOBInline() throws java.net.SocketException { return m_Socket.getOOBInline(); }
+        @Override public int getPort() { return m_Socket.getPort(); }
+        @Override public int getReceiveBufferSize() throws java.net.SocketException { return m_Socket.getReceiveBufferSize(); }
+        @Override public java.net.SocketAddress getRemoteSocketAddress() { return m_Socket.getRemoteSocketAddress(); }
+        @Override public boolean getReuseAddress() throws java.net.SocketException { return m_Socket.getReuseAddress(); }
+        @Override public int getSendBufferSize() throws java.net.SocketException { return m_Socket.getSendBufferSize(); }
+        @Override public int getSoLinger() throws java.net.SocketException { return m_Socket.getSoLinger(); }
+        @Override public int getSoTimeout() throws java.net.SocketException { return m_Socket.getSoTimeout(); }
+        @Override public boolean getTcpNoDelay() throws java.net.SocketException { return m_Socket.getTcpNoDelay(); }
+        @Override public int getTrafficClass() throws java.net.SocketException { return m_Socket.getTrafficClass(); }
+        @Override public boolean isBound() { return m_Socket.isBound(); }
+        @Override public boolean isClosed() { return m_Socket.isClosed(); }
+        @Override public boolean isConnected() { return m_Socket.isConnected(); }
+        @Override public boolean isInputShutdown() { return m_Socket.isInputShutdown(); }
+        @Override public boolean isOutputShutdown() { return m_Socket.isOutputShutdown(); }
+        @Override public void sendUrgentData(int data) throws IOException { m_Socket.sendUrgentData(data); }
+        @Override public void setKeepAlive(boolean on) throws java.net.SocketException { m_Socket.setKeepAlive(on); }
+        @Override public void setOOBInline(boolean on) throws java.net.SocketException { m_Socket.setOOBInline(on); }
+        @Override public void setPerformancePreferences(int connectionTime, int latency, int bandwidth) { m_Socket.setPerformancePreferences(connectionTime, latency, bandwidth); }
+        @Override public void setReceiveBufferSize(int size) throws java.net.SocketException { m_Socket.setReceiveBufferSize(size); }
+        @Override public void setReuseAddress(boolean on) throws java.net.SocketException { m_Socket.setReuseAddress(on); }
+        @Override public void setSendBufferSize(int size) throws java.net.SocketException { m_Socket.setSendBufferSize(size); }
+        @Override public void setSoLinger(boolean on, int linger) throws java.net.SocketException { m_Socket.setSoLinger(on, linger); }
+        @Override public void setSoTimeout(int timeout) throws java.net.SocketException{ m_Socket.setSoTimeout(timeout); }
+        @Override public void setTcpNoDelay(boolean on) throws java.net.SocketException{ m_Socket.setTcpNoDelay(on); }
+        @Override public void setTrafficClass(int tc) throws java.net.SocketException { m_Socket.setTrafficClass(tc); }
+        @Override public void shutdownInput() throws IOException { m_Socket.shutdownInput(); }
+        @Override public void shutdownOutput() throws IOException { m_Socket.shutdownOutput(); }
+        @Override public String toString() { return m_Socket.toString(); }
+
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port)
+        throws IOException
+    {
+        return new LogSocket((SSLSocket) SSLSocketFactory.getDefault().createSocket(address, port));
+    }
+
+    @Override
+    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort)
+        throws IOException
+    {
+        return new LogSocket((SSLSocket) SSLSocketFactory.getDefault().createSocket(address, port, localAddress, localPort));
+    }
+
+    @Override
+    public Socket createSocket( String sHost, int nPort, InetAddress clientHost, int clientPort )
+        throws IOException, UnknownHostException
+    {
+        return new LogSocket((SSLSocket) SSLSocketFactory.getDefault().createSocket(sHost, nPort, clientHost, clientPort));
+    }
+
+    @Override
+    public Socket createSocket( String sHost, int nPort )
+        throws IOException, UnknownHostException
+    {
+        return new LogSocket((SSLSocket) SSLSocketFactory.getDefault().createSocket(sHost, nPort));
+    }
+
+    @Override
+    public Socket createSocket( Socket aSocket, String sHost, int nPort, boolean bAutoClose )
+        throws IOException
+    {
+        return new LogSocket((SSLSocket) ((SSLSocketFactory) SSLSocketFactory.getDefault()).createSocket(aSocket, sHost, nPort, bAutoClose));
+    }
+
+    @Override
+    public String[] getDefaultCipherSuites()
+    {
+        // have to implement abstract method, just use the default
+        return ((SSLSocketFactory) SSLSocketFactory.getDefault()).getDefaultCipherSuites();
+    }
+
+    @Override
+    public String[] getSupportedCipherSuites()
+    {
+        // have to implement abstract method, just use the default
+        return ((SSLSocketFactory) SSLSocketFactory.getDefault()).getSupportedCipherSuites();
+    }
+
+    @Override
+    public boolean equals(Object obj)
+    {
+        return (obj != null) && (obj instanceof LoggingProtocolSocketFactory);
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return LoggingProtocolSocketFactory.class.hashCode();
+    }
+}
+