/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
package com.sun.star.wiki;
import com.sun.star.awt.XDialog;
import com.sun.star.awt.XWindowPeer;
import com.sun.star.beans.PropertyValue;
import com.sun.star.frame.DispatchDescriptor;
import com.sun.star.frame.XComponentLoader;
import com.sun.star.frame.XController;
import com.sun.star.frame.XDesktop;
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.XStatusListener;
import com.sun.star.frame.XStorable;
import com.sun.star.io.XInputStream;
import com.sun.star.lang.XComponent;
import com.sun.star.lang.XInitialization;
import com.sun.star.uno.UnoRuntime;
import com.sun.star.uno.XComponentContext;
import com.sun.star.lib.uno.helper.Factory;
import com.sun.star.lang.XSingleComponentFactory;
import com.sun.star.registry.XRegistryKey;
import com.sun.star.lib.uno.helper.WeakBase;
import com.sun.star.util.XCloseBroadcaster;
import com.sun.star.view.XSelectionSupplier;
import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import javax.net.ssl.SSLException;
public final class WikiEditorImpl extends WeakBase
implements com.sun.star.lang.XServiceInfo, XDispatchProvider, XDispatch, XInitialization
{
private final XComponentContext m_xContext;
private static final String m_implementationName = WikiEditorImpl.class.getName();
private static final String[] m_serviceNames = {"com.sun.star.wiki.WikiEditor" };
// information needed for component registration
public static final String[] supportedServiceNames = {"com.sun.star.frame.ProtocolHandler"};
public static final Class implementationClass = WikiEditorImpl.class;
// protocol name that this protocol handler handles
public static final String protocolName = "vnd.com.sun.star.wiki:";
private Map m_statusListeners = new HashMap();
private XComponent xComp;
private String sTempUrl;
private XFrame m_xFrame;
private XModel m_xModel;
private 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;
}
public static boolean __writeRegistryServiceInfo( XRegistryKey xRegistryKey )
{
boolean bResult = Factory.writeRegistryServiceInfo( m_implementationName,
m_serviceNames,
xRegistryKey );
return ( bResult && Factory.writeRegistryServiceInfo( WikiOptionsEventHandlerImpl.m_sImplementationName,
WikiOptionsEventHandlerImpl.m_pServiceNames,
xRegistryKey ) );
}
// 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;
}
private XSelectionSupplier m_sel;
private XController m_ctrl;
private boolean m_bInitialized;
public synchronized void initialize( Object[] args ) throws com.sun.star.uno.Exception
{
if ( m_bInitialized )
{
//logger.log( Level.SEVERE, "Extension instance was initialized again" );
}
if ( args.length > 0 )
{
m_bInitialized = true;
m_xFrame = ( XFrame )UnoRuntime.queryInterface( XFrame.class, args[0] );
// become close listener
XCloseBroadcaster cb = ( XCloseBroadcaster )UnoRuntime.queryInterface(
XCloseBroadcaster.class, m_xFrame );
}
}
public void dispatch(
final com.sun.star.util.URL aURL,
com.sun.star.beans.PropertyValue[] propertyValue )
{
final com.sun.star.util.URL myURL = aURL;
//logger.log( Level.INFO, "received dispatch request for: "+aURL.Complete );
if ( aURL.Protocol.compareTo( protocolName ) == 0 )
{
/*
synchronized( this )
{
if( m_bClosing ) return;
else m_bActive = true;
}
**/
try
{
if ( myURL.Path.compareTo( "send" ) == 0 )
{
sendArticle();
}
} catch( java.lang.Throwable t )
{
//logger.log( Level.WARNING, "exception while handeling dispatch", t );
}
/*
synchronized( this )
{
m_bActive = false;
// if we became owner while we were active
// we are responsible for closing the m_xFrame now
if ( m_bOwner && m_xFrame != null )
{
try
{
XCloseable xclose = ( XCloseable )UnoRuntime.queryInterface(
XCloseable.class, m_xFrame );
xclose.close( true );
} catch ( CloseVetoException cve )
{
logger.log( Level.SEVERE, "cannot close owned frame" );
}
// relase reference to the m_xFrame;
m_xFrame = null;
}
}
*/
}
}
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 )
{
String urlstring = url.Complete;
m_statusListeners.put( urlstring, listener );
// synchroneous callback required!!!
callStatusListener( urlstring, listener );
}
public void callStatusListeners()
{
Set entries = m_statusListeners.entrySet();
Iterator iter = entries.iterator();
while ( iter.hasNext() )
{
Map.Entry entry = ( Map.Entry ) iter.next();
String uristring = ( String ) entry.getKey();
XStatusListener listener = ( XStatusListener ) entry.getValue();
callStatusListener( uristring, listener );
}
}
public void callStatusListener( String uristring, XStatusListener listener )
{
try
{
URI uri = new URI( uristring );
// check whether any blogs are live...
setListenerState( listener, "command", false );
} catch ( URISyntaxException ex )
{
ex.printStackTrace();
}
}
private void setListenerState( XStatusListener listener, String urlstring, boolean state )
{
com.sun.star.util.URL url = new com.sun.star.util.URL();
url.Complete = urlstring;
//listener.statusChanged( new FeatureStateEvent( this, url, "", state, false, null ));
}
public 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,
(XWindowPeer)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 noncommited 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, Hashtable 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,
(XWindowPeer)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 = new Boolean( true );
sTemp2Url = Helper.CreateTempFile( m_xContext );
XStorable xStore = ( com.sun.star.frame.XStorable )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;
Object desktop = m_xContext.getServiceManager().createInstanceWithContext( "com.sun.star.frame.Desktop", m_xContext );
XDesktop xDesktop = ( XDesktop ) UnoRuntime.queryInterface( com.sun.star.frame.XDesktop.class, desktop );
Helper.SetDocTitle( m_xModel, aArticle.GetTitle() );
Hashtable aDocInfo = new Hashtable();
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,
(XWindowPeer)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,
(XWindowPeer)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,
(XWindowPeer)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 ) );
aFile.delete();
}
catch ( java.lang.Exception e )
{
e.printStackTrace();
}
}
}
return bResult;
}
}