зеркало из https://github.com/mozilla/gecko-dev.git
154 строки
4.8 KiB
C++
154 строки
4.8 KiB
C++
/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public
|
|
* License Version 1.1 (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.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is the Mozilla browser.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape
|
|
* Communications, Inc. Portions created by Netscape are
|
|
* Copyright (C) 1999, Mozilla. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Scott MacGregor <mscott@netscape.com>
|
|
*/
|
|
|
|
#include "nsOSHelperAppService.h"
|
|
#include "nsISupports.h"
|
|
#include "nsString.h"
|
|
#include "nsXPIDLString.h"
|
|
#include "nsIURL.h"
|
|
#include "nsILocalFile.h"
|
|
#include <stdlib.h> // for system()
|
|
|
|
|
|
nsOSHelperAppService::nsOSHelperAppService() : nsExternalHelperAppService()
|
|
{
|
|
}
|
|
|
|
nsOSHelperAppService::~nsOSHelperAppService()
|
|
{}
|
|
|
|
|
|
NS_IMETHODIMP nsOSHelperAppService::CanHandleContent(const char *aMimeContentType, nsIURI * aURI, PRBool * aCanHandleContent)
|
|
{
|
|
// once we have user over ride stuff working, we need to first call up to our base class
|
|
// and ask the base class if we can handle the content. This will take care of looking for user specified
|
|
// apps for content types.
|
|
|
|
// for now we only have defaults to worry about...
|
|
// go look up in the windows registry to see if there is a handler for this mime type...if there is return TRUE...
|
|
|
|
*aCanHandleContent = PR_FALSE;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsOSHelperAppService::DoContent(const char *aMimeContentType, nsIURI *aURI, nsISupports *aWindowContext,
|
|
PRBool *aAbortProcess, nsIStreamListener ** aStreamListener)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
// see if we have user specified information for handling this content type by giving the base class
|
|
// first crack at it...
|
|
|
|
rv = nsExternalHelperAppService::DoContent(aMimeContentType, aURI, aWindowContext, aAbortProcess, aStreamListener);
|
|
|
|
// this is important!! if do content for the base class returned any success code, then assume we are done
|
|
// and don't even play around with
|
|
if (NS_SUCCEEDED(rv)) return NS_OK;
|
|
|
|
// there is no registry on linux (like there is on win32)
|
|
// so we can only make up a dummy mime type for this content....
|
|
nsCOMPtr<nsIMIMEInfo> mimeInfo (do_CreateInstance(NS_MIMEINFO_CONTRACTID));
|
|
nsCAutoString fileExtension;
|
|
|
|
*aStreamListener = nsnull;
|
|
if (aURI)
|
|
{
|
|
nsCOMPtr<nsIURL> url = do_QueryInterface(aURI);
|
|
if (url) {
|
|
nsXPIDLCString extenion;
|
|
url->GetFileExtension(getter_Copies(extenion));
|
|
|
|
fileExtension = ".";
|
|
fileExtension.Append(extenion);
|
|
}
|
|
}
|
|
|
|
if (mimeInfo)
|
|
{
|
|
if (!fileExtension.IsEmpty())
|
|
mimeInfo->SetFileExtensions(fileExtension);
|
|
mimeInfo->SetMIMEType(aMimeContentType);
|
|
|
|
// this code is incomplete and just here to get things started..
|
|
nsExternalAppHandler * handler = CreateNewExternalHandler(mimeInfo, fileExtension, aWindowContext);
|
|
handler->QueryInterface(NS_GET_IID(nsIStreamListener), (void **) aStreamListener);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsOSHelperAppService::LaunchAppWithTempFile(nsIMIMEInfo * aMIMEInfo, nsIFile * aTempFile)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
if (aMIMEInfo)
|
|
{
|
|
nsCOMPtr<nsIFile> application;
|
|
nsXPIDLCString path;
|
|
aTempFile->GetPath(getter_Copies(path));
|
|
|
|
aMIMEInfo->GetPreferredApplicationHandler(getter_AddRefs(application));
|
|
if (application)
|
|
{
|
|
// if we were given an application to use then use it....otherwise
|
|
// make the registry call to launch the app
|
|
const char * strPath = (const char *) path;
|
|
application->Spawn(&strPath, 1);
|
|
}
|
|
else
|
|
{
|
|
// if we had hooks into the OS we can use them here to launch the app
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP nsOSHelperAppService::ExternalProtocolHandlerExists(const char * aProtocolScheme, PRBool * aHandlerExists)
|
|
{
|
|
// look up the protocol scheme in the windows registry....if we find a match then we have a handler for it...
|
|
*aHandlerExists = PR_FALSE;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsOSHelperAppService::LoadUrl(nsIURI * aURL)
|
|
{
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsresult nsOSHelperAppService::GetFileTokenForPath(const PRUnichar * platformAppPath, nsIFile ** aFile)
|
|
{
|
|
nsCOMPtr<nsILocalFile> localFile (do_CreateInstance(NS_LOCAL_FILE_CONTRACTID));
|
|
nsresult rv = NS_OK;
|
|
|
|
if (localFile)
|
|
{
|
|
if (localFile)
|
|
localFile->InitWithUnicodePath(platformAppPath);
|
|
*aFile = localFile;
|
|
NS_IF_ADDREF(*aFile);
|
|
}
|
|
else
|
|
rv = NS_ERROR_FAILURE;
|
|
|
|
return rv;
|
|
}
|