From aab38ad60d82d22f90f1896e2293e954c5bef107 Mon Sep 17 00:00:00 2001 From: "mkaply%us.ibm.com" Date: Mon, 1 May 2000 22:21:43 +0000 Subject: [PATCH] # 37239 r= mkaply@us.ibm.com OS/2 bring up continues - checking in files for the OS/2 team --- gfx/src/os2/nsFontMetricsOS2.cpp | 13 +- gfx/src/os2/nsFontMetricsOS2.h | 10 +- intl/locale/src/os2/nsCollationOS2.cpp | 4 + intl/locale/src/os2/nsLocaleModule.cpp | 9 +- widget/src/os2/nsMenuItem.cpp | 20 +- widget/src/os2/nsMenuItem.h | 3 + widget/src/os2/nsToolkit.cpp | 55 + xpcom/io/nsLocalFileOS2.cpp | 1050 +++++++++++++++++ xpcom/io/nsLocalFileOS2.h | 127 ++ xpfe/global/resources/content/os2/Makefile.in | 43 + .../content/os2/platformBrowserBindings.xul | 36 + .../content/os2/platformDialogOverlay.xul | 27 + .../content/os2/platformEditorBindings.xul | 98 ++ .../content/os2/platformGlobalOverlay.xul | 28 + .../content/os2/platformInputBindings.xul | 78 ++ .../content/os2/platformTextAreaBindings.xul | 86 ++ xpfe/global/resources/skin/os2/Makefile.in | 0 .../skin/os2/platformHTMLBindings.xml | 135 +++ 18 files changed, 1810 insertions(+), 12 deletions(-) create mode 100644 xpcom/io/nsLocalFileOS2.cpp create mode 100644 xpcom/io/nsLocalFileOS2.h create mode 100644 xpfe/global/resources/content/os2/Makefile.in create mode 100644 xpfe/global/resources/content/os2/platformBrowserBindings.xul create mode 100644 xpfe/global/resources/content/os2/platformDialogOverlay.xul create mode 100644 xpfe/global/resources/content/os2/platformEditorBindings.xul create mode 100644 xpfe/global/resources/content/os2/platformGlobalOverlay.xul create mode 100644 xpfe/global/resources/content/os2/platformInputBindings.xul create mode 100644 xpfe/global/resources/content/os2/platformTextAreaBindings.xul create mode 100644 xpfe/global/resources/skin/os2/Makefile.in create mode 100644 xpfe/global/resources/skin/os2/platformHTMLBindings.xml diff --git a/gfx/src/os2/nsFontMetricsOS2.cpp b/gfx/src/os2/nsFontMetricsOS2.cpp index e22970db78d..c475daca060 100644 --- a/gfx/src/os2/nsFontMetricsOS2.cpp +++ b/gfx/src/os2/nsFontMetricsOS2.cpp @@ -60,7 +60,7 @@ nsFontMetricsOS2::~nsFontMetricsOS2() NS_IMPL_ISUPPORTS( nsFontMetricsOS2, nsIFontMetrics::GetIID()) -nsresult nsFontMetricsOS2::Init( const nsFont &aFont, nsIDeviceContext *aContext) +nsresult nsFontMetricsOS2::Init( const nsFont &aFont, nsIAtom* aLangGroup, nsIDeviceContext *aContext) { mFont = new nsFont( aFont); mContext = (nsDeviceContextOS2 *) aContext; @@ -432,3 +432,14 @@ NS_IMETHODIMP nsFontMetricsOS2::GetFontHandle( nsFontHandle &aHandle) return NS_OK; } +NS_IMETHODIMP nsFontMetricsOS2::GetLangGroup(nsIAtom** aLangGroup) +{ + if (!aLangGroup) { + return NS_ERROR_NULL_POINTER; + } + + *aLangGroup = mLangGroup; + NS_IF_ADDREF(*aLangGroup); + + return NS_OK; +} diff --git a/gfx/src/os2/nsFontMetricsOS2.h b/gfx/src/os2/nsFontMetricsOS2.h index cd0b1739197..4ca262d4f2f 100644 --- a/gfx/src/os2/nsFontMetricsOS2.h +++ b/gfx/src/os2/nsFontMetricsOS2.h @@ -32,6 +32,8 @@ #include "nsIFontMetrics.h" #include "nsCRT.h" +#include "nsIAtom.h" +#include "nsCOMPtr.h" //HCT-M15 class nsIRenderingContext; class nsDeviceContextOS2; @@ -59,7 +61,7 @@ class nsFontMetricsOS2 : public nsIFontMetrics NS_DECL_ISUPPORTS - NS_IMETHOD Init( const nsFont& aFont, nsIDeviceContext *aContext); + NS_IMETHOD Init( const nsFont& aFont, nsIAtom* aLangGroup, nsIDeviceContext *aContext); NS_IMETHOD Destroy(); // Metrics @@ -75,9 +77,8 @@ class nsFontMetricsOS2 : public nsIFontMetrics NS_IMETHOD GetMaxDescent( nscoord &aDescent); NS_IMETHOD GetMaxAdvance( nscoord &aAdvance); NS_IMETHOD GetFont( const nsFont *&aFont); -// NS_IMETHOD GetLangGroup(nsIAtom** aLangGroup); + NS_IMETHOD GetLangGroup(nsIAtom** aLangGroup); NS_IMETHOD GetFontHandle( nsFontHandle &aHandle); -// NS_IMETHOD GetLangGroup(nsIAtom** aLangGroup); // for drawing text PRUint32 GetDevMaxAscender() const { return mDevMaxAscent; } @@ -105,6 +106,9 @@ class nsFontMetricsOS2 : public nsIFontMetrics nsFontHandleOS2 *mFontHandle; nsDeviceContextOS2 *mContext; // sigh.. broken broken broken XP interfaces... + + nsCOMPtr mLangGroup; + }; #endif diff --git a/intl/locale/src/os2/nsCollationOS2.cpp b/intl/locale/src/os2/nsCollationOS2.cpp index d2d05609253..97124479ff1 100644 --- a/intl/locale/src/os2/nsCollationOS2.cpp +++ b/intl/locale/src/os2/nsCollationOS2.cpp @@ -72,6 +72,10 @@ nsresult nsCollationOS2::GetSortKeyLen( const nsCollationStrength aStrength, if( !aOutLen) return NS_ERROR_NULL_POINTER; + // XXXX M15 LAUNCH HACK: TODO: track down why we get here before Initialize has been called...OS2TODO + if (!mLocaleObject) + UniCreateLocaleObject(UNI_UCS_STRING_POINTER, (UniChar*)L"", &mLocaleObject); + size_t num_elems = UniStrxfrm( mLocaleObject, nsnull, aStringIn.GetUnicode(), 0); diff --git a/intl/locale/src/os2/nsLocaleModule.cpp b/intl/locale/src/os2/nsLocaleModule.cpp index 9ca55081a37..53952eab284 100644 --- a/intl/locale/src/os2/nsLocaleModule.cpp +++ b/intl/locale/src/os2/nsLocaleModule.cpp @@ -37,7 +37,6 @@ #include "nsDateTimeFormatCID.h" #include "nsCollationCID.h" #include "nsIServiceManager.h" -#include "nsCOMPtr.h" static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID); @@ -228,7 +227,7 @@ static Components gComponents[] = { NS_IMETHODIMP nsLocaleModule::RegisterSelf(nsIComponentManager *aCompMgr, - nsIFileSpec* aPath, + nsIFile* aPath, const char* registryLocation, const char* componentType) { @@ -259,7 +258,7 @@ nsLocaleModule::RegisterSelf(nsIComponentManager *aCompMgr, NS_IMETHODIMP nsLocaleModule::UnregisterSelf(nsIComponentManager* aCompMgr, - nsIFileSpec* aPath, + nsIFile* aPath, const char* registryLocation) { #ifdef DEBUG @@ -296,7 +295,7 @@ nsLocaleModule::CanUnload(nsIComponentManager *aCompMgr, PRBool *okToUnload) static nsLocaleModule *gModule = NULL; extern "C" NS_EXPORT nsresult NSGetModule(nsIComponentManager *servMgr, - nsIFileSpec* location, + nsIFile* location, nsIModule** return_cobj) { nsresult rv = NS_OK; @@ -304,7 +303,7 @@ extern "C" NS_EXPORT nsresult NSGetModule(nsIComponentManager *servMgr, NS_ASSERTION(return_cobj, "Null argument"); NS_ASSERTION(gModule == NULL, "nsLocaleModule: Module already created."); - // Create an initialize the layout module instance + // Create and initialize the layout module instance nsLocaleModule *m = new nsLocaleModule(); if (!m) { return NS_ERROR_OUT_OF_MEMORY; diff --git a/widget/src/os2/nsMenuItem.cpp b/widget/src/os2/nsMenuItem.cpp index 7c41a50f846..2fbe575470d 100644 --- a/widget/src/os2/nsMenuItem.cpp +++ b/widget/src/os2/nsMenuItem.cpp @@ -290,10 +290,11 @@ nsresult nsMenuItem::DoCommand() // code copied from windows nsresult rv = NS_ERROR_FAILURE; +#if 0 // XXXXX FIXME no longer works due to WebShell changes nsCOMPtr contentViewer; NS_ENSURE_SUCCESS(mWebShell->GetContentViewer(getter_AddRefs(contentViewer)), NS_ERROR_FAILURE); - + nsCOMPtr docViewer; docViewer = do_QueryInterface(contentViewer); if (!docViewer) { @@ -306,7 +307,7 @@ nsresult nsMenuItem::DoCommand() NS_ERROR("Unable to retrieve the doc viewer's presentation context."); return rv; } - + nsEventStatus status = nsEventStatus_eIgnore; nsMouseEvent event; event.eventStructType = NS_MOUSE_EVENT; @@ -320,7 +321,8 @@ nsresult nsMenuItem::DoCommand() } rv = contentNode->HandleDOMEvent(presContext, &event, nsnull, NS_EVENT_FLAG_INIT, &status); - +#endif + return rv; } @@ -420,3 +422,15 @@ nsresult nsMenuItem::GetCheckboxType(PRBool *aIsCheckbox) { return NS_OK; } + +nsresult nsMenuItem::SetMenuItemType(EMenuItemType aType) +{ + mMenuType = aType; + return NS_OK; +} + +nsresult nsMenuItem::GetMenuItemType(EMenuItemType *aType) +{ + *aType = mMenuType; + return NS_OK; +} diff --git a/widget/src/os2/nsMenuItem.h b/widget/src/os2/nsMenuItem.h index c9854ad4e63..54699efe624 100644 --- a/widget/src/os2/nsMenuItem.h +++ b/widget/src/os2/nsMenuItem.h @@ -71,6 +71,8 @@ class nsMenuItem : public nsIMenuItem, public nsIMenuListener NS_IMETHOD GetShortcutChar(nsString &aText); NS_IMETHOD SetModifiers(PRUint8 aModifiers); NS_IMETHOD GetModifiers(PRUint8 * aModifiers); + NS_IMETHOD SetMenuItemType(EMenuItemType aIsCheckbox); + NS_IMETHOD GetMenuItemType(EMenuItemType *aIsCheckbox); // nsIMenuListener interface nsEventStatus MenuSelected( const nsMenuEvent &aMenuEvent); @@ -97,6 +99,7 @@ class nsMenuItem : public nsIMenuItem, public nsIMenuListener nsString mCmdString; // JS command nsIDOMElement *mDOMElement; // dom element for item nsIWebShell *mWebShell; + EMenuItemType mMenuType; }; #endif diff --git a/widget/src/os2/nsToolkit.cpp b/widget/src/os2/nsToolkit.cpp index 0cc51d94da9..9a0fa209058 100644 --- a/widget/src/os2/nsToolkit.cpp +++ b/widget/src/os2/nsToolkit.cpp @@ -26,6 +26,8 @@ #include "nsWidgetsCID.h" #include "nsIComponentManager.h" +static PRUintn gToolkitTLSIndex = 0; + // Bits to deal with the case where a new toolkit is initted with a null ---- // thread. In this case it has to create a new thread to be the PM thread. // Hopefully this will never happen! @@ -130,6 +132,10 @@ void nsToolkit::CreateInternalWindow( PRThread *aThread) 0, 0, 0); NS_ASSERTION( mDispatchWnd, "Couldn't create toolkit internal window"); + +#if DEBUG_sobotka + printf("\n+++++++++++nsToolkit created dispatch window 0x%lx\n", mDispatchWnd); +#endif } // Set up the toolkit - create window, check for thread. @@ -245,3 +251,52 @@ MRESULT EXPENTRY fnwpDispatch( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) return mRC; } + +//------------------------------------------------------------------------- +// +// Return the nsIToolkit for the current thread. If a toolkit does not +// yet exist, then one will be created... +// +//------------------------------------------------------------------------- +NS_METHOD NS_GetCurrentToolkit(nsIToolkit* *aResult) +{ + nsIToolkit* toolkit = nsnull; + nsresult rv = NS_OK; + PRStatus status; + + // Create the TLS index the first time through... + if (0 == gToolkitTLSIndex) { + status = PR_NewThreadPrivateIndex(&gToolkitTLSIndex, NULL); + if (PR_FAILURE == status) { + rv = NS_ERROR_FAILURE; + } + } + + if (NS_SUCCEEDED(rv)) { + toolkit = (nsIToolkit*)PR_GetThreadPrivate(gToolkitTLSIndex); + + // + // Create a new toolkit for this thread... + // + if (!toolkit) { + toolkit = new nsToolkit(); + + if (!toolkit) { + rv = NS_ERROR_OUT_OF_MEMORY; + } else { + NS_ADDREF(toolkit); + toolkit->Init(PR_GetCurrentThread()); + // + // The reference stored in the TLS is weak. It is removed in the + // nsToolkit destructor... + // + PR_SetThreadPrivate(gToolkitTLSIndex, (void*)toolkit); + } + } else { + NS_ADDREF(toolkit); + } + *aResult = toolkit; + } + + return rv; +} diff --git a/xpcom/io/nsLocalFileOS2.cpp b/xpcom/io/nsLocalFileOS2.cpp new file mode 100644 index 00000000000..3de58e01e7f --- /dev/null +++ b/xpcom/io/nsLocalFileOS2.cpp @@ -0,0 +1,1050 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * The contents of this file are subject to the Netscape 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/NPL/ + * + * 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 Mozilla Communicator client code, + * released March 31, 1998. + * + * The Initial Developer of the Original Code is Netscape Communications + * Corporation. Portions created by Netscape are + * Copyright (C) 1998-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * Henry Sobotka + * Implementation of nsIFile for OS/2. Freely adapted from the Win32 and + * UNIX versions, as well as the outgoing nsFileSpecOS2. + * + * This Original Code has been modified by IBM Corporation. + * Modifications made by IBM described herein are + * Copyright (c) International Business Machines + * Corporation, 2000 + * + * Modifications to Mozilla code or documentation + * identified per MPL Section 3.3 + * + * Date Modified by Description of modification + * 03/23/2000 IBM Corp. Updated original version, which was prior to nsIFile drop, to the latest + * Win/Unix versions. + */ + +#include "nsCOMPtr.h" +#include "nsIAllocator.h" +#include "nsIComponentManager.h" +#include "nsISimpleEnumerator.h" +#include "nsIFile.h" +#include "nsLocalFileOS2.h" +#include "prtypes.h" +#include "prlong.h" +#include "prmem.h" +#include "prio.h" +#include "prproces.h" +#include +#include +#include + +#ifdef XP_OS2_VACPP +#include +#define F_OK 0 +#define X_OK 1 +#define W_OK 2 +#define R_OK 4 +#define mkdir(a,b) mkdir(a) +#else +#include +#endif + + +#define VALIDATE_STAT_CACHE() \ + PR_BEGIN_MACRO \ + if (!mHaveStatCached) { \ + LoadStatCache(); \ + if (!mHaveStatCached) \ + return NSRESULT_FOR_ERRNO(); \ + } \ + PR_END_MACRO + +#define CHECK_mPath() \ + PR_BEGIN_MACRO \ + if (!mPath) \ + return NS_ERROR_NOT_INITIALIZED; \ + PR_END_MACRO + + +class nsDirEnumerator : public nsISimpleEnumerator +{ + public: + + NS_DECL_ISUPPORTS + + nsDirEnumerator() : mDir(nsnull) + { + NS_INIT_REFCNT(); + } + + nsresult Init(nsILocalFile* parent) + { + char* filepath; + parent->GetTarget(&filepath); + + if (filepath == nsnull) + { + parent->GetPath(&filepath); + } + + if (filepath == nsnull) + { + return NS_ERROR_OUT_OF_MEMORY; + } + + mDir = PR_OpenDir(filepath); + if (mDir == nsnull) // not a directory? + return NS_ERROR_FAILURE; + + nsAllocator::Free(filepath); + + mParent = parent; + return NS_OK; + } + + NS_IMETHOD HasMoreElements(PRBool *result) + { + nsresult rv; + if (mNext == nsnull && mDir) + { + PRDirEntry* entry = PR_ReadDir(mDir, PR_SKIP_BOTH); + if (entry == nsnull) + { + // end of dir entries + + PRStatus status = PR_CloseDir(mDir); + if (status != PR_SUCCESS) + return NS_ERROR_FAILURE; + mDir = nsnull; + + *result = PR_FALSE; + return NS_OK; + } + + nsCOMPtr file; + rv = mParent->Clone(getter_AddRefs(file)); + if (NS_FAILED(rv)) + return rv; + + rv = file->Append(entry->name); + if (NS_FAILED(rv)) + return rv; + + // make sure the thing exists. If it does, try the next one. + PRBool exists; + rv = file->Exists(&exists); + if (NS_FAILED(rv) || !exists) + { + return HasMoreElements(result); + } + + mNext = do_QueryInterface(file); + } + *result = mNext != nsnull; + return NS_OK; + } + + NS_IMETHOD GetNext(nsISupports **result) + { + nsresult rv; + PRBool hasMore; + rv = HasMoreElements(&hasMore); + if (NS_FAILED(rv)) return rv; + + *result = mNext; // might return nsnull + NS_IF_ADDREF(*result); + + mNext = null_nsCOMPtr(); + return NS_OK; + } + + virtual ~nsDirEnumerator() + { + if (mDir) + { + PRStatus status = PR_CloseDir(mDir); + NS_ASSERTION(status == PR_SUCCESS, "close failed"); + } + } + + protected: + PRDir* mDir; + nsCOMPtr mParent; + nsCOMPtr mNext; +}; + +NS_IMPL_ISUPPORTS(nsDirEnumerator, NS_GET_IID(nsISimpleEnumerator)); + + +// ctor & dtor +// =========== +nsLocalFile::nsLocalFile() : + mHaveStatCached(PR_FALSE) +{ + mPath = ""; + NS_INIT_REFCNT(); +} + +nsLocalFile::~nsLocalFile() +{ +} + + +// nsISupports interface implementation +// ==================================== +NS_IMPL_THREADSAFE_ISUPPORTS2(nsLocalFile, nsILocalFile, nsIFile) + +NS_METHOD +nsLocalFile::nsLocalFileConstructor(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr) +{ + NS_ENSURE_ARG_POINTER(aInstancePtr); + NS_ENSURE_NO_AGGREGATION(outer); + + nsLocalFile* inst = new nsLocalFile(); + if (inst == NULL) + return NS_ERROR_OUT_OF_MEMORY; + + nsresult rv = inst->QueryInterface(aIID, aInstancePtr); + if (NS_FAILED(rv)) + { + delete inst; + return rv; + } + return NS_OK; +} + +// Interface methods implementation +// ================================ +NS_IMETHODIMP +nsLocalFile::Clone(nsIFile **file) +{ + nsresult rv; + char * aFilePath; + GetPath(&aFilePath); + + nsCOMPtr localFile; + + rv = NS_NewLocalFile(aFilePath, getter_AddRefs(localFile)); + nsAllocator::Free(aFilePath); + + if (NS_SUCCEEDED(rv) && localFile) + { + return localFile->QueryInterface(NS_GET_IID(nsIFile), (void**)file); + } + + return rv; +} + +NS_IMETHODIMP +nsLocalFile::InitWithPath(const char *filePath) +{ + SetNoStatCache(); + NS_ENSURE_ARG(filePath); + nsresult rv = NS_OK; + char* pathString = nsnull; + char* nativeFilePath = nsnull; + + // Do a sanity check. if it has any forward slashes, it is not a Native path + // Also, it can only have a colon at the first char. + + if ( ( (filePath[0] != 0) && (filePath[1] == ':') && (strchr(filePath, '/') == 0) ) || + ( (filePath[0] == '\\') && (filePath[1] == '\\') ) ) // netwerk path + { + // This is a native path + if(filePath[1] == ':') + { + rv = CheckDrive(filePath); + if (NS_FAILED(rv)) + return NS_ERROR_FILE_INVALID_PATH; + } + nativeFilePath = (char*) nsAllocator::Clone( filePath, strlen(filePath)+1 ); + } + + if (nativeFilePath == nsnull) + return NS_ERROR_FILE_UNRECOGNIZED_PATH; + + // kill any trailing seperator + char* temp = nativeFilePath; + int len = strlen(temp) - 1; + if(temp[len] == '\\') + temp[len] = '\0'; + + mPath.SetString(nativeFilePath); + nsAllocator::Free( nativeFilePath ); + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::OpenNSPRFileDesc(PRInt32 flags, PRInt32 mode, PRFileDesc **_retval) +{ + CHECK_mPath(); + + *_retval = PR_Open(mPath, flags, mode); + + if (*_retval) + return NS_OK; + else + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsLocalFile::OpenANSIFileDesc(const char *mode, FILE * *_retval) +{ + CHECK_mPath(); + + *_retval = fopen(mPath, mode); + + if (*_retval) + return NS_OK; + + return NS_ERROR_FAILURE; +} + +NS_IMETHODIMP +nsLocalFile::Create(PRUint32 type, PRUint32 attributes) +{ + CHECK_mPath(); + + // Return if file exists + if (access(mPath, F_OK) == 0) + return NS_ERROR_FILE_ALREADY_EXISTS; + + // Check type + if (type != NORMAL_FILE_TYPE && type != DIRECTORY_TYPE) + return NS_ERROR_FILE_UNKNOWN_TYPE; + + char* segment = (char*)PR_Malloc(strlen(mPath)); + char* tail = strchr(mPath, '\\'); + char* leaf = strrchr(mPath, '\\'); + size_t len = strlen(mPath); + +#if DEBUG_sobotka + printf("In nsLocalFile::Create: mPath = %s\n", mPath); + printf("tail = %s\n", tail); + printf("leaf = %s\n", leaf); +#endif + + // Walk path if not a leaf + if (stricmp(tail, leaf) || tail != nsnull) { + + // Absolute path + if (mPath[2] == '\\' && mPath[1] == ':') { + ++tail; + tail = strchr(tail, '\\'); + } + + // LAN path + if (mPath[0] == '\\' && mPath[1] == '\\') { + tail += 2; + tail = strchr(tail, '\\'); + } + + if (tail != NULL) { + size_t idx = len - strlen(tail); + + while (stricmp(segment, mPath)) { + memcpy(segment, mPath, idx); + if (access(segment, F_OK) != 0) + mkdir(segment, 0); + + ++tail; + tail = strchr(tail, '\\'); + + if (tail == NULL) + break; + else + idx = len - strlen(tail); + } + } + } + + // Now just create the directory or file + int ret; + if (type == DIRECTORY_TYPE) { + ret = mkdir(mPath, attributes); + if (!ret) + return NS_OK; + else + return NSRESULT_FOR_RETURN(ret); + } + else { + ret = creat(mPath, attributes); + if (ret != -1) { + close(ret); + return NS_OK; + } + else + return NSRESULT_FOR_RETURN(ret); + } +} + +NS_IMETHODIMP +nsLocalFile::Append(const char *node) +{ + if ( (node == nsnull) || + (*node == '/') || + (strstr(node, "..") != nsnull) || + (strchr(node, '\\') != nsnull) || + (strchr(node, '/') != nsnull) ) + { + return NS_ERROR_FILE_UNRECOGNIZED_PATH; + } + + mPath.Append("\\"); + mPath.Append(node); + return NS_OK; +#if 0 + NS_ENSURE_ARG(fragment); + CHECK_mPath(); + char * newPath = (char *)nsAllocator::Alloc(strlen(mPath) + + strlen(fragment) + 2); + if (!newPath) + return NS_ERROR_OUT_OF_MEMORY; + strcpy(newPath, mPath); + strcat(newPath, "\\"); + + // flip slashes + char *c; + char *temp = (char *)nsAllocator::Alloc(strlen(fragment) + 1); + strcpy(temp, fragment); + for(c = temp; *c; c++) + if( *c == '/') *c = '\\'; + + strcat(newPath, temp); + mPath = newPath; + nsAllocator::Free(newPath); + return NS_OK; +#endif +} + +NS_IMETHODIMP +nsLocalFile::Normalize() +{ + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::GetLeafName(char **aLeafName) +{ + NS_ENSURE_ARG_POINTER(aLeafName); + + const char* temp = mPath.GetBuffer(); + if(temp == nsnull) + return NS_ERROR_FILE_UNRECOGNIZED_PATH; + + const char* leaf = strrchr(temp, '\\'); + + // if mPath is just a node without any slashes. + if (leaf == nsnull) + leaf = temp; + else + leaf++; + + *aLeafName = (char*)nsAllocator::Clone(leaf, strlen(leaf) + 1); + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::SetLeafName(const char * aLeafName) +{ + const char* temp = mPath.GetBuffer(); + if(temp == nsnull) + return NS_ERROR_FILE_UNRECOGNIZED_PATH; + + const char* leaf = strrchr(temp, '\\'); + + PRInt32 offset = mPath.RFindChar('\\'); + if (offset) + { + mPath.Truncate(offset+1); + } + mPath.Append(aLeafName); + + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::GetPath(char **_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + *_retval = (char*)nsAllocator::Clone(mPath, strlen(mPath) + 1); + return NS_OK; +} + +nsresult +nsLocalFile::CopyMove(nsIFile *newParentDir, const char *newName, PRBool move) +{ + CHECK_mPath(); + NS_ENSURE_ARG(newParentDir); + + int rv; + PRBool exists; + newParentDir->Exists(&exists); + if (exists == PR_FALSE) { + rv = newParentDir->Create(DIRECTORY_TYPE, S_IREAD | S_IWRITE); + if (NS_FAILED(rv)) + return rv; + } + + nsCString newPath; + newParentDir->GetPath((char**)&newPath); + if (newPath[strlen(newPath - 1)] != '\\') + newPath.Append("\\"); + newPath.Append(newName); + + rv = DosCopy((PSZ)mPath, (PSZ)newPath, DCPY_EXISTING); + if (NS_FAILED(rv)) + return rv; + + if(move) { + rv = remove(mPath); + if (NS_FAILED(rv)) + return rv; + } + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::CopyTo(nsIFile *newParentDir, const char *newName) +{ + return CopyMove(newParentDir, newName, PR_FALSE); +} + +NS_IMETHODIMP +nsLocalFile::CopyToFollowingLinks(nsIFile *newParentDir, const char *newName) +{ + return CopyMove(newParentDir, newName, PR_FALSE); +} + +NS_IMETHODIMP +nsLocalFile::MoveTo(nsIFile *newParentDir, const char *newName) +{ + return CopyMove(newParentDir, newName, PR_TRUE); +} + +NS_IMETHODIMP +nsLocalFile::Spawn(const char **args, PRUint32 count) +{ + PRBool isFile; + nsresult rv = IsFile(&isFile); + + if (NS_FAILED(rv)) + return rv; + + // make sure that when we allocate we have 1 greater than the + // count since we need to null terminate the list for the argv to + // pass into PR_CreateProcessDetached + char **my_argv = NULL; + + my_argv = (char **)malloc(sizeof(char *) * (count + 2) ); + if (!my_argv) { + return NS_ERROR_OUT_OF_MEMORY; + } + + // copy the args + PRUint32 i; + for (i=0; i < count; i++) { + my_argv[i+1] = (char *)args[i]; + } + // we need to set argv[0] to the program name. + my_argv[0] = mPath; + + // null terminate the array + my_argv[count+1] = NULL; + rv = PR_CreateProcessDetached(mPath, my_argv, NULL, NULL); + + // free up our argv + nsAllocator::Free(my_argv); + + if (PR_SUCCESS == rv) + return NS_OK; + else + return NS_ERROR_FILE_EXECUTION_FAILED; +} + +NS_IMETHODIMP +nsLocalFile::Load(PRLibrary **_retval) +{ + PRBool isFile; + nsresult rv = IsFile(&isFile); + + if (NS_FAILED(rv)) + return rv; + + if (! isFile) + return NS_ERROR_FILE_IS_DIRECTORY; + + *_retval = PR_LoadLibrary(mPath); + + if (*_retval) + return NS_OK; + else + return NS_ERROR_NULL_POINTER; +} + + +NS_IMETHODIMP +nsLocalFile::Delete(PRBool recursive) +{ + PRBool isDir; + + nsresult rv = IsDirectory(&isDir); + if (NS_FAILED(rv)) + return rv; + + const char *filePath = mPath.GetBuffer(); + + if (isDir) + { + if (recursive) + { + nsDirEnumerator* dirEnum = new nsDirEnumerator(); + if (dirEnum) + return NS_ERROR_OUT_OF_MEMORY; + + rv = dirEnum->Init(this); + + nsCOMPtr iterator = do_QueryInterface(dirEnum); + + PRBool more; + iterator->HasMoreElements(&more); + while (more) + { + nsCOMPtr item; + nsCOMPtr file; + iterator->GetNext(getter_AddRefs(item)); + file = do_QueryInterface(item); + + file->Delete(recursive); + + iterator->HasMoreElements(&more); + } + } + rmdir(filePath); // todo: save return value? + } + else + { + remove(filePath); // todo: save return value? + } + + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::GetLastModificationDate(PRInt64 *aLastModificationDate) +{ + NS_ENSURE_ARG_POINTER(aLastModificationDate); + CHECK_mPath(); + LL_UI2L(*aLastModificationDate, (PRUint32)mStatCache.st_mtime); + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::SetLastModificationDate(PRInt64 aLastModificationDate) +{ + NS_ENSURE_ARG(aLastModificationDate); + int result; + if (aLastModificationDate) { + VALIDATE_STAT_CACHE(); + struct utimbuf ut; + ut.actime = mStatCache.st_atime; + LL_L2UI(ut.modtime, aLastModificationDate); + result = utime((const char*)mPath, &ut); + } else { + result = utime((const char*)mPath, NULL); + } + SetNoStatCache(); + return NSRESULT_FOR_RETURN(result); +} + +NS_IMETHODIMP +nsLocalFile::GetLastModificationDateOfLink(PRInt64 *aLastModificationDate) +{ + return (GetLastModificationDate(aLastModificationDate)); +} + +NS_IMETHODIMP +nsLocalFile::SetLastModificationDateOfLink(PRInt64 aLastModificationDate) +{ + return (SetLastModificationDate(aLastModificationDate)); +} + +/* Permission flags for st_mode; emx's already defines them. + * Though these permissions are meaningless on OS/2, in a network context + * a file can end up a system where these bits do serve a purpose. Since + * setting and getting is easy, might as well provide the facility. + */ +#ifdef XP_OS2_VACPP +#define S_IRWXU 00700 +#define S_IRWXG 00070 +#define S_IRWXO 00007 +#endif + +#define NORMALIZE_PERMS(mode) ((mode)& (S_IRWXU | S_IRWXG | S_IRWXO)) + +NS_IMETHODIMP +nsLocalFile::GetPermissions(PRUint32 *aPermissions) +{ + NS_ENSURE_ARG_POINTER(aPermissions); + VALIDATE_STAT_CACHE(); + *aPermissions = NORMALIZE_PERMS(mStatCache.st_mode); + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::GetPermissionsOfLink(PRUint32 *aPermissionsOfLink) +{ + return (GetPermissions(aPermissionsOfLink)); +} + + +NS_IMETHODIMP +nsLocalFile::SetPermissions(PRUint32 aPermissions) +{ + NS_ENSURE_ARG(aPermissions); + SetNoStatCache(); + return NSRESULT_FOR_RETURN(chmod(mPath, aPermissions)); +} + +NS_IMETHODIMP +nsLocalFile::SetPermissionsOfLink(PRUint32 aPermissions) +{ + return (SetPermissions(aPermissions)); +} + +NS_IMETHODIMP +nsLocalFile::GetFileSize(PRInt64 *aFileSize) +{ + NS_ENSURE_ARG_POINTER(aFileSize); + VALIDATE_STAT_CACHE(); + *aFileSize = (PRUint32)mStatCache.st_size; + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::GetFileSizeOfLink(PRInt64 *aFileSize) +{ + NS_ENSURE_ARG_POINTER(aFileSize); + return (GetFileSize(aFileSize)); +} + +NS_IMETHODIMP +nsLocalFile::SetFileSize(PRInt64 aFileSize) +{ + NS_ENSURE_ARG_POINTER(aFileSize); + CHECK_mPath(); + + int fh = open(mPath, O_RDWR); + if (fh == -1) + return NSRESULT_FOR_ERRNO(); + + PRInt32 newSize; + LL_L2I(newSize, aFileSize); + + nsresult rv = chsize(fh, newSize); + if (NS_FAILED(rv)) + return rv; + else + close(fh); + + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::GetDiskSpaceAvailable(PRInt64 *aDiskSpaceAvailable) +{ + NS_ENSURE_ARG_POINTER(aDiskSpaceAvailable); + CHECK_mPath(); + + ULONG ulDriveNo = toupper(mPath[0]) + 1 - 'A'; + FSALLOCATE fsAllocate = { 0 }; + APIRET rv = DosQueryFSInfo(ulDriveNo, FSIL_ALLOC, + &fsAllocate, sizeof(fsAllocate)); + + if (NS_FAILED(rv)) + return rv; + else + *aDiskSpaceAvailable = (PRInt64)(fsAllocate.cUnitAvail * + fsAllocate.cSectorUnit * + fsAllocate.cbSector); + + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::GetParent(nsIFile * *aParent) +{ + NS_ENSURE_ARG_POINTER(aParent); + + nsCString parentPath = mPath; + + PRInt32 offset = parentPath.RFindChar('\\'); + if (offset == -1) + return NS_ERROR_FILE_UNRECOGNIZED_PATH; + + parentPath.Truncate(offset); + + nsCOMPtr localFile; + nsresult rv = NS_NewLocalFile(parentPath.GetBuffer(), getter_AddRefs(localFile)); + + if(NS_SUCCEEDED(rv) && localFile) + { + return localFile->QueryInterface(NS_GET_IID(nsIFile), (void**)aParent); + } + return rv; +} + +NS_IMETHODIMP +nsLocalFile::Exists(PRBool *_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + PRBool accessOK; + *_retval = accessOK = (access(mPath, F_OK) == 0); + return NS_OK; + } + +NS_IMETHODIMP +nsLocalFile::IsWritable(PRBool *_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + PRBool accessOK; + *_retval = accessOK = (access(mPath, W_OK) == 0); + if (accessOK || errno == EACCES) + return NS_OK; + return NSRESULT_FOR_ERRNO(); + } + +NS_IMETHODIMP +nsLocalFile::IsReadable(PRBool *_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + PRBool accessOK; + *_retval = accessOK = (access(mPath, R_OK) == 0); + if (accessOK || errno == EACCES) + return NS_OK; + return NSRESULT_FOR_ERRNO(); +} + +NS_IMETHODIMP +nsLocalFile::IsExecutable(PRBool *_retval) +{ + NS_ENSURE_ARG(_retval); + CHECK_mPath(); + + char *ext = strrchr(mPath, '.'); + + if (!(stricmp(ext, ".exe")) || + !(stricmp(ext, ".cmd")) || + !(stricmp(ext, ".com")) || + !(stricmp(ext, ".bat"))) + *_retval = PR_TRUE; + else + *_retval = PR_FALSE; + + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::IsDirectory(PRBool *_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + VALIDATE_STAT_CACHE(); + *_retval = S_ISDIR(mStatCache.st_mode); + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::IsFile(PRBool *_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + VALIDATE_STAT_CACHE(); + *_retval = S_ISREG(mStatCache.st_mode); + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::IsHidden(PRBool *_retval) +{ + CHECK_mPath(); + NS_ENSURE_ARG(_retval); + + HFILE fh = 0; + ULONG openAct = 0; + FILESTATUS3 fs3 = {{0}}; + + APIRET rv = DosOpen((PSZ)mPath, &fh, &openAct, 0L, 0L, + OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS, + OPEN_FLAGS_NOINHERIT | OPEN_ACCESS_READONLY | OPEN_SHARE_DENYWRITE, + 0L); + if (NS_FAILED(rv)) + return rv; + else + rv = DosQueryPathInfo(mPath, FIL_STANDARD, &fs3, sizeof(fs3)); + + if (NS_FAILED(rv)) + return rv; + else + *_retval = fs3.attrFile & FILE_HIDDEN ? PR_TRUE : PR_FALSE; + + rv = DosClose(fh); + + if (NS_FAILED(rv)) + return rv; + else + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::IsSymlink(PRBool *_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + *_retval = PR_FALSE; // No symlinks on OS/2 + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::IsSpecial(PRBool *_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + VALIDATE_STAT_CACHE(); + *_retval = !(S_ISREG(mStatCache.st_mode) || S_ISDIR(mStatCache.st_mode)); + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::Equals(nsIFile *inFile, PRBool *_retval) +{ + NS_ENSURE_ARG_POINTER(inFile); + NS_ENSURE_ARG_POINTER(_retval); + *_retval = PR_FALSE; + + char* inFilePath; + inFile->GetPath(&inFilePath); + + char* filePath; + GetPath(&filePath); + + if (strcmp(inFilePath, filePath) == 0) + *_retval = PR_TRUE; + + nsAllocator::Free(inFilePath); + nsAllocator::Free(filePath); + + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::Contains(nsIFile *inFile, PRBool recur, PRBool *_retval) +{ + *_retval = PR_FALSE; + + char* myFilePath; + if ( NS_FAILED(GetTarget(&myFilePath))) + GetPath(&myFilePath); + + PRInt32 myFilePathLen = strlen(myFilePath); + + char* inFilePath; + if ( NS_FAILED(inFile->GetTarget(&inFilePath))) + inFile->GetPath(&inFilePath); + + if ( strncmp( myFilePath, inFilePath, myFilePathLen) == 0) + { + // now make sure that the |inFile|'s path has a trailing + // separator. + + if (inFilePath[myFilePathLen] == '\\') + { + *_retval = PR_TRUE; + } + + } + + nsAllocator::Free(inFilePath); + nsAllocator::Free(myFilePath); + + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::GetTarget(char **_retval) +{ + NS_ENSURE_ARG_POINTER(_retval); + VALIDATE_STAT_CACHE(); + *_retval = (char*)nsAllocator::Clone(mPath, strlen(mPath) + 1); + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::GetDirectoryEntries(nsISimpleEnumerator **entries) +{ + NS_ENSURE_ARG_POINTER(entries); + PRBool isDir; + + nsresult rv = IsDirectory(&isDir); + if (NS_FAILED(rv)) + return rv; + if (!isDir) + return NS_ERROR_FILE_NOT_DIRECTORY; + + nsDirEnumerator* dirEnum = new nsDirEnumerator(); + if (dirEnum == nsnull) + return NS_ERROR_OUT_OF_MEMORY; + + NS_ADDREF(dirEnum); + rv = dirEnum->Init(this); + if (NS_FAILED(rv)) { + NS_RELEASE(dirEnum); + return rv; + } + + *entries = dirEnum; + return NS_OK; +} + +nsresult +NS_NewLocalFile(const char* path, nsILocalFile* *result) +{ + nsLocalFile* file = new nsLocalFile(); + if (file == nsnull) + return NS_ERROR_OUT_OF_MEMORY; + NS_ADDREF(file); + + nsresult rv = file->InitWithPath(path); + if (NS_FAILED(rv)) { + NS_RELEASE(file); + return rv; + } + *result = file; + return NS_OK; +} + +NS_IMETHODIMP +nsLocalFile::CheckDrive(const char* inPath) { + + ULONG ulDriveNo = 0; + ULONG ulDriveMap = 0; + APIRET rv = DosQueryCurrentDisk(&ulDriveNo, &ulDriveMap); + if (NS_FAILED(rv)) + return NS_ERROR_FAILURE; + + // See if specified drive exists + ulDriveNo = toupper(inPath[0]) + 1 - 'A'; + if (!((ulDriveMap << (31 - ulDriveNo)) >> 31)) + return NS_ERROR_FILE_INVALID_PATH; + + return NS_OK; +} diff --git a/xpcom/io/nsLocalFileOS2.h b/xpcom/io/nsLocalFileOS2.h new file mode 100644 index 00000000000..083561782ce --- /dev/null +++ b/xpcom/io/nsLocalFileOS2.h @@ -0,0 +1,127 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * The contents of this file are subject to the Netscape 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/NPL/ + * + * 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 Mozilla Communicator client code, + * released March 31, 1998. + * + * The Initial Developer of the Original Code is Netscape Communications + * Corporation. Portions created by Netscape are + * Copyright (C) 1998-2000 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * Henry Sobotka + */ + +#ifndef _nsLocalFileOS2_H_ +#define _nsLocalFileOS2_H_ + +#include "nscore.h" +#include "nsError.h" +#include "nsString.h" +#include "nsCRT.h" +#include "nsIFile.h" +#include "nsILocalFile.h" +#include "nsIFactory.h" +#include "nsLocalFile.h" + +#define INCL_DOSFILEMGR +#define INCL_DOSERRORS +#define INCL_DOSPROCESS +#define INCL_DOSMODULEMGR +#include + +#include +#include +#include +#include +#include +#include +#include + +#define NSRESULT_FOR_RETURN(ret) (!(ret) ? NS_OK : NSRESULT_FOR_ERRNO()) + +inline nsresult +nsresultForErrno(int err) +{ +#ifdef DEBUG + if (err) + fprintf(stderr, "errno %d\n", err); +#endif + switch(err) { + case 0: + return NS_OK; + case ENOENT: + return NS_ERROR_FILE_TARGET_DOES_NOT_EXIST; + case ENOTDIR: + return NS_ERROR_FILE_DESTINATION_NOT_DIR; + case EEXIST: + return NS_ERROR_FILE_ALREADY_EXISTS; + case EACCES: + default: + return NS_ERROR_FAILURE; + } +} + +#define NSRESULT_FOR_ERRNO() nsresultForErrno(errno) + +class NS_COM nsLocalFile : public nsILocalFile +{ +public: + NS_DEFINE_STATIC_CID_ACCESSOR(NS_LOCAL_FILE_CID) + + nsLocalFile(); + virtual ~nsLocalFile(); + + static NS_METHOD nsLocalFileConstructor(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr); + + // nsISupports interface + NS_DECL_ISUPPORTS + + // nsIFile interface + NS_DECL_NSIFILE + + // nsILocalFile interface + NS_DECL_NSILOCALFILE + +private: + + // String guaranteed to be native path + nsCString mPath; + nsresult CheckDrive(const char* inPath); + + // Filehandling method + nsresult CopyMove(nsIFile *newParentDir, const char *newName, PRBool move); + + // stat caching members and inline methods + PRBool mHaveStatCached; + struct stat mStatCache; + + void SetNoStatCache() { mHaveStatCached = PR_FALSE; } + + nsresult LoadStatCache() { + if (stat((const char*)mPath, &mStatCache) == -1) { +#ifdef DEBUG + fprintf(stderr, "stat(%s) failed; errno: %d\n", (const char *)mPath, errno); +#endif + return NS_ERROR_FAILURE; + } + mHaveStatCached = PR_TRUE; + return NS_OK; + } + + // Check path for system-reserved chars (inPath = whatever follows drive colon, if any) + PRBool ValidatePath(const char* inPath) { + return ((strpbrk(inPath, "<>:\"|") == NULL) ? PR_TRUE : PR_FALSE); + } +}; +#endif // _nsLocalFileOS2_H_ diff --git a/xpfe/global/resources/content/os2/Makefile.in b/xpfe/global/resources/content/os2/Makefile.in new file mode 100644 index 00000000000..c778b498444 --- /dev/null +++ b/xpfe/global/resources/content/os2/Makefile.in @@ -0,0 +1,43 @@ +# +# The contents of this file are subject to the Netscape 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/NPL/ +# +# 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 mozilla.org code. +# +# The Initial Developer of the Original Code is Netscape +# Communications Corporation. Portions created by Netscape are +# Copyright (C) 1998 Netscape Communications Corporation. All +# Rights Reserved. +# +# Contributor(s): +# + +DEPTH = ../../../../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +include $(DEPTH)/config/autoconf.mk + +EXPORT_RESOURCE_CONTENT = \ + $(srcdir)/platformGlobalOverlay.xul \ + $(srcdir)/platformDialogOverlay.xul \ + $(srcdir)/platformInputBindings.xul \ + $(srcdir)/platformBrowserBindings.xul \ + $(srcdir)/platformInputBindings.xul \ + $(srcdir)/platformEditorBindings.xul \ + $(srcdir)/platformTextAreaBindings.xul \ + $(NULL) + +include $(topsrcdir)/config/rules.mk + +install:: + $(INSTALL) $(EXPORT_RESOURCE_CONTENT) $(DIST)/bin/chrome/global/content/default + diff --git a/xpfe/global/resources/content/os2/platformBrowserBindings.xul b/xpfe/global/resources/content/os2/platformBrowserBindings.xul new file mode 100644 index 00000000000..98dc8ac3fc8 --- /dev/null +++ b/xpfe/global/resources/content/os2/platformBrowserBindings.xul @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + diff --git a/xpfe/global/resources/content/os2/platformDialogOverlay.xul b/xpfe/global/resources/content/os2/platformDialogOverlay.xul new file mode 100644 index 00000000000..0cc2647d3ff --- /dev/null +++ b/xpfe/global/resources/content/os2/platformDialogOverlay.xul @@ -0,0 +1,27 @@ + + + + + + + + + + + +