This commit was manufactured by cvs2svn to create tag 'MANIFEST'.

git-svn-id: svn://10.0.0.236/tags/MANIFEST@3327 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/LEGAL

@@ -1,37 +0,0 @@
-Please be apprised of the following Legal Notices:
-
-A) Wang contends that its U.S. Patent No. 4, 751,669 ("the '669
-Patent") disclosing a "video text" system, is infringed by the following
-functionality in the Netscape Navigator code: 1) the animated logo and
-status line indicators --See Claims 1,8 and 9; 2)  the "File Save As"
-function --See Claims 23-27; 3) Bookmarks and Rename Bookmarks in the
-Properties window --See Claims 20-22; 4) storing HTML, GIF, and JPEG
-files and adding filename extensions based on mime types (performed in
-Windows OS) --See Claim 38.  Netscape believes the '669 Patent is
-invalid and non-infringed. Netscape is vigorously defending against
-Wang's claims.
-
-B)   Intermind owns pending U.S. patent applications on communications
-systems which employ metadata ("channel objects") to define a control
-structure for information transfer.  The Netscape code does not infringe
-as released; however, modifications which utilize channel objects as
-described by Intermind should be considered carefully. The following is
-a statement from Intermind:  "Intermind's claims fundamentally involve
-the use of a control structure to automate communications. ...The
-essence of Intermind's top claim is that two devices sender and
-receiver have persistent storage, communicate over a network,
-and exchange a control structure including metadata which describes: 1)
-what information is to be updated, 2) when to update this information,
-and 3) how to transfer the updated information. In addition, at  least
-the receiving device must be able to process the metadata in order to
-perform the update determination and transfer. Any digital
-communications system which incorporates all of these elements will be
-covered by Intermind's patents."  See Intermind.com.
-
-C) Stac, Inc., and its licensing agent Hi/fn, own several patents which
-disclose data compression methods implementing an LZS compression
-algorithm, including U.S. Patent Nos.  4,701,745 and 5,016, 009 ("the
-Stac Patents").  The Netscape Communicator code  does not perform
-compression. If you modify the Netscape source code to perform
-compression, please take notice of the Stac Patents.
-

mozilla/LICENSE

@@ -1,421 +0,0 @@
-                           NETSCAPE PUBLIC LICENSE
-                                Version 1.0
-
-                              ----------------
-
-1. Definitions.
-
-     1.1. ``Contributor'' means each entity that creates or contributes to
-     the creation of Modifications.
-
-     1.2. ``Contributor Version'' means the combination of the Original
-     Code, prior Modifications used by a Contributor, and the Modifications
-     made by that particular Contributor.
-
-     1.3. ``Covered Code'' means the Original Code or Modifications or the
-     combination of the Original Code and Modifications, in each case
-     including portions thereof.
-
-     1.4. ``Electronic Distribution Mechanism'' means a mechanism generally
-     accepted in the software development community for the electronic
-     transfer of data.
-
-     1.5. ``Executable'' means Covered Code in any form other than Source
-     Code.
-
-     1.6. ``Initial Developer'' means the individual or entity identified as
-     the Initial Developer in the Source Code notice required by Exhibit A.
-
-     1.7. ``Larger Work'' means a work which combines Covered Code or
-     portions thereof with code not governed by the terms of this License.
-
-     1.8. ``License'' means this document.
-
-     1.9. ``Modifications'' means any addition to or deletion from the
-     substance or structure of either the Original Code or any previous
-     Modifications. When Covered Code is released as a series of files, a
-     Modification is:
-
-          A. Any addition to or deletion from the contents of a file
-          containing Original Code or previous Modifications.
-
-          B. Any new file that contains any part of the Original Code or
-          previous Modifications.
-
-     1.10. ``Original Code'' means Source Code of computer software code
-     which is described in the Source Code notice required by Exhibit A as
-     Original Code, and which, at the time of its release under this License
-     is not already Covered Code governed by this License.
-
-     1.11. ``Source Code'' means the preferred form of the Covered Code for
-     making modifications to it, including all modules it contains, plus any
-     associated interface definition files, scripts used to control
-     compilation and installation of an Executable, or a list of source code
-     differential comparisons against either the Original Code or another
-     well known, available Covered Code of the Contributor's choice. The
-     Source Code can be in a compressed or archival form, provided the
-     appropriate decompression or de-archiving software is widely available
-     for no charge.
-
-     1.12. ``You'' means an individual or a legal entity exercising rights
-     under, and complying with all of the terms of, this License or a future
-     version of this License issued under Section 6.1. For legal entities,
-     ``You'' includes any entity which controls, is controlled by, or is
-     under common control with You. For purposes of this definition,
-     ``control'' means (a) the power, direct or indirect, to cause the
-     direction or management of such entity, whether by contract or
-     otherwise, or (b) ownership of fifty percent (50%) or more of the
-     outstanding shares or beneficial ownership of such entity.
-
-2. Source Code License.
-
-     2.1. The Initial Developer Grant.
-     The Initial Developer hereby grants You a world-wide, royalty-free,
-     non-exclusive license, subject to third party intellectual property
-     claims:
-
-          (a) to use, reproduce, modify, display, perform, sublicense and
-          distribute the Original Code (or portions thereof) with or without
-          Modifications, or as part of a Larger Work; and
-
-          (b) under patents now or hereafter owned or controlled by Initial
-          Developer, to make, have made, use and sell (``Utilize'') the
-          Original Code (or portions thereof), but solely to the extent that
-          any such patent is reasonably necessary to enable You to Utilize
-          the Original Code (or portions thereof) and not to any greater
-          extent that may be necessary to Utilize further Modifications or
-          combinations.
-
-     2.2. Contributor Grant.
-     Each Contributor hereby grants You a world-wide, royalty-free,
-     non-exclusive license, subject to third party intellectual property
-     claims:
-
-          (a) to use, reproduce, modify, display, perform, sublicense and
-          distribute the Modifications created by such Contributor (or
-          portions thereof) either on an unmodified basis, with other
-          Modifications, as Covered Code or as part of a Larger Work; and
-
-          (b) under patents now or hereafter owned or controlled by
-          Contributor, to Utilize the Contributor Version (or portions
-          thereof), but solely to the extent that any such patent is
-          reasonably necessary to enable You to Utilize the Contributor
-          Version (or portions thereof), and not to any greater extent that
-          may be necessary to Utilize further Modifications or combinations.
-
-3. Distribution Obligations.
-
-     3.1. Application of License.
-     The Modifications which You create or to which You contribute are
-     governed by the terms of this License, including without limitation
-     Section 2.2. The Source Code version of Covered Code may be distributed
-     only under the terms of this License or a future version of this
-     License released under Section 6.1, and You must include a copy of this
-     License with every copy of the Source Code You distribute. You may not
-     offer or impose any terms on any Source Code version that alters or
-     restricts the applicable version of this License or the recipients'
-     rights hereunder. However, You may include an additional document
-     offering the additional rights described in Section 3.5.
-
-     3.2. Availability of Source Code.
-     Any Modification which You create or to which You contribute must be
-     made available in Source Code form under the terms of this License
-     either on the same media as an Executable version or via an accepted
-     Electronic Distribution Mechanism to anyone to whom you made an
-     Executable version available; and if made available via Electronic
-     Distribution Mechanism, must remain available for at least twelve (12)
-     months after the date it initially became available, or at least six
-     (6) months after a subsequent version of that particular Modification
-     has been made available to such recipients. You are responsible for
-     ensuring that the Source Code version remains available even if the
-     Electronic Distribution Mechanism is maintained by a third party.
-
-     3.3. Description of Modifications.
-     You must cause all Covered Code to which you contribute to contain a
-     file documenting the changes You made to create that Covered Code and
-     the date of any change. You must include a prominent statement that the
-     Modification is derived, directly or indirectly, from Original Code
-     provided by the Initial Developer and including the name of the Initial
-     Developer in (a) the Source Code, and (b) in any notice in an
-     Executable version or related documentation in which You describe the
-     origin or ownership of the Covered Code.
-
-     3.4. Intellectual Property Matters
-
-          (a) Third Party Claims.
-          If You have knowledge that a party claims an intellectual property
-          right in particular functionality or code (or its utilization
-          under this License), you must include a text file with the source
-          code distribution titled ``LEGAL'' which describes the claim and
-          the party making the claim in sufficient detail that a recipient
-          will know whom to contact. If you obtain such knowledge after You
-          make Your Modification available as described in Section 3.2, You
-          shall promptly modify the LEGAL file in all copies You make
-          available thereafter and shall take other steps (such as notifying
-          appropriate mailing lists or newsgroups) reasonably calculated to
-          inform those who received the Covered Code that new knowledge has
-          been obtained.
-
-          (b) Contributor APIs.
-          If Your Modification is an application programming interface and
-          You own or control patents which are reasonably necessary to
-          implement that API, you must also include this information in the
-          LEGAL file.
-
-     3.5. Required Notices.
-     You must duplicate the notice in Exhibit A in each file of the Source
-     Code, and this License in any documentation for the Source Code, where
-     You describe recipients' rights relating to Covered Code. If You
-     created one or more Modification(s), You may add your name as a
-     Contributor to the notice described in Exhibit A. If it is not possible
-     to put such notice in a particular Source Code file due to its
-     structure, then you must include such notice in a location (such as a
-     relevant directory file) where a user would be likely to look for such
-     a notice. You may choose to offer, and to charge a fee for, warranty,
-     support, indemnity or liability obligations to one or more recipients
-     of Covered Code. However, You may do so only on Your own behalf, and
-     not on behalf of the Initial Developer or any Contributor. You must
-     make it absolutely clear than any such warranty, support, indemnity or
-     liability obligation is offered by You alone, and You hereby agree to
-     indemnify the Initial Developer and every Contributor for any liability
-     incurred by the Initial Developer or such Contributor as a result of
-     warranty, support, indemnity or liability terms You offer.
-
-     3.6. Distribution of Executable Versions.
-     You may distribute Covered Code in Executable form only if the
-     requirements of Section 3.1-3.5 have been met for that Covered Code,
-     and if You include a notice stating that the Source Code version of the
-     Covered Code is available under the terms of this License, including a
-     description of how and where You have fulfilled the obligations of
-     Section 3.2. The notice must be conspicuously included in any notice in
-     an Executable version, related documentation or collateral in which You
-     describe recipients' rights relating to the Covered Code. You may
-     distribute the Executable version of Covered Code under a license of
-     Your choice, which may contain terms different from this License,
-     provided that You are in compliance with the terms of this License and
-     that the license for the Executable version does not attempt to limit
-     or alter the recipient's rights in the Source Code version from the
-     rights set forth in this License. If You distribute the Executable
-     version under a different license You must make it absolutely clear
-     that any terms which differ from this License are offered by You alone,
-     not by the Initial Developer or any Contributor. You hereby agree to
-     indemnify the Initial Developer and every Contributor for any liability
-     incurred by the Initial Developer or such Contributor as a result of
-     any such terms You offer.
-
-     3.7. Larger Works.
-     You may create a Larger Work by combining Covered Code with other code
-     not governed by the terms of this License and distribute the Larger
-     Work as a single product. In such a case, You must make sure the
-     requirements of this License are fulfilled for the Covered Code.
-
-4. Inability to Comply Due to Statute or Regulation.
-
-     If it is impossible for You to comply with any of the terms of this
-     License with respect to some or all of the Covered Code due to statute
-     or regulation then You must: (a) comply with the terms of this License
-     to the maximum extent possible; and (b) describe the limitations and
-     the code they affect. Such description must be included in the LEGAL
-     file described in Section 3.4 and must be included with all
-     distributions of the Source Code. Except to the extent prohibited by
-     statute or regulation, such description must be sufficiently detailed
-     for a recipient of ordinary skill to be able to understand it.
-
-5. Application of this License.
-
-     This License applies to code to which the Initial Developer has
-     attached the notice in Exhibit A, and to related Covered Code.
-
-6. Versions of the License.
-
-     6.1. New Versions.
-     Netscape Communications Corporation (``Netscape'') may publish revised
-     and/or new versions of the License from time to time. Each version will
-     be given a distinguishing version number.
-
-     6.2. Effect of New Versions.
-     Once Covered Code has been published under a particular version of the
-     License, You may always continue to use it under the terms of that
-     version. You may also choose to use such Covered Code under the terms
-     of any subsequent version of the License published by Netscape. No one
-     other than Netscape has the right to modify the terms applicable to
-     Covered Code created under this License.
-
-     6.3. Derivative Works.
-     If you create or use a modified version of this License (which you may
-     only do in order to apply it to code which is not already Covered Code
-     governed by this License), you must (a) rename Your license so that the
-     phrases ``Mozilla'', ``MOZILLAPL'', ``MOZPL'', ``Netscape'', ``NPL'' or
-     any confusingly similar phrase do not appear anywhere in your license
-     and (b) otherwise make it clear that your version of the license
-     contains terms which differ from the Mozilla Public License and
-     Netscape Public License. (Filling in the name of the Initial Developer,
-     Original Code or Contributor in the notice described in Exhibit A shall
-     not of themselves be deemed to be modifications of this License.)
-
-7. DISCLAIMER OF WARRANTY.
-
-     COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN ``AS IS'' BASIS,
-     WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
-     WITHOUT LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF
-     DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING.
-     THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED CODE
-     IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT,
-     YOU (NOT THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE
-     COST OF ANY NECESSARY SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER
-     OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF
-     ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
-
-8. TERMINATION.
-
-     This License and the rights granted hereunder will terminate
-     automatically if You fail to comply with terms herein and fail to cure
-     such breach within 30 days of becoming aware of the breach. All
-     sublicenses to the Covered Code which are properly granted shall
-     survive any termination of this License. Provisions which, by their
-     nature, must remain in effect beyond the termination of this License
-     shall survive.
-
-9. LIMITATION OF LIABILITY.
-
-     UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT
-     (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL THE INITIAL
-     DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE,
-     OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO YOU OR ANY OTHER
-     PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
-     OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF
-     GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND
-     ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE
-     BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF
-     LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY
-     RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW
-     PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE
-     EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT
-     EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.
-
-10. U.S. GOVERNMENT END USERS.
-
-     The Covered Code is a ``commercial item,'' as that term is defined in
-     48 C.F.R. 2.101 (Oct. 1995), consisting of ``commercial computer
-     software'' and ``commercial computer software documentation,'' as such
-     terms are used in 48 C.F.R. 12.212 (Sept. 1995). Consistent with 48
-     C.F.R. 12.212 and 48 C.F.R. 227.7202-1 through 227.7202-4 (June 1995),
-     all U.S. Government End Users acquire Covered Code with only those
-     rights set forth herein.
-
-11. MISCELLANEOUS.
-
-     This License represents the complete agreement concerning subject
-     matter hereof. If any provision of this License is held to be
-     unenforceable, such provision shall be reformed only to the extent
-     necessary to make it enforceable. This License shall be governed by
-     California law provisions (except to the extent applicable law, if any,
-     provides otherwise), excluding its conflict-of-law provisions. With
-     respect to disputes in which at least one party is a citizen of, or an
-     entity chartered or registered to do business in, the United States of
-     America: (a) unless otherwise agreed in writing, all disputes relating
-     to this License (excepting any dispute relating to intellectual
-     property rights) shall be subject to final and binding arbitration,
-     with the losing party paying all costs of arbitration; (b) any
-     arbitration relating to this Agreement shall be held in Santa Clara
-     County, California, under the auspices of JAMS/EndDispute; and (c) any
-     litigation relating to this Agreement shall be subject to the
-     jurisdiction of the Federal Courts of the Northern District of
-     California, with venue lying in Santa Clara County, California, with
-     the losing party responsible for costs, including without limitation,
-     court costs and reasonable attorneys fees and expenses. The application
-     of the United Nations Convention on Contracts for the International
-     Sale of Goods is expressly excluded. Any law or regulation which
-     provides that the language of a contract shall be construed against the
-     drafter shall not apply to this License.
-
-12. RESPONSIBILITY FOR CLAIMS.
-
-     Except in cases where another Contributor has failed to comply with
-     Section 3.4, You are responsible for damages arising, directly or
-     indirectly, out of Your utilization of rights under this License, based
-     on the number of copies of Covered Code you made available, the
-     revenues you received from utilizing such rights, and other relevant
-     factors. You agree to work with affected parties to distribute
-     responsibility on an equitable basis.
-
-AMENDMENTS
-Additional Terms applicable to the Netscape Public License.
-
-     I. Effect.
-     These additional terms described in this Netscape Public License --
-     Amendments shall apply to the Mozilla Communicator client code and to
-     all Covered Code under this License.
-
-     II. ``Netscape's Branded Code'' means Covered Code that Netscape
-     distributes and/or permits others to distribute under one or more
-     trademark(s) which are controlled by Netscape but which are not
-     licensed for use under this License.
-
-     III. Netscape and logo.
-     This License does not grant any rights to use the trademark
-     ``Netscape'', the ``Netscape N and horizon'' logo or the Netscape
-     lighthouse logo, even if such marks are included in the Original Code.
-
-     IV. Inability to Comply Due to Contractual Obligation.
-     Prior to licensing the Original Code under this License, Netscape has
-     licensed third party code for use in Netscape's Branded Code. To the
-     extent that Netscape is limited contractually from making such third
-     party code available under this License, Netscape may choose to
-     reintegrate such code into Covered Code without being required to
-     distribute such code in Source Code form, even if such code would
-     otherwise be considered ``Modifications'' under this License.
-
-     V. Use of Modifications and Covered Code by Initial Developer.
-
-          V.1. In General.
-          The obligations of Section 3 apply to Netscape, except to the
-          extent specified in this Amendment, Section V.2 and V.3.
-
-          V.2. Other Products.
-          Netscape may include Covered Code in products other than the
-          Netscape's Branded Code which are released by Netscape during the
-          two (2) years following the release date of the Original Code,
-          without such additional products becoming subject to the terms of
-          this License, and may license such additional products on
-          different terms from those contained in this License.
-
-          V.3. Alternative Licensing.
-          Netscape may license the Source Code of Netscape's Branded Code,
-          including Modifications incorporated therein, without such
-          additional products becoming subject to the terms of this License,
-          and may license such additional products on different terms from
-          those contained in this License.
-
-     VI. Arbitration and Litigation.
-     Notwithstanding the limitations of Section 11 above, the provisions
-     regarding arbitration and litigation in Section 11(a), (b) and (c) of
-     the License shall apply to all disputes relating to this License.
-
-EXHIBIT A.
-
-     ``The contents of this file are subject to the Netscape Public License
-     Version 1.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.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
-     Netscape Communications Corporation. All Rights Reserved.
-
-     Contributor(s): ______________________________________.''
-
-     [NOTE: The text of this Exhibit A may differ slightly from the text of
-     the notices in the Source Code files of the Original Code. This is due
-     to time constraints encountered in simultaneously finalizing the
-     License and in preparing the Original Code for release. You should use
-     the text of this Exhibit A rather than the text found in the Original
-     Code Source Code for Your Modifications.]

mozilla/Makefile

@@ -1,83 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-#
-
-DEPTH		= .
-
-NSPRDIR		= nsprpub
-NSPR20		= 1
-MOZILLA_CLIENT	= 1
-
-ifndef NO_MOCHA
-DIRS_JS		= js
-endif
-
-DIRS		= config coreconf $(NSPRDIR) jpeg dbm xpcom
-
-ifdef MOZ_NETCAST
-DIRS		+= netcast
-endif
-
-ifdef MOZ_JAVA
-DIRS		+= sun-java ldap ifc $(DIRS_JS) nav-java ifc/tools js/jsd
-else
-DIRS		+= sun-java nav-java $(DIRS_JS)
-endif
-
-ifndef NO_SECURITY
-DIRS		+= security
-endif
-
-DIRS		+= modules lib l10n cmd
-
-ifeq ($(STAND_ALONE_JAVA),1)
-DIRS		= config lib/xp $(NSPRDIR) jpeg modules/zlib sun-java ifc js ifc/tools sun-java/java
-endif
-
-include $(DEPTH)/config/rules.mk
-
-export:: $(OBJS)
-
-# Running this rule assembles all the SDK source pieces into dist/sdk.
-# You'll need to run this rule on every platform to get all the
-# binaries (e.g. javah) copied there. You'll also have to do special
-# magic on a Mac.
-sdk-src::
-	$(SDKINSTALL) include/npapi.h $(SDK)/include/
-	$(SDKINSTALL) include/jri_md.h $(SDK)/include/
-	$(SDKINSTALL) include/jritypes.h $(SDK)/include/
-	$(SDKINSTALL) include/jri.h $(SDK)/include/
-	$(SDKINSTALL) lib/plugin/npupp.h $(SDK)/include/
-	$(SDKINSTALL) sdk/common/*.c* $(SDK)/common/
-	$(SDKINSTALL) sun-java/classsrc/$(ZIP_NAME).x $(SDK)/classes/$(ZIP_NAME)
-	$(SDKINSTALL) sdk/examples/simple/Source/*.c $(SDK)/examples/simple/Source/
-	$(SDKINSTALL) sdk/examples/simple/Source/*.java $(SDK)/examples/simple/Source/
-	$(SDKINSTALL) sdk/examples/simple/Source/*.class $(SDK)/examples/simple/Source/
-	$(SDKINSTALL) sdk/examples/simple/Source/_gen/*.h $(SDK)/examples/simple/Source/_gen/
-	$(SDKINSTALL) sdk/examples/simple/Source/_stubs/*.c $(SDK)/examples/simple/Source/_stubs/
-	$(SDKINSTALL) sdk/examples/simple/Unix/makefile.* $(SDK)/examples/simple/Unix/
-	$(SDKINSTALL) sdk/examples/simple/Testing/SimpleExample.html $(SDK)/examples/simple/Testing/
-	$(SDKINSTALL) sdk/examples/simple/readme.html $(SDK)/examples/simple/
-	$(SDKINSTALL) sdk/examples/UnixTemplate/Source/*.c $(SDK)/examples/UnixTemplate/Source/
-	$(SDKINSTALL) sdk/examples/UnixTemplate/Testing/Test.html $(SDK)/examples/UnixTemplate/Testing/
-	$(SDKINSTALL) sdk/examples/UnixTemplate/Unix/makefile.* $(SDK)/examples/UnixTemplate/Unix/
-	$(SDKINSTALL) sdk/examples/UnixTemplate/readme.html $(SDK)/examples/UnixTemplate/
-
-sdk-bin::
-	cd sdk; $(MAKE); cd ..
-	$(SDKINSTALL) $(DIST)/bin/javah$(BIN_SUFFIX) $(SDK)/bin/$(OS_CONFIG)/
-	$(SDKINSTALL) sdk/examples/simple/Source/$(OBJDIR)/npsimple.$(DLL_SUFFIX) $(SDK)/bin/$(OS_CONFIG)/
-	$(SDKINSTALL) sdk/examples/UnixTemplate/Source/$(OBJDIR)/nptemplate.$(DLL_SUFFIX) $(SDK)/bin/$(OS_CONFIG)/

mozilla/build/mac/BuildList.pm

@@ -0,0 +1,287 @@
+#!perl
+
+package			BuildList;
+require			Exporter;
+
+@ISA				= qw(Exporter);
+@EXPORT			= qw(BuildMozilla DistMozilla);
+
+=head1 NAME
+
+BuildList - build the [ordered] set of projects needed to construct Mozilla
+
+=head1 SYNOPSIS
+
+...
+
+=head1 COPYRIGHT
+
+The contents of this file are subject to the Netscape Public License
+Version 1.0 (the "NPL"); you may not use this file except in
+compliance with the NPL.  You may obtain a copy of the NPL at
+http://www.mozilla.org/NPL/
+
+Software distributed under the NPL is distributed on an "AS IS" basis,
+WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+for the specific language governing rights and limitations under the
+NPL.
+
+The Initial Developer of this code under the NPL is Netscape
+Communications Corporation.  Portions created by Netscape are
+Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+Reserved.
+
+=cut
+
+		use Moz;
+		use File::Path;
+		
+sub BuildMozilla()
+	{
+		if ( $main::DEBUG )
+			{
+				$D = "Debug";
+				$dist_dir = ":mozilla:dist:client_debug:";
+			}
+		else
+			{
+				$D = "";
+				$dist_dir = ":mozilla:dist:client:";
+			}
+		
+			#
+			# Build the appropriate target of each project
+			#
+
+		BuildProjectClean(":mozilla:lib:mac:NSStdLib:NSStdLib.mcp",										"Stubs");
+		BuildProjectClean(":mozilla:lib:mac:NSRuntime:NSRuntime.mcp",									"Stubs");
+		BuildProjectClean(":mozilla:lib:mac:MacMemoryAllocator:MemAllocator.mcp",			"Stubs");
+		BuildProjectClean(":mozilla:cmd:macfe:projects:client:NavigatorStubs.mcp",		"Stubs");
+		
+		BuildProject(":mozilla:lib:mac:NSRuntime:NSRuntime.mcp",											"NSRuntime$D.shlb");
+		MakeAlias(":mozilla:lib:mac:NSRuntime:NSRuntime$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:cmd:macfe:restext:StringLib.mcp",											"Strings$D.shlb");
+		MakeAlias(":mozilla:cmd:macfe:restext:Strings$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:lib:mac:MoreFiles:build:MoreFilesPPC.mcp",							"MoreFiles$D.shlb");
+		MakeAlias(":mozilla:lib:mac:MoreFiles:build:MoreFiles$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:nsprpub:macbuild:NSPR20PPC.mcp",												"NSPR20$D.shlb");
+		MakeAlias(":mozilla:nsprpub:macbuild:NSPR20$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:dbm:macbuild:DBMPPC.mcp",															"DBM$D.shlb");
+		MakeAlias(":mozilla:dbm:macbuild:DBM$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:lib:mac:MacMemoryAllocator:MemAllocator.mcp",					"MemAllocator$D.shlb");
+		MakeAlias(":mozilla:lib:mac:MacMemoryAllocator:MemAllocator$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:lib:mac:NSStdLib:NSStdLib.mcp",												"NSStdLib$D.shlb");
+		MakeAlias(":mozilla:lib:mac:NSStdLib:NSStdLib$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:xpcom:macbuild:xpcomPPC.mcp",													"xpcom$D.shlb");
+		MakeAlias(":mozilla:xpcom:macbuild:xpcom$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:lib:mac:PowerPlant:PowerPlant.mcp",										"PowerPlant$D.shlb");		
+		MakeAlias(":mozilla:lib:mac:PowerPlant:PowerPlant$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:modules:zlib:macbuild:zlib.mcp",												"zlib$D.shlb");
+		MakeAlias(":mozilla:modules:zlib:macbuild:zlib$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:jpeg:macbuild:JPEG.mcp",																"JPEG$D.shlb");
+		MakeAlias(":mozilla:jpeg:macbuild:JPEG$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:sun-java:stubs:macbuild:JavaStubs.mcp",								"JavaRuntime$D.shlb");
+		MakeAlias(":mozilla:sun-java:stubs:macbuild:JavaRuntime$D.shlb", "$dist_dir");	
+		
+		BuildProject(":mozilla:js:jsj:macbuild:JSJ_PPC.mcp", 													"JSJ$D.o");
+		
+		BuildProject(":mozilla:js:macbuild:JavaScriptPPC.mcp",												"JavaScript$D.shlb");
+		MakeAlias(":mozilla:js:macbuild:JavaScript$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:nav-java:stubs:macbuild:NavJavaStubs.mcp",							"NavJava$D.shlb");
+		MakeAlias(":mozilla:nav-java:stubs:macbuild:NavJava$D.shlb", "$dist_dir");
+
+		BuildProject(":mozilla:modules:rdf:macbuild:RDF.mcp", 												"RDF$D.shlb");
+		MakeAlias(":mozilla:modules:rdf:macbuild:RDF$D.shlb", "$dist_dir");
+	
+		BuildProject(":mozilla:modules:xml:macbuild:XML.mcp",													"XML$D.shlb");
+		MakeAlias(":mozilla:modules:xml:macbuild:XML$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:modules:schedulr:macbuild:Schedulr.mcp",								"Scheduler$D.shlb");
+		MakeAlias(":mozilla:modules:schedulr:macbuild:Scheduler$D.shlb", "$dist_dir");
+			
+		BuildProject(":mozilla:build:mac:CustomLib:CustomLib.mcp",										"CustomLib$D.shlb");
+		MakeAlias(":mozilla:build:mac:CustomLib:CustomLib$D.shlb", "$dist_dir");
+		
+		BuildProject(":mozilla:build:mac:CustomLib:CustomLib.mcp",										"CustomStaticLibs$D.o");
+		BuildProject(":mozilla:modules:security:freenav:macbuild:NoSecurity.mcp",			"Security.o");
+		BuildProject(":mozilla:modules:libfont:macbuild:FontBroker.mcp",							"FontBroker$D.o");
+		BuildProject(":mozilla:lib:libmocha:macbuild:LibMocha.mcp",										"LibMocha$D.o");	
+		BuildProject(":mozilla:network:macbuild:network.mcp",													"Network$D.o");
+		
+		if ( $main::MOZ_LITE == 0 )
+			{
+				BuildProject(":mozilla:cmd:macfe:Composer:build:Composer.mcp",						"Composer$D.o");
+				
+				# Build the appropriate resources target
+				BuildProject(":mozilla:cmd:macfe:projects:client:Client.mcp", 						"Moz_Resources");
+			}
+		else
+			{
+				# Build a project with dummy targets to make stub libraries
+				BuildProject("cmd:macfe:projects:dummies:MakeDummies.mcp",				"Composer$D.o");
+				
+				# Build the appropriate resources target
+				BuildProject(":mozilla:cmd:macfe:projects:client:Client.mcp", 						"Nav_Resources");
+			}
+		
+		BuildProject(":mozilla:cmd:macfe:projects:client:Client.mcp", 								"Client$D");
+	}
+
+
+sub DistMozilla()
+	{
+		mkpath([ ":mozilla:dist:", ":mozilla:dist:client:", ":mozilla:dist:client_debug:", ":mozilla:dist:client_stubs:" ]);
+
+		#INCLUDE
+		InstallFromManifest(":mozilla:config:mac:MANIFEST",													":mozilla:dist:config:");
+		InstallFromManifest(":mozilla:include:MANIFEST",														":mozilla:dist:include:");
+		InstallFromManifest(":mozilla:cmd:macfe:pch:MANIFEST",											":mozilla:dist:include:");
+
+		#MAC_COMMON
+		InstallFromManifest(":mozilla:build:mac:MANIFEST",													":mozilla:dist:mac:common:");
+		InstallFromManifest(":mozilla:lib:mac:NSStdLib:include:MANIFEST",						":mozilla:dist:mac:common:");
+		InstallFromManifest(":mozilla:lib:mac:MacMemoryAllocator:include:MANIFEST",	":mozilla:dist:mac:common:");
+		InstallFromManifest(":mozilla:lib:mac:Misc:MANIFEST",												":mozilla:dist:mac:common:");
+		InstallFromManifest(":mozilla:lib:mac:MoreFiles:MANIFEST",									":mozilla:dist:mac:common:morefiles:");
+		InstallFromManifest(":mozilla:cmd:macfe:MANIFEST",													":mozilla:dist:mac:macfe:");
+
+		#NSPR
+		InstallFromManifest(":mozilla:nsprpub:pr:include:MANIFEST",									":mozilla:dist:nspr:");
+		InstallFromManifest(":mozilla:nsprpub:pr:src:md:mac:MANIFEST",							":mozilla:dist:nspr:mac:");
+		InstallFromManifest(":mozilla:nsprpub:lib:ds:MANIFEST",											":mozilla:dist:nspr:");
+		InstallFromManifest(":mozilla:nsprpub:lib:libc:include:MANIFEST",						":mozilla:dist:nspr:");
+		InstallFromManifest(":mozilla:nsprpub:lib:msgc:include:MANIFEST",						":mozilla:dist:nspr:");
+		
+		#DBM
+		InstallFromManifest(":mozilla:dbm:include:MANIFEST",												":mozilla:dist:dbm:");
+		
+		#LIBIMAGE
+		InstallFromManifest(":mozilla:modules:libimg:png:MANIFEST",									":mozilla:dist:libimg:");
+		InstallFromManifest(":mozilla:modules:libimg:src:MANIFEST",									":mozilla:dist:libimg:");
+		InstallFromManifest(":mozilla:modules:libimg:public:MANIFEST",							":mozilla:dist:libimg:");
+		
+		#SECURITY_freenav
+		InstallFromManifest(":mozilla:modules:security:freenav:MANIFEST",		":mozilla:dist:security:");
+		
+		#XPCOM
+		InstallFromManifest(":mozilla:xpcom:src:MANIFEST",									":mozilla:dist:xpcom:");
+		
+		#ZLIB
+		InstallFromManifest(":mozilla:modules:zlib:src:MANIFEST",						":mozilla:dist:zlib:");
+				
+		#JPEG
+		InstallFromManifest(":mozilla:jpeg:MANIFEST",												":mozilla:dist:jpeg:");
+		
+		#JSJ
+		InstallFromManifest(":mozilla:js:jsj:MANIFEST",											":mozilla:dist:jsj:");
+		
+		#JSDEBUG
+		InstallFromManifest(":mozilla:js:jsd:MANIFEST",											":mozilla:dist:jsdebug:");
+		
+		#JS
+		InstallFromManifest(":mozilla:js:src:MANIFEST",											":mozilla:dist:js:");
+		
+		#RDF
+		InstallFromManifest(":mozilla:modules:rdf:include:MANIFEST",				":mozilla:dist:rdf:");
+		
+		#XML
+		InstallFromManifest(":mozilla:modules:xml:glue:MANIFEST",						":mozilla:dist:xml:");
+		InstallFromManifest(":mozilla:modules:xml:expat:xmlparse:MANIFEST",	":mozilla:dist:xml:");
+		
+		#LIBFONT
+		InstallFromManifest(":mozilla:modules:libfont:MANIFEST",						":mozilla:dist:libfont:");
+		InstallFromManifest(":mozilla:modules:libfont:src:MANIFEST",				":mozilla:dist:libfont:");
+		
+		#LDAP
+		if ( $main::MOZ_LDAP )
+			{
+				InstallFromManifest(":mozilla:directory:c-sdk:ldap:include:MANIFEST", ":mozilla:dist:ldap:");
+			}
+			
+		#SCHEDULER
+		InstallFromManifest(":mozilla:modules:schedulr:public:MANIFEST",		":mozilla:dist:schedulr:");
+		
+		#NETWORK
+		InstallFromManifest(":mozilla:network:cache:MANIFEST",						":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:client:MANIFEST",						":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:cnvts:MANIFEST",						":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:cstream:MANIFEST",					":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:main:MANIFEST",							":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:about:MANIFEST",		":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:certld:MANIFEST",	":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:dataurl:MANIFEST",	":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:file:MANIFEST",		":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:ftp:MANIFEST",			":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:gopher:MANIFEST",	":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:http:MANIFEST",		":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:js:MANIFEST",			":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:mailbox:MANIFEST",	":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:marimba:MANIFEST",	":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:nntp:MANIFEST",		":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:pop3:MANIFEST",		":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:remote:MANIFEST",	":mozilla:dist:network:");
+		InstallFromManifest(":mozilla:network:protocol:smtp:MANIFEST",		":mozilla:dist:network:");
+		
+		#HTML_DIALOGS
+		InstallFromManifest(":mozilla:lib:htmldlgs:MANIFEST",							":mozilla:dist:htmldlgs:");
+		
+		#LAYOUT
+		InstallFromManifest(":mozilla:lib:layout:MANIFEST",								":mozilla:dist:layout:");
+		
+		#LAYERS
+		InstallFromManifest(":mozilla:lib:liblayer:include:MANIFEST",			":mozilla:dist:layers:");
+		
+		#PARSE
+		InstallFromManifest(":mozilla:lib:libparse:MANIFEST",							":mozilla:dist:libparse:");
+		
+		#STYLE
+		InstallFromManifest(":mozilla:lib:libstyle:MANIFEST",							":mozilla:dist:libstyle:");
+		
+		#PLUGIN
+		InstallFromManifest(":mozilla:lib:plugin:MANIFEST",								":mozilla:dist:plugin:");
+		
+		#LIBHOOK
+		InstallFromManifest(":mozilla:modules:libhook:public:MANIFEST",		":mozilla:dist:libhook:");
+		
+		#LIBPREF
+		InstallFromManifest(":mozilla:modules:libpref:public:MANIFEST",		":mozilla:dist:libpref:");
+		
+		#LIBREG
+		InstallFromManifest(":mozilla:modules:libreg:include:MANIFEST",		":mozilla:dist:libreg:");
+		
+		#LIBUTIL
+		InstallFromManifest(":mozilla:modules:libutil:public:MANIFEST",		":mozilla:dist:libutil:");
+		
+		#PROGRESS
+		InstallFromManifest(":mozilla:modules:progress:public:MANIFEST",	":mozilla:dist:progress:");
+		
+		#SOFTUPDATE
+		InstallFromManifest(":mozilla:modules:softupdt:include:MANIFEST",	":mozilla:dist:softupdate:");
+		
+		#EDTPLUG
+		InstallFromManifest(":mozilla:modules:edtplug:include:MANIFEST", 	":mozilla:dist:edtplug:");
+
+		#NAV_JAVA
+		InstallFromManifest(":mozilla:nav-java:stubs:include:MANIFEST",		":mozilla:dist:nav-java:");
+		InstallFromManifest(":mozilla:nav-java:stubs:macjri:MANIFEST",		":mozilla:dist:nav-java:");
+		
+		#SUN_JAVA
+		InstallFromManifest(":mozilla:sun-java:stubs:include:MANIFEST",		":mozilla:dist:sun-java:");
+		InstallFromManifest(":mozilla:sun-java:stubs:macjri:MANIFEST",		":mozilla:dist:sun-java:");
+	}
+
+1;
+
+

mozilla/build/mac/BuildMozilla.pl

@@ -1,37 +1,35 @@
+#!perl
+
 #
 # The contents of this file are subject to the Netscape Public License
 # Version 1.0 (the "NPL"); you may not use this file except in
 # compliance with the NPL.  You may obtain a copy of the NPL at
 # http://www.mozilla.org/NPL/
-# 
+#
 # Software distributed under the NPL is distributed on an "AS IS" basis,
 # WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 # for the specific language governing rights and limitations under the
 # NPL.
-# 
+#
 # The Initial Developer of this code under the NPL is Netscape
 # Communications Corporation.  Portions created by Netscape are
 # Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 # Reserved.
 #
 
-#! gmake
+	use Moz;
+	use BuildList;
 
-MOD_DEPTH = ..
+$DEBUG = 0;
+$MOZ_LITE = 0;		# build moz medium. This will come from a config file at some stage.
 
-export NSPR20=1
+Moz::OpenErrorLog(":::Mozilla.BuildLog");
+Moz::StopForErrors();
 
-include $(MOD_DEPTH)/config/config.mk
+chdir("::::");
 
-#
-# On all platforms, we build ds and libc.
-#
-DIRS = ds libc msgc
-ifneq (,$(filter-out WIN16 NEWS-OS,$(OS_TARGET)))
-endif
+# Make and popuplate the dist directory
+DistMozilla();
 
-include $(MOD_DEPTH)/config/rules.mk
-
-export:: $(TARGETS)
-
-install:: export
+# Now build the projects
+BuildMozilla();

mozilla/build/mac/BuildMozillaDebug.pl

@@ -0,0 +1,35 @@
+#!perl
+
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+	use Moz;
+	use BuildList;
+
+$DEBUG = 1;
+$MOZ_LITE = 0;		# build moz medium. This will come from a config file at some stage.
+
+Moz::OpenErrorLog(":::Mozilla.BuildLog");
+Moz::StopForErrors();
+
+chdir("::::");
+
+# Make and popuplate the dist directory
+DistMozilla();
+
+# Now build the projects
+BuildMozilla();

mozilla/build/mac/CopyExports.script

@@ -0,0 +1,78 @@
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+if {#} != 1
+	echo "CopyExports requires 1 parameters:"
+	echo "Parameter 1: path relative to {SourceRootDir} of the file which contains"
+	echo "             the list of files to be copied, one per line.  This path"
+	echo "             may not begin with a colon"
+	echo
+	Exit 1
+end if
+
+
+Set SourceList "{SourceRootDir}{1}"
+
+Set ScriptsDir "{SourceRootDir}mozilla:build:mac:"
+
+#set sourceList "{SourceRootDir}mozilla:{1}"
+
+if {verbose}
+	echo "Source list is in file ¶"{SourceList}¶""
+	echo "Scripts directory is ¶"{ScriptsDir}¶""
+end if
+
+# for each line in the source file, remove it if it starts with #, otherwise quote it
+
+for curLine in `streamedit "{sourceList}" -e '/¥#Å/ Delete; /¥/ Replace /(Å)¨1/ "¶""¨1"¶""'`
+	
+	echo "{curLine}"
+	
+	# ignore empty lines
+	if `evaluate "{{curLine}}" != ""`
+		
+		echo "{curLine}"
+		
+		# strip out trailing comments
+		if `evaluate "{curLine}" =~ /(Å)¨1[ ¶t]+(#Å)¨2/`
+			set sourceLine "{¨1}"
+			# echo "Discarding comment {¨2}"
+		else
+			set sourceLine "{curLine}"
+		end if
+		
+		if `evaluate "{sourceLine}" =~ /([Â ¶t]+)¨1[ ¶t]+[:]*(Å)¨2/`
+		
+			if {verbose}
+				echo "Cur line is {sourceLine}"
+			end if
+		
+			set exportFile "{¨1}"
+			set theTarget "{¨2}"
+			
+			if {verbose}
+				echo "Export file name is {exportFile}"
+				echo "Target directory is {theTarget}"
+			end if
+			
+			"{ScriptsDir}CopyList.script" "{exportFile}" "{theTarget}"
+		
+		end if
+	
+	end if
+
+end for

mozilla/build/mac/CopyHeaders.script

@@ -0,0 +1,81 @@
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+
+# This is the controlling script for a set of scripts that copy public
+# header files in one or more source trees into a single, "dist" directory.
+#
+# It relies on the two accompanying scripts, ÒCopyList.scriptÓ and
+# ÒCopyExports.scriptÓ, which must be in the same directory.
+# 
+# To execute this script, select everything from "# Get the..." to 
+# " the end" and hit the Enter key.
+# 
+# Known bugs:
+# 	Header files are always copied if the export.mac file contains
+#	non-local paths.
+#	Spurious output is produced even when verbose is off.
+#
+
+# Uncomment this to get some progress information
+# set -e verbose 1
+
+# Get the root of everything
+
+set magicfilepath "{systempfolder}filepath" # Temporary items folder, "filepath"
+if !`Exists "{{magicFilePath}}"`
+	Echo "No file path file seems to have been created in the temporary items folder."
+	Echo "Was this script executed from the perl script?  That's the way it was designed."
+	Exit 1
+end if
+
+set myDirectory "`catenate "{{magicFilePath}}"`"
+delete -i "{{magicFilePath}}"
+
+Set SourceList "{myDirectory}{1}"
+(Evaluate "{myDirectory}" =~ /(Å:)¨1[Â:]+:[Â:]+:[Â:]+/) #·· dev:null
+Set -e mozillaDir "{¨1}"
+
+if !`Exists "{{mozillaDir}}"`
+	Echo "A file path was passed, but it doesn't seem to be the mozilla directory."
+	Exit 1
+end if
+echo "Mozilla directory found at {mozillaDir}"
+
+#Calculate the root directory by stripping off the leaf name.
+(Evaluate "{mozillaDir}" =~ /(Å:)¨1([Â:]+)¨2/) #·· dev:null
+Set -e SourceRootDir "{¨1}"
+Set -e DestRootDir "{mozillaDir}dist:"
+
+# Ensure the build and stubs folders exist
+
+if !`exists -d "{mozillaDir}dist"`
+	newfolder "{mozillaDir}dist"
+end if
+if !`exists -d "{mozillaDir}dist:client"`
+	newfolder "{mozillaDir}dist:client"
+end if
+if !`exists -d "{mozillaDir}dist:client_debug"`
+	newfolder "{mozillaDir}dist:client_debug"
+end if
+if !`exists -d "{mozillaDir}dist:client_stubs"`
+	newfolder "{mozillaDir}dist:client_stubs"
+end if
+
+"{SourceRootDir}mozilla:build:mac:CopyExports.script" "mozilla:build:mac:MacExportListPublic"
+
+# the end

mozilla/build/mac/CopyList.script

@@ -0,0 +1,97 @@
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+if {#} != 2
+	echo "CopyList requires 2 parameters:"
+	echo "Parameter 1: path relative to {SourceRootDir} of the file which contains"
+	echo "             the list of files to be copied, one per line.  This path"
+	echo "             may not begin with a colon"
+	echo
+	echo "Parameter 2: path relative to {DestRootDir} of the directory where all the"
+	echo "             files are to be copied.  No initial colons!"
+	echo
+	Exit 1
+end if
+
+set debugEcho "" # This setting will actually duplicate the files
+#set debugEcho "echo" # This setting will merely print the "duplicate" commands.
+
+set sourceList "{SourceRootDir}{1}"
+set targetDir "{DestRootDir}{2}"
+
+# targetDir may not end in a colon for this script to work.
+if `Evaluate "{targetDir}" =~ /(Å)¨1:/`
+	#echo "Removed a colon"
+	set targetDir "{¨1}"
+end if
+
+#Ensure the target hierarchy exists
+# Volume name
+(Evaluate "{TargetDir}" =~ /([Â:]+)¨1:Å/) ·· dev:null
+Set PartialPath "{¨1}"
+Loop
+	(Evaluate "{TargetDir}" =~ /("{PartialPath}":[Â:]+)¨1([:]*)¨2Å/) ·· dev:null
+	Set PartialPath "{¨1}"
+	Set Exit 0
+	(NewFolder "{PartialPath}") ·· dev:null
+	Set Exit 1
+	break if "{¨2}" == ""
+End Loop
+
+#Calculate the source directory by stripping off the leaf name.
+(Evaluate "{SourceList}" =~ /(Å:)¨1([Â:]+)¨2/) #·· dev:null
+Set SourceDir "{¨1}"
+
+if {verbose}
+	echo "Source list is in file ¶"{sourceList}¶""
+	echo "Source directory is  ¶"{SourceDir}¶""
+	echo "Target directory is ¶"{targetDir}¶""
+end if
+
+# Strip all comment lines, pipe the stripped lines into the "for" loop.
+# We quote each whole line here so that we deal with a line at a time in the
+# for loop. Don't ya just love MPW quoting rulesÉ
+
+for f in `streamedit "{sourceList}" -e '/¥#Å/ Delete; /¥/ Replace /(Å)¨1/ "¶""¨1"¶""'`
+	
+	if `evaluate "{{f}}" != ""`
+	
+		# strip out trailing comments (in fact, anything following whitespace)
+		if `evaluate "{f}" =~ /([Â ¶t]+)¨1[ ¶t]+([#]*Å)¨2/`
+			set sourceFile "{¨1}"
+			# echo "Discarding comment {¨2}"
+		else
+			set sourceFile "{f}"
+		end if
+		
+		# sourceFile can be a relative path, so need to get the file name for date comparisons
+		if `evaluate "{sourceFile}" =~ /Å:([Â:]+)¨1/`
+			set filename "{¨1}"
+		else
+			set filename "{sourceFile}"
+		end if
+		
+		# now copy the file if newer
+		if "`Newer "{sourceDir}{sourceFile}" "{targetDir}:{filename}"`" #|| !`Exists "{targetDir}:{filename}"`
+			if {verbose} ; echo "{sourceDir}{sourceFile} is newer than {targetDir}:{filename}" ; end if
+			#{debugEcho} duplicate -y "{sourceDir}{sourceFile}" "{targetDir}"
+			{debugEcho} newalias "{sourceDir}{sourceFile}" "{targetDir}:{filename}"
+		end if
+		
+	end if
+	
+end for

mozilla/build/mac/IDE_Options.h

@@ -0,0 +1,88 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+/*
+
+	This file overrides all option settings in the IDE.  It is an attempt to allow all builds
+	to have the same options.
+
+	Note: We can't use ConditionalMacros.h in this file because it will conflict with 
+	the PowerPlant precompiled headers.
+
+*/
+
+	/* warning pragmas */
+#pragma warn_hidevirtual on
+
+#pragma check_header_flags on
+
+	/* Language features that must be the same across libraries... */
+#pragma enumsalwaysint	on
+#pragma unsigned_char		off
+#pragma exceptions			on
+#pragma bool on
+
+
+	/* Save as much space as possible with strings... */
+#pragma pool_strings				on
+#pragma dont_reuse_strings	off
+
+#pragma options align=native
+#pragma sym on									/* Takes no memory.  OK in non-debug. */
+
+
+
+#ifdef powerc /* ...generating PowerPC */
+	#pragma toc_data on
+	#pragma fp_contract on
+	#pragma readonly_strings on
+
+	#ifdef DEBUG
+		#pragma traceback on
+		#pragma global_optimizer off
+		#pragma scheduling off
+		#pragma peephole off
+		#pragma optimize_for_size off
+	#else
+		#pragma traceback off
+		#pragma global_optimizer on
+		#pragma optimization_level 4
+		#pragma scheduling 604
+		#pragma peephole on
+		#pragma optimize_for_size on
+	#endif
+
+#else /* ...generating 68k */
+	#pragma code68020 on
+	#pragma code68881 off
+
+		/* Far everything... */
+	#pragma far_code
+	#pragma far_data on
+	#pragma far_strings on
+	#pragma far_vtables on
+
+	#pragma fourbyteints	on	/* 4-byte ints */
+	#pragma IEEEdoubles		on	/* 8-byte doubles (as required by Java and NSPR) */
+
+	#ifdef DEBUG
+		#pragma macsbug on
+		#pragma oldstyle_symbols off
+	#else
+		#pragma macsbug off
+	#endif
+#endif

mozilla/build/mac/MacExportListPublic

@@ -0,0 +1,156 @@
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+# This is a list of paths to export.mac files, and destination
+# directories for the copied headers. Destinations are relative
+# to "mozilla:dist".
+
+###################
+# PUBLIC TREE
+###################
+
+# LDAP
+mozilla:directory:c-sdk:ldap:include:MANIFEST		:ldap
+
+#INCLUDE
+mozilla:config:mac:export.mac						:config
+mozilla:include:export.mac							:include
+mozilla:cmd:macfe:pch:export.mac					:include
+
+#MAC_COMMON
+mozilla:build:mac:export.mac						:mac:common
+mozilla:lib:mac:NSStdLib:include:export.mac			:mac:common
+mozilla:lib:mac:MacMemoryAllocator:include:export.mac	:mac:common
+mozilla:lib:mac:Misc:export.mac						:mac:common
+mozilla:lib:mac:MoreFiles:export.mac				:mac:common:morefiles
+mozilla:cmd:macfe:export.mac						:mac:macfe
+
+#NSPR
+mozilla:nsprpub:pr:include:export.mac				:nspr
+mozilla:nsprpub:pr:src:md:mac:export.mac			:nspr:mac
+mozilla:nsprpub:lib:ds:export.mac					:nspr
+mozilla:nsprpub:lib:libc:include:export.mac			:nspr
+mozilla:nsprpub:lib:msgc:include:export.mac			:nspr
+
+#DBM
+mozilla:dbm:include:export.mac						:dbm
+
+#LIBIMAGE
+mozilla:modules:libimg:png:export.mac				:libimg
+mozilla:modules:libimg:src:export.mac				:libimg
+mozilla:modules:libimg:public:export.mac			:libimg
+
+#SECURITY_freenav
+mozilla:modules:security:freenav:export.mac			:security
+
+#XPCOM
+mozilla:xpcom:src:export.mac						:xpcom
+
+#ZLIB
+mozilla:modules:zlib:src:export.mac					:zlib
+
+#JPEG
+mozilla:jpeg:export.mac								:jpeg
+
+#JSJ
+mozilla:js:jsj:export.mac							:jsj
+
+#JSDEBUG
+mozilla:js:jsd:export.mac							:jsdebug
+
+#JS
+mozilla:js:src:export.mac							:js
+
+#RDF
+mozilla:modules:rdf:include:export.mac				:rdf
+
+#XML
+mozilla:modules:xml:glue:export.mac					:xml
+mozilla:modules:xml:expat:xmlparse:export.mac		:xml
+
+#LIBFONT
+mozilla:modules:libfont:public:export.mac			:libfont
+mozilla:modules:libfont:src:export.mac				:libfont
+
+#SCHEDULER
+mozilla:modules:schedulr:public:export.mac			:schedulr
+
+#NETWORK
+#This stuff is all in libnet on the branch.
+#mozilla:network:cache:export.mac					:network
+#mozilla:network:client:export.mac					:network
+#mozilla:network:cnvts:export.mac					:network
+#mozilla:network:cstream:export.mac					:network
+#mozilla:network:main:export.mac						:network
+#ozilla:network:protocol:about:export.mac			:network
+#mozilla:network:protocol:certld:export.mac			:network
+#mozilla:network:protocol:dataurl:export.mac			:network
+#mozilla:network:protocol:file:export.mac			:network
+#mozilla:network:protocol:ftp:export.mac				:network
+#mozilla:network:protocol:gopher:export.mac			:network
+#mozilla:network:protocol:http:export.mac			:network
+#mozilla:network:protocol:js:export.mac				:network
+#mozilla:network:protocol:mailbox:export.mac			:network
+#mozilla:network:protocol:marimba:export.mac			:network
+#mozilla:network:protocol:nntp:export.mac			:network
+#mozilla:network:protocol:pop3:export.mac			:network
+#mozilla:network:protocol:remote:export.mac			:network
+#mozilla:network:protocol:smtp:export.mac			:network
+
+#NORMANDY_BRANCH only
+mozilla:lib:libnet:export.mac						:libnet
+
+#HTML_DIALOGS
+mozilla:lib:htmldlgs:export.mac						:htmldlgs
+
+#LAYOUT
+mozilla:lib:layout:export.mac						:layout
+
+#LAYERS
+mozilla:lib:liblayer:include:export.mac				:layers
+
+#PARSE
+mozilla:lib:libparse:export.mac						:libparse
+
+#STYLE
+mozilla:lib:libstyle:export.mac						:libstyle
+
+#LIBHOOK
+mozilla:modules:libhook:public:export.mac			:libhook
+
+#LIBPREF
+mozilla:modules:libpref:public:export.mac			:libpref
+
+#LIBREG
+mozilla:modules:libreg:include:export.mac			:libreg
+
+#LIBUTIL
+mozilla:modules:libutil:public:export.mac			:libutil
+
+#PROGRESS
+mozilla:modules:progress:public:export.mac			:progress
+
+#SOFTUPDATE
+mozilla:modules:softupdt:include:export.mac			:softupdate
+
+#NAV_JAVA
+mozilla:nav-java:stubs:macjri:export.mac			:nav-java:macjri
+mozilla:nav-java:stubs:include:export.mac			:nav-java
+
+#SUN_JAVA
+mozilla:sun-java:stubs:include:export.mac			:sun-java:include
+mozilla:sun-java:stubs:macjri:export.mac			:sun-java:macjri

mozilla/build/mac/Moz.pm

@@ -0,0 +1,368 @@
+=head1 NAME
+
+B<Moz> - routines for automating CodeWarrior builds, and some extra-curricular activities related to building Mozilla
+
+=head1 SYNOPSIS
+
+    use Moz;
+
+    OpenErrorLog(":::BuildLog");
+    StopForErrors();
+
+		$Moz::QUIET = 1;
+		InstallFromManifest(":projects:MANIFEST", $dist_dir);
+
+    BuildProjectClean(":projects:SomeProject.mcp", "SomeTarget");
+    MakeAlias(":projects:SomeProject.shlb", $dist_dir);
+
+    DontStopForErrors();
+
+    BuildProject(":projects:SomeOtherProject.mcp", "SomeTarget");
+
+=head1 DESCRIPTION
+
+B<Moz> comprises the routines needed to slap CodeWarrior around, force it to build a sequence of projects, report the results, and a few other things.
+
+=cut
+
+
+
+
+package			Moz;
+require			Exporter;
+
+@ISA				= qw(Exporter);
+@EXPORT			= qw(BuildProject BuildProjectClean OpenErrorLog MakeAlias StopForErrors DontStopForErrors InstallFromManifest);
+@EXPORT_OK	= qw(CloseErrorLog UseCodeWarriorLib QUIET);
+
+	use Cwd;
+	use File::Path;
+	use ExtUtils::Manifest 'maniread';
+
+sub current_directory()
+	{
+		my $current_directory = cwd();
+		chop($current_directory) if ( $current_directory =~ m/:$/ );
+		return $current_directory;
+	}
+
+sub full_path_to($)
+	{
+		my ($path) = @_;
+		if ( $path =~ m/^[^:]+$/ )
+			{
+				$path = ":" . $path;
+			}
+
+		if ( $path =~ m/^:/ )
+			{
+				$path = current_directory() . $path;
+			}
+
+		return $path;
+	}
+
+=head2 Setup
+
+Pretty much, everything is taken care of for you.
+  However, B<Moz> does use a little compiled AppleScript library (the file CodeWarriorLib) for some of its communcication with CodeWarrior.
+  If this library isn't in the same directory as "Moz.pm", then you need to tell B<Moz> where to find it.
+  Call C<UseCodeWarriorLib($path_to_CodeWarriorLib)>.
+  This routine is not exported by default, nor are you likely to need it.
+
+=cut
+
+sub UseCodeWarriorLib($)
+	{
+		($CodeWarriorLib) = @_;
+		$CodeWarriorLib = full_path_to($CodeWarriorLib);
+	}
+
+sub activate_CodeWarrior()
+	{
+MacPerl::DoAppleScript(<<END_OF_APPLESCRIPT);
+	tell (load script file "$CodeWarriorLib") to ActivateCodeWarrior()
+END_OF_APPLESCRIPT
+	}
+
+BEGIN
+	{
+		UseCodeWarriorLib(":CodeWarriorLib");
+		activate_CodeWarrior();
+	}
+
+$logging								= 0;
+$recent_errors_file			= "";
+$stop_on_1st_error			= 1;
+$QUIET									= 0;
+
+
+
+=head2 Logging all the errors and warnings - C<OpenErrorLog($log_file)>, C<CloseErrorLog()>
+
+The warnings and errors generated in the course of building projects can be logged to a file.
+Tinderbox uses this facility to show why a remote build failed.
+
+Logging is off by default.
+  Start logging at any point in your build process with C<OpenErrorLog($log_file)>.
+  Stop with C<CloseErrorLog()>.
+  You never need to close the log explicitly, unless you want to just log a couple of projects in the middle of a big list.
+  C<CloseErrorLog()> is not exported by default. 
+
+=cut
+
+sub CloseErrorLog()
+	{
+		if ( $logging )
+			{
+				close(ERROR_LOG);
+				$logging = 0;
+				StopForErrors() if $stop_on_1st_error;
+			}
+	}
+
+
+
+sub OpenErrorLog($)
+	{
+		my ($log_file) = @_;
+
+		CloseErrorLog();
+		if ( $log_file )
+			{
+				$log_file = full_path_to($log_file);
+
+				open(ERROR_LOG, ">$log_file");
+
+				$log_file =~ m/.+:(.+)/;
+				$recent_errors_file = full_path_to("$1.part");
+				$logging = 1;
+			}
+	}
+
+
+=head2 Stopping before it's too late - C<StopForErrors()>, C<DontStopForErrors()>
+
+When building a long list of projects, you decide whether to continue building subsequent projects when one fails.
+  By default, your build script will C<die> after the first project that generates an error while building.
+  Change this behavior with C<DontStopForErrors()>.
+  Re-enable it with C<StopForErrors()>.
+
+=cut
+
+sub StopForErrors()
+	{
+		$stop_on_1st_error = 1;
+		
+			# Can't stop for errors unless we notice them.
+			# Can't notice them unless we are logging.
+			# If the user didn't explicitly request logging, log to a temporary file.
+
+		if ( ! $recent_errors_file )
+			{
+				OpenErrorLog("${TMPDIR}BuildResults");
+			}
+	}
+
+sub DontStopForErrors()
+	{
+		$stop_on_1st_error = 0;		
+	}
+
+sub log_message($)
+	{
+		if ( $logging )
+			{
+				my ($message) = @_;
+				print ERROR_LOG $message;
+			}
+	}
+
+sub log_message_with_time($)
+	{
+		if ( $logging )
+			{
+				my ($message) = @_;
+				my $time_stamp = localtime();
+				log_message("$message ($time_stamp)\n");
+			}
+	}
+
+sub log_recent_errors($)
+	{
+		my ($project_name) = @_;
+		my $found_errors = 0;
+
+		if ( $logging )
+			{
+				open(RECENT_ERRORS, "<$recent_errors_file");
+
+				while( <RECENT_ERRORS> )
+					{
+						if ( /^Error/ || /^CouldnÕt find project file/ )
+							{
+								$found_errors = 1;
+							}
+						print ERROR_LOG $_;
+					}
+
+				close(RECENT_ERRORS);
+				unlink("$recent_errors_file");
+			}
+
+		if ( $stop_on_1st_error && $found_errors )
+			{
+				print ERROR_LOG "### Build failed.\n";
+				die "### Errors encountered building \"$project_name\".\n";
+			}
+	}
+
+sub build_project($$$)
+	{
+		my ($project_path, $target_name, $clean_build) = @_;
+		$project_path = full_path_to($project_path);
+
+		$project_path =~ m/.+:(.+)/;
+		my $project_name = $1;
+
+		log_message_with_time("### Building \"$project_path\"");
+
+			# Check that the given project exists
+		if (! -e $project_path)
+			{
+				print ERROR_LOG "### Build failed.\n";
+				die "### Can't find project file \"$project_path\".\n";
+			}
+		
+		print "Building \"$project_path\"\n";
+		
+		$had_errors =
+MacPerl::DoAppleScript(<<END_OF_APPLESCRIPT);
+	tell (load script file "$CodeWarriorLib") to BuildProject("$project_path", "$project_name", "$target_name", "$recent_errors_file", $clean_build)
+END_OF_APPLESCRIPT
+
+			# Append any errors to the globally accumulated log file
+		if ( $had_errors )
+			{
+				log_recent_errors($project_path);
+			}
+	}
+
+=head2 Getting CodeWarrior to build projects - C<BuildProject($project, $opt_target)>, C<BuildProjectClean($project, $opt_target)>
+
+C<BuildProject()> and C<BuildProjectClean()> are identical, except that the latter first removes object code.
+  In both, CodeWarrior opens the project if it wasn't already open; builds the given (or else current) target; and finally closes
+ the project, if it wasn't already open.
+
+=cut
+
+sub BuildProject($;$)
+	{
+		my ($project_path, $target_name) = @_;
+		build_project($project_path, $target_name, "false");
+	}
+
+sub BuildProjectClean($;$)
+	{
+		my ($project_path, $target_name) = @_;
+		build_project($project_path, $target_name, "true");
+	}
+
+
+=head2 Miscellaneous
+
+C<MakeAlias($old_file, $new_file)> functions like C<symlink()>, except with better argument defaulting and more explicit error messages.
+
+=cut
+
+sub MakeAlias($$)
+	{
+		my ($old_file, $new_file) = @_;
+
+			# if the directory to hold $new_file doesn't exist, create it
+		if ( ($new_file =~ m/(.+:)/) && !-d $1 )
+			{
+				mkpath($1);
+			}
+
+			# if a leaf name wasn't specified for $new_file, use the leaf from $old_file
+		if ( ($new_file =~ m/:$/) && ($old_file =~ m/.+:(.+)/) )
+			{
+				$new_file .= $1;
+			}
+
+		my $message = "Can't create a Finder alias (at \"$new_file\")\n for \"$old_file\";";
+		# die "$message symlink doesn't work on directories.\n" if -d $old_file;
+		die "$message because \"$old_file\" doesn't exist.\n" unless -e $old_file;
+
+		unlink $new_file;
+		# print "symlink(\"$old_file\", \"$new_file\");\n";
+		symlink($old_file, $new_file) || die "$message symlink returned an unexpected error.\n";
+	}
+	
+	
+=pod
+
+C<InstallFromManifest()>
+
+=cut
+
+sub InstallFromManifest($;$)
+	{
+		my ($manifest_file, $dest_dir) = @_;
+
+		$dest_dir ||= ":";
+
+		$manifest_file =~ m/(.+):/;
+		my $source_dir =  $1;
+
+		chop($dest_dir) if $dest_dir =~ m/:$/;
+
+		print "Doing manifest on \"$manifest_file\"\n" unless $QUIET;
+		
+		my $read = maniread(full_path_to($manifest_file));
+		foreach $file (keys %$read)
+			{
+				next unless $file;
+
+				$subdir = ":";
+				if ( $file =~ /:.+:/ )
+					{
+						$subdir = $&;
+					}
+
+				$file = ":$file" unless $file =~ m/^:/;
+				MakeAlias("$source_dir$file", "$dest_dir$subdir");
+			}
+	}
+
+
+
+1;
+
+=head1 AUTHORS
+
+Scott Collins <scc@netscape.com>, Simon Fraser <sfraser@netscape.com>
+
+=head1 SEE ALSO
+
+BuildMozillaDebug.pl (et al), BuildList.pm, CodeWarriorLib (an AppleScript library)
+
+=head1 COPYRIGHT
+
+The contents of this file are subject to the Netscape Public License
+Version 1.0 (the "NPL"); you may not use this file except in
+compliance with the NPL.  You may obtain a copy of the NPL at
+http://www.mozilla.org/NPL/
+
+Software distributed under the NPL is distributed on an "AS IS" basis,
+WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+for the specific language governing rights and limitations under the
+NPL.
+
+The Initial Developer of this code under the NPL is Netscape
+Communications Corporation.  Portions created by Netscape are
+Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+Reserved.
+
+=cut

mozilla/build/mac/NSCrossProductDefines.h

@@ -0,0 +1,38 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#define OLDROUTINELOCATIONS 0
+#define XP_MAC 1
+#ifndef NSPR20
+#define NSPR20 1
+#endif
+#define _NSPR 1
+#define _NO_FAST_STRING_INLINES_ 1
+#define HAVE_BOOLEAN 1
+#define NETSCAPE 1
+#define OTUNIXERRORS 1		/* We want OpenTransport error codes */
+
+/*
+	This compiles in heap dumping utilities and other good stuff
+ for developers -- maybe we only want it in for a special SDK
+ nspr/java runtime(?):
+*/
+#define DEVELOPER_DEBUG 1
+
+#define	MAX(_a,_b)	((_a) < (_b) ? (_b) : (_a))
+#define	MIN(_a,_b)	((_a) < (_b) ? (_a) : (_b))

mozilla/build/mac/export.mac

@@ -0,0 +1,5 @@
+#
+# This is a list of local files which get copied to the mozilla:dist directory
+#
+
+IDE_Options.h

mozilla/build/mac/makedist.xps

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+	The only job of this file is for make dependencies:
+	include files here that you want to cause MakeDist
+	to happen again when they change.
+*/
+
+
+#include "MacExportListPublic"

mozilla/build/mac/makedist.xps_Make

@@ -0,0 +1,76 @@
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+# This is the controlling script for a set of scripts that copy public
+# header files in one or more source trees into a single, "dist" directory.
+#
+# It relies on the two accompanying scripts, ÒCopyList.scriptÓ and
+# ÒCopyExports.scriptÓ, which must be in the same directory.
+# 
+# 
+# Known bugs:
+# 	Header files are always copied if the export.mac file contains
+#	non-local paths.
+#	Spurious output is produced even when verbose is off.
+#
+
+set echo 0
+
+Evaluate % = ("{{SourceFile}}" =~ /(Å:)¨0Å/)
+Directory "{{¨0}}"
+
+set mozillaDir "{¨0}"
+if `evaluate "{mozillaDir}" =~ /(Å:)¨1[Â:]+:[Â:]+:/`
+	set -e mozillaDir "{¨1}"
+else
+	echo "Failed to find mozilla directory. Exitting"
+	exit 1;
+end if
+
+# Sanity check for mozilla
+
+if !`exists -d "{mozillaDir}"`
+	echo "Failed to find mozilla directory. Exitting"
+	exit 1;
+end if
+
+# Calculate the root directory by stripping off the leaf name.
+
+(Evaluate "{mozillaDir}" =~ /(Å:)¨1([Â:]+)¨2:/)
+Set -e SourceRootDir "{¨1}"
+Set -e DestRootDir "{mozillaDir}dist:"
+
+# Ensure the build and stubs folders exist
+
+if !`exists -d "{mozillaDir}dist"`
+	newfolder "{mozillaDir}dist"
+end if
+if !`exists -d "{mozillaDir}dist:client"`
+	newfolder "{mozillaDir}dist:client"
+end if
+if !`exists -d "{mozillaDir}dist:client_debug"`
+	newfolder "{mozillaDir}dist:client_debug"
+end if
+if !`exists -d "{mozillaDir}dist:client_stubs"`
+	newfolder "{mozillaDir}dist:client_stubs"
+end if
+
+# Now do the grunt work of copying headers. This can take some time
+
+"{SourceRootDir}mozilla:build:mac:CopyExports.script" "mozilla:build:mac:MacExportListPublic"
+
+

mozilla/client.mak

@@ -1,246 +0,0 @@
-# The contents of this file are subject to the Netscape Public License
-# Version 1.0 (the "NPL"); you may not use this file except in
-# compliance with the NPL.  You may obtain a copy of the NPL at
-# http://www.mozilla.org/NPL/
-#
-# Software distributed under the NPL is distributed on an "AS IS" basis,
-# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
-# for the specific language governing rights and limitations under the
-# NPL.
-#
-# The Initial Developer of this code under the NPL is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
-# Reserved.
-
-#//------------------------------------------------------------------------
-#// Figure out how to do the pull.
-#//------------------------------------------------------------------------
-!if "$(MOZ_BRANCH)" != ""
-CVS_BRANCH=-r $(MOZ_BRANCH)
-HAVE_BRANCH=1
-!else
-HAVE_BRANCH=0
-!endif
-
-#//
-#// Temporary hardcode (while we figure out how to do this)
-#//	to support the Core modularity efforts...
-#//
-
-!ifndef MOZ_JAVAVER
-!ifdef MOZ_MEDIUM
-MOZ_JAVAVER    =-r JAVA_STUB_RELEASE_19980319
-!else
-MOZ_JAVAVER    =-r JAVA_RELEASE_19980304
-!endif
-!endif
-
-
-NSPR20_BRANCH  =-r NSPR20_RELEASE_19980304_BRANCH
-SECURITY_BRANCH=-r SECURITY_RELEASE_19980210
-CORECONF_BRANCH=-r CFG_1_6
-DBM_BRANCH     =-r DBM_RELEASE_19980319
-
-!if "$(MOZ_DATE)" != ""
-CVS_BRANCH=-D "$(MOZ_DATE)"
-HAVE_DATE=1
-!else
-HAVE_DATE=0
-!endif
-
-!if $(HAVE_DATE) && $(HAVE_BRANCH)
-ERR_MESSAGE=$(ERR_MESSAGE)^
-Cannot specify both MOZ_BRANCH and MOZ_DATE
-!endif
-
-NMAKE=@nmake -nologo -$(MAKEFLAGS)
-
-#//------------------------------------------------------------------------
-#//
-#// Stuff a do complete pull and build
-#//
-#//------------------------------------------------------------------------
-
-default:: 		build_all
-
-pull_and_build_all::     pull_all    \
-			    build_all
-
-#// Do this when you pull a new tree, or else you will often get bugs
-#// when replaceing an old dist with a new dist.
-
-pull_clobber_build_all:: pull_all \
-			clobber_all \
-			build_all
-
-clobber_build_all:: 	clobber_all \
-			build_all
-
-# In theory, we should use some symbol in ns/config/liteness.mak, 
-# but we haven't pulled the file yet.  So, refer to MOZ_LITE and
-# MOZ_MEDIUM explicitly .
-!if defined(MOZ_LITE) || defined(MOZ_MEDIUM)
-pull_all:: pull_client_source_product
-!else
-pull_all:: pull_client 
-!endif
-
-!ifndef NO_SECURITY
-pull_security:
-    -cvs -q co $(CORECONF_BRANCH) ns/coreconf
-    -cvs -q co $(SECURITY_BRANCH) CoreSecurity
-!else
-pull_security:
-!endif
-
-pull_client: pull_security
-    @echo +++ client.mak: checking out the client with "$(CVS_BRANCH)"
-    cd $(MOZ_SRC)\.
-    -cvs -q co $(DBM_BRANCH)      ns/dbm
-    -cvs -q co $(CVS_BRANCH)      Client50Win
-    -cvs -q co $(MOZ_JAVAVER)     JavaWin
-    -cvs -q co $(NSPR20_BRANCH)   CoreNSPR20
-
-pull_client_source_product:
-    @echo +++ client.mak: checking out the client with "$(CVS_BRANCH)"
-    cd $(MOZ_SRC)\.
-    -cvs -q co $(DBM_BRANCH)      ns/dbm
-    -cvs -q co $(CVS_BRANCH)      ClientSourceProductWin
-    -cvs -q co $(MOZ_JAVAVER)     JavaStubWin
-
-
-build_all:              build_ldap  \
-			build_dist  \
-			build_client
-build_dist:
-    @echo +++ client.mak: building dist
-    cd $(MOZ_SRC)\ns
-    $(NMAKE) -f makefile.win
-
-
-!if defined(MOZ_LITE) || defined(MOZ_MEDIUM)
-build_ldap:
-!else
-build_ldap:
-    @echo +++ client.mak: building ldap
-    cd $(MOZ_SRC)\ns\netsite\ldap\libraries\msdos\winsock
-    $(NMAKE) -f nsldap.mak DEPEND=1
-    $(NMAKE) -f nsldap.mak 
-    $(NMAKE) -f nsldap.mak EXPORT=1
-!endif
-
-
-build_client:
-    @echo +++ client.mak: building client
-    cd $(MOZ_SRC)\ns\cmd\winfe\mkfiles32
-!if "$(MOZ_BITS)" == "16"
-    $(NMAKE) -f mozilla.mak exports
-!endif
-    $(NMAKE) -f mozilla.mak DEPEND=1
-    $(NMAKE) -f mozilla.mak
-
-
-#
-# remove all source files from the tree and print a report of what was missed
-#
-clobber_all:
-    cd $(MOZ_SRC)\ns
-    $(NMAKE) -f makefile.win clobber_all
-    cd $(MOZ_SRC)\ns\cmd\winfe\mkfiles32
-    $(NMAKE) -f mozilla.mak clobber_all
-!if !defined(MOZ_MEDIUM)
-    cd $(MOZ_SRC)\ns\netsite\ldap\libraries\msdos\winsock
-    $(NMAKE) -f nsldap.mak clobber_all
-!endif
-
-depend:
-    -del /s /q make.dep
-    $(NMAKE) -f makefile.win depend 
-
-quick:
-    @cd $(MOZ_SRC)\.
-    @cvs -q co ns/quickup
-    @cd $(MOZ_SRC)\ns\quickup
-    @$(MOZ_TOOLS)\perl5\perl doupdate.pl
-
-#//------------------------------------------------------------------------
-#// Utility stuff...
-#//------------------------------------------------------------------------
-
-#//------------------------------------------------------------------------
-# Verify that MOZ_SRC is set correctly
-#//------------------------------------------------------------------------
-
-# Check to see if it is set at all
-!if "$(MOZ_SRC)"!=""
-
-#
-# create a temp file at the root and make sure it is visible from MOZ_SRC
-#
-!if [copy $(MAKEDIR)\client.mak $(MAKEDIR)\xyzzy.tmp > NUL] == 0
-!endif
-
-!if !EXIST( $(MOZ_SRC)\ns\xyzzy.tmp )
-ERR_MESSAGE=$(ERR_MESSAGE)^
-MOZ_SRC isn't set correctly: [$(MOZ_SRC)\ns]!=[$(MAKEDIR)]
-!endif
-
-!if [del $(MAKEDIR)\xyzzy.tmp]
-!endif
-
-!else
-# MOZ_SRC isn't set at all
-ERR_MESSAGE=$(ERR_MESSAGE)^
-Environment variable MOZ_SRC isn't set.
-!endif
-
-#//------------------------------------------------------------------------
-# Verify that MOZ_BITS is set
-#//------------------------------------------------------------------------
-!if !defined(MOZ_BITS)
-ERR_MESSAGE=$(ERR_MESSAGE)^
-Environment variable MOZ_BITS isn't set.
-!endif
-
-!if !defined(MOZ_TOOLS)
-ERR_MESSAGE=$(ERR_MESSAGE)^
-Environment variable MOZ_TOOLS isn't set.
-!endif
-
-
-#//------------------------------------------------------------------------
-#// Display error 
-#//------------------------------------------------------------------------
-
-
-!if "$(ERR_MESSAGE)" != ""
-ERR_MESSAGE = ^
-client.mak:  ^
-$(ERR_MESSAGE) ^
-^
-client.mak: usage^
-^
-nmake -f client.mak [MOZ_BRANCH=<cvs_branch_name>] ^
-		    [MOZ_DATE=<cvs_date>]^
-		    [pull_and_build_all]^
-		    [pull_all]^
-		    [pull_dist]^
-		    [pull_client]^
-		    [build_all]^
-		    [build_dist]^
-		    [build_ldap]^
-		    [build_client]^
-^
-Environment variables:^
-^
-MOZ_BITS    set to either 32 or 16 ^
-MOZ_SRC     set to the directory above ns or "$(MAKEDIR)\.."^
-MOZ_TOOLS   set to the directory containing the java compiler see ^
-		http://warp/tools/nt^
-JAVA_HOME   set to the same thing as MOZ_TOOLS^
-
-!ERROR $(ERR_MESSAGE)
-
-!endif
-

mozilla/cmd/macfe/Composer/CColorPopup.cp

@@ -0,0 +1,788 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ===========================================================================
+//	CColorPopup.cp
+// ===========================================================================
+
+#include "CColorPopup.h"
+#include "UGraphicGizmos.h"
+#include "UGraphicsUtilities.h"
+#include "CTargetedUpdateMenuRegistry.h"
+#include "CEditView.h"			// constant for menu string resource
+#include "edt.h"				// EDT calls
+#include "prefapi.h"
+#include "StSetBroadcasting.h"
+#include "CBrowserContext.h"	// MWContext
+
+
+// prototypes
+pascal void
+colorPopupMDEFProc( short message, MenuHandle theMenu, 
+					Rect *menuRect, Point hitPt, short *whichItem );
+
+// functionality
+
+static
+void
+colorPopupGetBox( Rect *menuRect, Rect *itemBox, short numItems, short theItem )
+{
+	Rect	box;
+
+	SetRect( itemBox, 0, 0, 0, 0 );
+	if ( theItem <= numItems )
+	{
+		if ( theItem == CColorPopup::CURRENT_COLOR_ITEM )
+		{
+			box.bottom = menuRect->bottom - CColorPopup::COLOR_FRAME_BORDER;
+			box.top = box.bottom - CColorPopup::COLOR_BOX_HEIGHT;
+			box.left = menuRect->left + CColorPopup::COLOR_FRAME_BORDER;
+			box.right = box.left + CColorPopup::COLOR_BOX_HEIGHT;
+		}
+		else if ( theItem == CColorPopup::DEFAULT_COLOR_ITEM )
+		{
+			box.bottom = menuRect->bottom - CColorPopup::COLOR_FRAME_BORDER 
+										- CColorPopup::COLOR_BOX_HEIGHT;
+			box.top = box.bottom - CColorPopup::COLOR_BOX_HEIGHT;
+			box.left = menuRect->left + CColorPopup::COLOR_FRAME_BORDER;
+			box.right = box.left + CColorPopup::COLOR_BOX_HEIGHT;
+		}
+		else if ( theItem == CColorPopup::LAST_COLOR_PICKED_ITEM )
+		{
+			box.top = menuRect->top + CColorPopup::COLOR_FRAME_BORDER;
+			box.bottom = box.top + CColorPopup::COLOR_BOX_HEIGHT;
+			box.left = menuRect->left + CColorPopup::COLOR_FRAME_BORDER;
+			box.right = box.left + CColorPopup::COLOR_BOX_HEIGHT;
+		}
+		else
+		{
+			box.top = menuRect->top /* + CColorPopup::COLOR_FRAME_BORDER */ + CColorPopup::COLOR_HEX_DISPLAY_SIZE;
+			box.left = menuRect->left + CColorPopup::COLOR_FRAME_BORDER;
+			box.bottom = box.top + CColorPopup::COLOR_BOX_HEIGHT;
+			box.right = box.left + CColorPopup::COLOR_BOX_WIDTH;
+
+			while ( --theItem > 1 )	// 1 is # menuItems preceding color chip matrix
+			{
+				OffsetRect( &box, CColorPopup::COLOR_BOX_WIDTH, 0 );
+				if ( box.left >= menuRect->right - CColorPopup::COLOR_FRAME_BORDER )
+				{
+					box.left = menuRect->left + CColorPopup::COLOR_FRAME_BORDER;
+					box.right = box.left + CColorPopup::COLOR_BOX_WIDTH;
+					OffsetRect( &box, 0, CColorPopup::COLOR_BOX_HEIGHT );
+				}
+			}
+		}
+		*itemBox = box;
+	}
+}
+
+
+static
+Boolean
+colorPopupParseColor( Str255 menuStr, RGBColor *theColor )
+{
+	Boolean			foundColorFlag = false;
+	unsigned short	part;
+	short			loop;
+
+	theColor->red = theColor->green = theColor->blue = 0;
+	for ( loop = 1; loop <= (unsigned)menuStr[ 0 ] - 6; ++loop )
+	{
+		if ( menuStr[0] > 1 
+		&& ( menuStr[ loop ] == CColorPopup::COLOR_CHIP_CHAR 
+		|| menuStr[ loop ] == CColorPopup::LAST_COLOR_PICKED_CHAR 
+		|| menuStr[ loop ] == CColorPopup::DEFAULT_COLOR_CHAR
+		|| menuStr[ loop ] == CColorPopup::CURRENT_COLOR_CHAR ) )
+		{
+		// Converting from ASCII to Hex
+		// This is BAD code...
+
+			part = menuStr[ loop + 1 ] - '0';
+			if ( part > 9 )
+				part = menuStr[ loop + 1 ] - 'A' + 10;
+			theColor->red = part << 4;
+			part = menuStr[ loop + 2 ] - '0';
+			if ( part > 9 )
+				part = menuStr[ loop + 2 ] - 'A' + 10;
+			theColor->red |= part;
+			theColor->red = theColor->red << 8;
+
+			part = menuStr[ loop + 3 ] - '0';
+			if ( part > 9 )
+				part = menuStr[ loop + 3 ] - 'A' + 10;
+			theColor->green = part << 4;
+			part = menuStr[ loop + 4 ] - '0';
+			if ( part > 9 )
+				part = menuStr[ loop + 4 ] - 'A' + 10;
+			theColor->green |= part;
+			theColor->green = theColor->green << 8;
+
+			part = menuStr[ loop + 5 ] - '0';
+			if ( part > 9 )
+				part = menuStr[ loop + 5 ] - 'A' + 10;
+			theColor->blue = part << 4;
+			part = menuStr[ loop + 6 ] - '0';
+			if ( part > 9 )
+				part = menuStr[ loop + 6 ] - 'A' + 10;
+			theColor->blue |= part;
+			theColor->blue = theColor->blue << 8;
+
+			foundColorFlag = true;
+			break;
+		}
+	}
+	
+	return foundColorFlag;
+}
+
+
+static
+void
+colorPopupDrawBox( MenuHandle theMenu, Rect *menuRect, short numItems )
+{
+	Boolean			wildcardFlag;
+	CIconHandle		cicnHandle;
+	RGBColor		theColor;
+	const RGBColor	black = {0,0,0}, white = {0xFFFF,0xFFFF,0xFFFF};
+	Rect			box;
+	Str255			menuStr;
+	short			theItem;
+
+	for ( theItem = 1; theItem <= numItems; ++theItem )
+	{
+		menuStr[ 0 ] = 0;
+		GetMenuItemText( theMenu, theItem, menuStr );
+		wildcardFlag = ((menuStr[0] == 0x01 && menuStr[1] == CColorPopup::COLOR_PICKER_CHAR)) ? true : false;
+		
+		colorPopupGetBox( menuRect, &box, numItems, theItem );
+
+		// text (if any)
+		int stringNum;
+		switch ( menuStr[1] )
+		{
+			default:									stringNum = 0;	break;
+			case CColorPopup::LAST_COLOR_PICKED_CHAR:	stringNum = 20;	break;
+			case CColorPopup::DEFAULT_COLOR_CHAR:		stringNum = 21;	break;
+			case CColorPopup::CURRENT_COLOR_CHAR:		stringNum = 22;	break;
+		}
+
+		if ( stringNum )
+		{
+			Point baseLinePoint;
+			baseLinePoint.v = box.top + CColorPopup::COLOR_BOX_HEIGHT - 4;
+			baseLinePoint.h = box.right + CColorPopup::COLOR_FRAME_BORDER;
+
+			Str255 menuItemStr;
+			menuItemStr[ 0 ] = 0;
+			::GetIndString( menuItemStr, CEditView::STRPOUND_EDITOR_MENUS, stringNum );
+			::RGBBackColor( &white );
+			::RGBForeColor( &black );
+			::MoveTo( baseLinePoint.h, baseLinePoint.v );
+			::DrawString( menuItemStr );
+		}
+
+		// draw color chip
+		if ( (true == wildcardFlag ) || (colorPopupParseColor( menuStr, &theColor ) == true))
+		{
+			::InsetRect( &box, 1, 1 );
+			::RGBForeColor( &black );
+			::MoveTo( box.left, box.bottom - 1 );
+			::LineTo( box.left, box.top );
+			::LineTo( box.right - 1, box.top );
+#ifdef THREE_D_EFFECT_ON_COLOR_POPUP
+			::RGBForeColor( &white );
+#endif
+			::LineTo( box.right - 1, box.bottom - 1 );
+			::LineTo( box.left, box.bottom - 1 );
+
+			if ( true == wildcardFlag )
+			{
+				RGBForeColor( &black );
+				if ( (cicnHandle = GetCIcon(11685)) != NULL )
+				{
+					// don't scale, plot into same size rect
+					Rect	r = (**cicnHandle).iconPMap.bounds;
+					box.bottom = box.top + r.bottom - r.top;
+					box.right = box.left + r.right - r.left;
+
+					::PlotCIcon( &box, cicnHandle );
+					::DisposeCIcon( cicnHandle );
+				}
+			}
+			else
+			{
+				InsetRect( &box, 1, 1 );
+				RGBForeColor( &theColor );
+				PaintRect( &box );
+
+				::RGBForeColor( &black );
+				box.left += ( box.right-box.left ) / 2;
+				box.right = box.left;
+				box.top += ( box.bottom - box.top ) / 2;
+				box.bottom = box.top;
+				InsetRect( &box, -4, -4 );
+				}
+			}
+		}
+}
+
+
+static
+void
+colorPopupChooseColor( Rect *menuRect, Point hitPt,
+						short *whichItem, short numItems, RGBColor *backColor )
+{
+	RGBColor	aColor;
+	Rect		box, oldBox;
+	short		newItem = 0, loop;
+
+	colorPopupGetBox( menuRect, &oldBox, numItems, *whichItem );
+
+	if ( PtInRect( hitPt, menuRect ) )
+	{
+		for ( loop = 1; loop <= numItems; loop++ )
+		{
+			colorPopupGetBox( menuRect, &box, numItems, loop );
+			if ( PtInRect( hitPt, &box ) )
+			{
+				newItem = loop;
+				break;
+			}
+		}
+	
+		if ( *whichItem != newItem )
+		{
+			// deselect old menu item, select new menu item
+			
+			if ( *whichItem > 0 )
+			{
+				RGBForeColor( backColor );
+				FrameRect( &oldBox );
+			}
+			if ( newItem > 0 )
+			{
+				aColor.red = aColor.blue = aColor.green = 0;
+				RGBForeColor( &aColor );
+				FrameRect( &box );
+			}
+
+#if COLOR_DISPLAY_TEXT
+			box = *menuRect;
+			box.top = box.bottom - COLOR_HEX_DISPLAY_SIZE;
+			EraseRect( &box );
+			if ( newItem > 0 )
+			{
+				menuStr[ 0 ] = 0;
+				GetMenuItemText( theMenu, newItem, menuStr );
+				if ( colorPopupParseColor( menuStr, &aColor ) == true )
+				{
+					if ( menuStr[ 0 ] )
+					{
+						// XXX should save/restore current font info, and set a particular (system?) font
+					
+						MoveTo( box.left + ((box.right-box.left) / 2) - ( ::StringWidth(menuStr) / 2), 
+								box.bottom - 4);
+						DrawString( menuStr );
+					}
+				}
+			}
+#endif
+			*whichItem = newItem;
+		}
+	}
+	else if ( *whichItem > 0 )
+	{
+		// deselect old menu item
+
+		RGBForeColor( backColor );
+		FrameRect( &oldBox );
+#if COLOR_DISPLAY_TEXT
+		box = *menuRect;
+		box.top = box.bottom - COLOR_HEX_DISPLAY_SIZE;
+		EraseRect( &box );
+#endif
+		*whichItem = 0;	// clear old item
+	}
+}
+
+
+pascal void
+colorPopupMDEFProc(short message, MenuHandle theMenu, 
+		Rect *menuRect, Point hitPt, short *whichItem)
+{
+	if ( theMenu == NULL )
+		return;
+	
+	PenState	pnState;
+	RGBColor	foreColor, backColor;
+#if 0
+	Boolean		growRowsFlag = false;
+#endif
+	short		numItems, numCols, numRows;
+
+	numItems = ::CountMItems( theMenu );
+	::GetPenState( &pnState );
+	::GetForeColor( &foreColor );
+	::PenNormal();
+	
+	switch( message )
+	{
+		case mDrawMsg:
+			colorPopupDrawBox( theMenu, menuRect, numItems );
+			break;
+
+		case mChooseMsg:
+			::GetBackColor( &backColor );
+			colorPopupChooseColor( menuRect, hitPt, whichItem, numItems, &backColor );
+			::RGBBackColor( &backColor );
+			break;
+
+		case mSizeMsg:
+
+		// determine # of rows/cols needed
+
+#if 0
+			if ( numItems > 0 )
+			{
+				numRows = numCols = 1;
+				while( numItems > (numRows * numCols) )
+				{
+					if ( growRowsFlag )
+						++numRows;
+					else
+						++numCols;
+					
+					growRowsFlag = (!growRowsFlag);
+				}
+			}
+#endif			
+#if 1
+			// hard code these for now
+			numRows = 10;
+			numCols = 10;
+#endif
+			// why are the width and height backwards?  If they are switched, the menu is wrong shape
+			(**theMenu).menuHeight = (numRows * CColorPopup::COLOR_BOX_HEIGHT) + (2 * CColorPopup::COLOR_FRAME_BORDER);
+			(**theMenu).menuWidth = (numCols * CColorPopup::COLOR_BOX_WIDTH) + CColorPopup::COLOR_FRAME_BORDER;
+	#if COLOR_DISPLAY_TEXT
+			(**theMenu).menuWidth += CColorPopup::COLOR_HEX_DISPLAY_SIZE;
+	#endif
+			break;
+
+		case mPopUpMsg:
+			::SetRect( menuRect, hitPt.v, hitPt.h, 
+						hitPt.v + (**theMenu).menuWidth, hitPt.h + (**theMenu).menuHeight );
+			break;
+/*
+		case	mDrawItemMsg:
+		break;
+
+		case	mCalcItemMsg:
+		break;
+*/
+		}
+
+	::RGBForeColor( &foreColor );
+	SetPenState( &pnState );
+}
+
+
+// This class overrides CPatternButtonPopup to provide a popup menu which
+// changes the descriptor based on the menu selection
+// assumes left-justified text in DrawButtonTitle()
+
+
+// ---------------------------------------------------------------------------
+//		¥ CColorPopup
+// ---------------------------------------------------------------------------
+// Stream-based ctor
+
+CColorPopup::CColorPopup(LStream* inStream)
+							:	CPatternButtonPopupText(inStream)
+{
+}
+
+
+void CColorPopup::FinishCreateSelf()
+{
+	LView *superview = NULL, *view = GetSuperView();
+	while ( view )
+	{
+		view = view->GetSuperView();
+		if ( view )
+			superview = view;
+	}
+
+	mEditView = (CEditView *)superview->FindPaneByID( CEditView::pane_ID );
+	mDoSetLastPickedPreference = false;
+
+	// need to Finish FinishCreateSelf to get menus set for retrieval
+	super::FinishCreateSelf();
+	
+	// set the control by adjusting the menu and then getting the current color
+	// unfortunately, when this is called, the editView doesn't have an mwcontext
+	// so we can't query to find out what the current color is to set it properly
+}
+
+
+void
+CColorPopup::InitializeCurrentColor()
+{
+	MenuHandle menuh;
+	menuh = GetMenu()->GetMacMenuH();
+	
+	MWContext *mwcontext;
+	if ( mEditView )
+		mwcontext = mEditView->GetNSContext() 
+						? mEditView->GetNSContext()->operator MWContext*()
+						: NULL;
+	else
+		mwcontext = NULL;
+	
+	char colorstr[9];
+	LO_Color color;
+	Boolean isColorFound = false;
+	
+	// first try to get the color out of the character data
+	EDT_CharacterData* chardata;
+	chardata = EDT_GetCharacterData( mwcontext );
+	if ( chardata && chardata->pColor )
+	{
+		isColorFound = true;
+		color = *chardata->pColor;
+		XP_SPRINTF( &colorstr[2], "%02X%02X%02X", color.red, color.green, color.blue);
+	}
+	if ( chardata )
+		EDT_FreeCharacterData( chardata );
+	
+	// if we still haven't found it, let's try the page data
+	if ( !isColorFound )
+	{
+		EDT_PageData *pagedata = EDT_GetPageData( mwcontext );
+		if ( pagedata && pagedata->pColorText )
+		{
+			isColorFound = true;
+			color = *pagedata->pColorText;
+			XP_SPRINTF( &colorstr[2], "%02X%02X%02X", color.red, color.green, color.blue);
+		}
+		if ( pagedata )
+			EDT_FreePageData( pagedata );
+	}
+	
+	// if we still haven't found the color, get the browser preference
+	if ( !isColorFound )
+	{
+		// editor.text_color
+		int iSize = 9;
+		int result = PREF_GetCharPref( "browser.foreground_color", &colorstr[1], &iSize );
+		if ( result != PREF_NOERROR )
+			colorstr[1] = 0;	// zero string if error is encountered
+	}
+	
+	colorstr[1] = CURRENT_COLOR_CHAR;	// put in leading character
+	colorstr[0] = strlen( &colorstr[1] );
+	::SetMenuItemText( menuh, CURRENT_COLOR_ITEM, (unsigned char *)&colorstr );
+	
+	// set descriptor of control
+	if ( GetValue() == CURRENT_COLOR_ITEM )
+	{
+		SetDescriptor( (const unsigned char *)colorstr );
+		Refresh();	// inval the control's visible pane area
+	}
+}
+
+
+// ---------------------------------------------------------------------------
+//		¥ AdjustMenuContents
+// ---------------------------------------------------------------------------
+//	Set last color picked (first item).
+
+void
+CColorPopup::AdjustMenuContents()
+{
+	MenuHandle menuh;
+	menuh = GetMenu()->GetMacMenuH();
+	
+	// initialize last color picked
+	char colorstr[9];
+	int iSize = 9;
+	int result;
+	
+	// note hack to avoid converting c-string to p-string
+	result = PREF_GetCharPref( "editor.last_color_used", &colorstr[1], &iSize );
+	if ( result == PREF_NOERROR )
+	{
+		colorstr[1] = LAST_COLOR_PICKED_CHAR;	// replace '#' with '<'
+		colorstr[0] = strlen( &colorstr[1] );
+		::SetMenuItemText( menuh, LAST_COLOR_PICKED_ITEM, (unsigned char *)&colorstr );
+	}
+	
+	// initialize the default color
+	result = PREF_GetCharPref( "browser.foreground_color", &colorstr[1], &iSize );
+	if ( result == PREF_NOERROR )
+	{
+		colorstr[1] = DEFAULT_COLOR_CHAR;	// replace '#' with '<'
+		colorstr[0] = strlen( &colorstr[1] );
+		::SetMenuItemText( menuh, DEFAULT_COLOR_ITEM, (unsigned char *)&colorstr );
+	}
+	
+	// initialize the current color
+	InitializeCurrentColor();
+}
+
+
+void CColorPopup::HandlePopupMenuSelect( Point inPopupLoc, Int16 inCurrentItem, 
+										Int16& outMenuID, Int16& outMenuItem )
+{
+	super::HandlePopupMenuSelect( inPopupLoc, inCurrentItem, outMenuID, outMenuItem );
+	
+	// check if we need to set the preference here...
+	mDoSetLastPickedPreference = ( outMenuID && outMenuItem != DEFAULT_COLOR_ITEM );
+}
+
+
+void CColorPopup::SetValue(Int32 inValue)
+{
+	if ( inValue == 0 )
+		inValue = CURRENT_COLOR_ITEM;
+	
+	Boolean shouldBroadcast;
+	// Handle color picker item special
+	if ( inValue == COLOR_PICKER_ITEM )
+	{
+		mValue = inValue;			//  Store new value to broadcast it
+		BroadcastValueMessage();	//  Inform Listeners of value change
+
+		inValue = CURRENT_COLOR_ITEM;	//	Reset value to current color
+		shouldBroadcast = false;	//	Already broadcast above; don't do again
+	}
+	else
+		shouldBroadcast = IsBroadcasting();
+	
+	// broadcast only if it's not a color picker item (handled above)
+	StSetBroadcasting setBroadcasting( this, shouldBroadcast );
+	super::SetValue( inValue );
+}
+
+
+// ---------------------------------------------------------------------------
+//		¥ HandleNewValue
+// ---------------------------------------------------------------------------
+//	Hook for handling value changes. Called by SetValue.
+//	Note that the setting of the new value is done by CPatternButtonPopup::SetValue.
+//  Therefore, GetValue() will still return the old value here, so the old value is
+//	still available in this method.
+
+Boolean
+CColorPopup::HandleNewValue(Int32 inNewValue)
+{
+	Str255	str;
+	MenuHandle menuh;
+	menuh = GetMenu()->GetMacMenuH();
+	::GetMenuItemText ( menuh, inNewValue, str );
+
+	if ( str[1] != COLOR_PICKER_CHAR )
+		SetDescriptor( str );
+
+	if ( mDoSetLastPickedPreference 
+	&& str[1] != LAST_COLOR_PICKED_CHAR && str[1] != COLOR_PICKER_CHAR )
+	{
+		mDoSetLastPickedPreference = false;
+
+		// skip over any text which might preceed color
+		int index;
+		for ( index = 1; index <= str[0]
+			&& str[index] != LAST_COLOR_PICKED_CHAR
+			&& str[index] != COLOR_CHIP_CHAR
+			&& str[index] != COLOR_PICKER_CHAR
+			&& str[index] != DEFAULT_COLOR_CHAR
+			&& str[index] != CURRENT_COLOR_CHAR; ++index )
+			;
+		
+		if ( index + 7 < str[0] )
+			str[index + 7] = 0;	// null terminate after symbol + 6chars of color
+		
+		str[ index ] = COLOR_CHIP_CHAR;	// prefs assume #-format color
+		p2cstr( str );
+		int result;
+		result = PREF_SetCharPref( "editor.last_color_used", (char *)&str[index-1] );
+														// skip past initial symbol; index-1 since now c-string
+	}
+	
+	return false;
+}
+
+
+const Int16 cPopupArrowHeight	= 	5;		// height of the arrow
+const Int16 cPopupArrowWidth	= 	9;		// widest width of the arrow
+
+
+void
+CColorPopup::DrawButtonContent(void)
+{
+	CPatternButtonPopupText::DrawButtonContent();
+	DrawPopupArrow();
+}
+
+
+void
+CColorPopup::DrawButtonTitle(void)
+{
+}
+
+
+void
+CColorPopup::DrawButtonGraphic(void)
+{
+	ResIDT		theSaveID = GetGraphicID();
+	ResIDT		theNewID = theSaveID;
+	RGBColor	foreColor, theColor;
+	const RGBColor	black={0,0,0};
+
+	Int32 theValue = GetValue();
+	if (theValue > 0)
+	{
+		if ( theValue == COLOR_PICKER_ITEM )
+			theValue = CURRENT_COLOR_ITEM;
+		
+		if (GetMenuItemRGBColor((short)theValue, &theColor) == true)
+		{
+			CButton::CalcGraphicFrame();
+			InsetRect(&mCachedGraphicFrame, (mCachedGraphicFrame.right-mCachedGraphicFrame.left-12)/2,
+				(mCachedGraphicFrame.bottom-mCachedGraphicFrame.top-12)/2);
+			
+			::GetForeColor(&foreColor);
+
+			::RGBForeColor(&black);
+			::FrameRect(&mCachedGraphicFrame);
+			::RGBForeColor(&foreColor);
+
+			::InsetRect(&mCachedGraphicFrame,1,1);
+			::RGBForeColor(&theColor);
+			::PaintRect(&mCachedGraphicFrame);
+		}
+		else
+			theValue = CURRENT_COLOR_ITEM;	// not sure this is the right thing; 
+											// it'd be nice if GetMenuItemRGBColor always returned true
+	}
+}
+
+
+void
+CColorPopup::DrawPopupArrow(void)
+{
+	Rect theFrame;
+	
+	CalcLocalFrameRect(theFrame);
+	
+	Int16 width = theFrame.right - theFrame.left;
+	Int16 height = theFrame.bottom - theFrame.top;
+	theFrame.top += ((height - cPopupArrowHeight) / 2);
+	theFrame.left = theFrame.right - cPopupArrowWidth - 7;
+	theFrame.right = theFrame.left + cPopupArrowWidth - 1;
+	theFrame.bottom = theFrame.top + cPopupArrowHeight - 1;
+
+	// check if we have moved past the right edge of the button
+	// if so, adjust it back to the right edge of the button
+	if ( theFrame.right > mCachedButtonFrame.right - 4 )
+	{
+		theFrame.right = mCachedButtonFrame.right - 4;
+		theFrame.left = theFrame.right - cPopupArrowWidth - 1;
+	}
+
+	UGraphicGizmos::DrawPopupArrow(
+									theFrame,
+									IsEnabled(),
+									IsActive(),
+									IsTrackInside());
+}
+
+
+#pragma mark -
+
+// always call ProcessCommandStatus for popup menus which can change values
+void
+CColorPopup::HandleEnablingPolicy()
+{
+	LCommander* theTarget		= LCommander::GetTarget();
+	MessageT	buttonCommand	= GetValueMessage();
+	Boolean 	enabled			= false;
+	Boolean		usesMark		= false;
+	Str255		outName;
+	Char16		outMark;
+	
+	if (!CTargetedUpdateMenuRegistry::UseRegistryToUpdateMenus() ||
+			CTargetedUpdateMenuRegistry::CommandInRegistry(buttonCommand))
+	{
+		if (!IsActive() || !IsVisible())
+			return;
+			
+		if (!theTarget)
+			return;
+		
+		CPatternButtonPopup::HandleEnablingPolicy();
+		
+		if (buttonCommand)
+			theTarget->ProcessCommandStatus(buttonCommand, enabled, usesMark, outMark, outName);
+	}
+	CPatternButtonPopup::Enable();
+}
+
+
+
+Boolean
+CColorPopup::GetMenuItemRGBColor(short menuItem, RGBColor *theColor)
+{
+	Str255		str;
+	MenuHandle	menuh;
+	Boolean		colorFoundFlag;
+
+	menuh = GetMenu()->GetMacMenuH();
+	::GetMenuItemText( menuh, menuItem, str );
+	colorFoundFlag = colorPopupParseColor( str, theColor );
+	return colorFoundFlag;
+}
+
+
+
+short
+CColorPopup::GetMenuItemFromRGBColor(RGBColor *theColor)
+{
+	MenuHandle	menuh;
+	RGBColor	tempColor;
+	Str255		str;
+	short		loop,numItems,retVal=CURRENT_COLOR_ITEM; // return current color if not found
+
+	if ((menuh = GetMenu()->GetMacMenuH()) != NULL)
+	{
+		numItems = ::CountMItems(menuh);
+		for (loop=1; loop<= numItems; loop++)
+		{
+			::GetMenuItemText( menuh, loop, str);
+			if (colorPopupParseColor(str, &tempColor) == true)
+			{
+				if ((tempColor.red == theColor->red) && (tempColor.blue == theColor->blue) && (tempColor.green == theColor->green))
+				{
+					retVal = loop;
+					break;
+				}
+			}
+		}
+	}
+	return retVal;
+}

mozilla/cmd/macfe/Composer/CColorPopup.h

@@ -0,0 +1,74 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "CPatternButtonPopupText.h"
+
+class CEditView;
+
+
+class CColorPopup : 	public CPatternButtonPopupText
+{
+	public:
+		enum { class_ID = 'Cpop' };
+		enum { COLOR_DISPLAY_TEXT = 0,	// need to fix "*" bug before turning on (among other things)
+		 		COLOR_FRAME_BORDER = 2,
+				COLOR_BOX_WIDTH = 14,
+				COLOR_BOX_HEIGHT = 14,
+				COLOR_HEX_DISPLAY_SIZE = 16
+		 	};
+		 enum {
+		 		LAST_COLOR_PICKED_CHAR = '<',
+		 		LAST_COLOR_PICKED_ITEM = 1,
+		 		COLOR_CHIP_CHAR = '#',
+		 		COLOR_PICKER_CHAR = '*',
+		 		COLOR_PICKER_ITEM = 62,
+		 		DEFAULT_COLOR_CHAR = '@',
+		 		DEFAULT_COLOR_ITEM = 72,
+		 		CURRENT_COLOR_CHAR = '.',
+		 		CURRENT_COLOR_ITEM = 73
+		 	};
+
+	typedef CPatternButtonPopupText super;
+	
+		
+	static	void*	CreateCColorPopupStream( LStream *inStream ) {return( new CColorPopup (inStream ));};
+					CColorPopup( LStream *inStream );		//	¥ Constructor
+	virtual void	FinishCreateSelf();
+	
+						// ¥ drawing
+	void			DrawButtonContent(void);
+	void 			DrawButtonTitle(void);
+	void			DrawPopupArrow(void);
+	void			DrawButtonGraphic(void);
+
+						// ¥ hooks
+	virtual void 		SetValue( Int32 inValue );
+	virtual void		AdjustMenuContents();
+	virtual	void		HandlePopupMenuSelect( Point inPopupLoc, Int16 inCurrentItem,
+												Int16& outMenuID, Int16& outMenuItem );
+	virtual Boolean		HandleNewValue(Int32 inNewValue);
+	virtual Boolean		GetMenuItemRGBColor(short menuItem, RGBColor *theColor);
+	virtual short		GetMenuItemFromRGBColor(RGBColor *theColor);
+	
+	void			InitializeCurrentColor();
+
+protected:
+	virtual void		HandleEnablingPolicy();
+	CEditView			*mEditView;
+	Boolean				mDoSetLastPickedPreference;
+};

mozilla/cmd/macfe/Composer/CComposerDragTask.cp

@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ===========================================================================
+//	CComposerDragTask.cp
+// ===========================================================================
+
+
+#include "CComposerDragTask.h"
+
+
+// ---------------------------------------------------------------------------
+//		¥ CComposerDragTask
+// ---------------------------------------------------------------------------
+
+CComposerDragTask::CComposerDragTask(
+	const EventRecord&	inEventRecord,
+	const Rect& 		inGlobalFrame,
+	CHTMLView& 			inHTMLView)
+	:	mGlobalFrame(inGlobalFrame),
+		mHTMLView(inHTMLView),
+		super(inEventRecord)
+{
+}	
+
+
+// ---------------------------------------------------------------------------
+//		¥ ~CComposerDragTask
+// ---------------------------------------------------------------------------
+											
+CComposerDragTask::~CComposerDragTask()
+{
+}	
+
+
+// ---------------------------------------------------------------------------
+//		¥ AddFlavors
+// ---------------------------------------------------------------------------
+
+void
+CComposerDragTask::AddFlavors( DragReference /* inDragRef */ )
+{
+	OSErr theErr;
+	
+	theErr = ::AddDragItemFlavor( mDragRef, (ItemReference)this, emComposerNativeDrag,
+									nil, 0, flavorNotSaved | flavorSenderTranslated );
+	ThrowIfOSErr_(theErr);
+}
+
+
+void
+CComposerDragTask::MakeDragRegion( DragReference /* inDragRef */, RgnHandle /* inDragRegion */ )
+{
+	AddRectDragItem((ItemReference)&mHTMLView, mGlobalFrame);
+}
+				

mozilla/cmd/macfe/Composer/CComposerDragTask.h

@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ===========================================================================
+//	CComposerDragTask.h
+// ===========================================================================
+
+#ifndef CComposerDragTask_H
+#define CComposerDragTask_H
+#pragma once
+
+// Includes
+
+#include <LDragTask.h>
+
+class CHTMLView;
+
+#define emComposerNativeDrag 'CNDr'	// others defined in "resgui.h"
+
+// Class declaration
+
+class CComposerDragTask : public LDragTask
+{
+public:
+	typedef LDragTask super;
+	
+							CComposerDragTask( const EventRecord& inEventRecord,
+											const Rect& inGlobalFrame, CHTMLView& inHTMLView );
+	virtual	 				~CComposerDragTask();
+						
+protected:
+	virtual void			AddFlavors( DragReference inDragRef );
+	virtual void		 	MakeDragRegion( DragReference inDragRef, RgnHandle inDragRegion );
+
+
+	Rect			mGlobalFrame;
+	CHTMLView&		mHTMLView;
+};
+
+
+#endif

mozilla/cmd/macfe/Composer/CEditDictionary.cp

@@ -0,0 +1,320 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "CEditDictionary.h"
+#include "CLargeEditField.h"	// msg_EditField2
+#include "LGAPushButton.h"
+#include "resgui.h"				// msg_Help
+#include "macutil.h"			// ShowHelp
+#include "CSpellChecker.h"		// ISpellChecker
+
+// need to include "ntypes.h" before "xp_help.h" because 
+// "xp_help.h" doesn't include definition of MWContext though it should
+#include "ntypes.h"
+#include "xp_help.h"			// HELP_SPELL_CHECK
+
+// If user has changed the word field, figure out the length and enable/disable appropriately
+void		CEditDictionary::ListenToMessage	(	MessageT inMessage, 
+														void*		ioParam )	{
+														
+	Assert_(mWordNameField);
+	Assert_(mAddButton);
+	
+	// This happens when user types
+	if (inMessage == msg_EditField2) {
+		if ((**(mWordNameField->GetMacTEH())).teLength) {
+			mAddButton->Enable();
+		} else {
+			mAddButton->Disable();
+		}
+	
+	// User clicked in words table	
+	} else if (inMessage == WordsTableID) {
+	
+		Boolean atleastoneselected = false;
+		// Must have at least one cell selected for remove to be valid
+		STableCell selchecker(0,0);
+		if (mWordsView->GetNextSelectedCell(selchecker)) {
+			atleastoneselected = true;
+			mRemoveButton->Enable();
+		} else {
+			mRemoveButton->Disable();
+		}
+		// Replace is enabled if there is a valid word in New Word Edit Field
+		// And exactly one word is selected
+		if ((**(mWordNameField->GetMacTEH())).teLength && atleastoneselected &&
+		 !mWordsView->GetNextSelectedCell(selchecker) ) {
+			mReplaceButton->Enable();
+		} else {
+			mReplaceButton->Disable();
+		}
+	
+	// User left words table
+	} else if (inMessage == msg_LeaveDictionaryTable) {
+		mRemoveButton->Disable();
+		mReplaceButton->Disable();
+	
+	// If user clicks on Remove Button
+	} else if (inMessage == RemoveButtonID) {
+		RemoveSelectedWords();
+	
+	// If user clicks on Replace Button
+	} else if (inMessage == ReplaceButtonID) {
+		ReplaceSelectedWord();
+		
+	// If user clicks on OK Button
+	}	else if (inMessage == msg_OK) {
+		MakeDictionaryChangesPermanent();
+		AttemptClose();
+		
+	// If user clicks on Cancel Button
+	} else if (inMessage == msg_Cancel) {
+		AttemptClose();
+	
+	// User clicks on Help Button	
+	} else if (inMessage == msg_Help) {
+		ShowHelp(HELP_SPELL_CHECK);
+		
+	// This is the case when something important happens (selection, deselection, etc.)
+	// to the New Word edit field.  Check status of word
+	} else if (inMessage == WordID) {
+		if ((**(mWordNameField->GetMacTEH())).teLength) {
+			mAddButton->Enable();
+		} else {
+			mAddButton->Disable();
+		}
+		
+	// Add word to dictionary	
+	} else if (inMessage == AddButtonID) {
+		AddNewWord();
+	} else {
+		LGADialogBox::ListenToMessage(inMessage, ioParam);
+	}			
+	
+}
+
+//-------------------------------------------------------------------------------------
+// CEditDictionary::MakeDictionaryChangesPermanent
+// Take words in view and set in dictionary
+//-------------------------------------------------------------------------------------
+void CEditDictionary::MakeDictionaryChangesPermanent() {
+
+	STableCell 	currCellLoc(1,1);
+	Str255			currCellData;
+	int					maxsize = 255;
+	
+	mISpellChecker->ResetPersonalDictionary();
+	for (currCellLoc.row = 1; currCellLoc.row <= mNumWords; currCellLoc.row++) {
+		maxsize = 255;
+		mWordsView->GetCellData(currCellLoc, currCellData, maxsize);
+		mISpellChecker->AddWordToPersonalDictionary(p2cstr(currCellData));
+	}
+}
+
+
+//-------------------------------------------------------------------------------------
+// CEditDictionary::RemoveSelectedWord
+// Remove words that are currently selected
+//-------------------------------------------------------------------------------------
+void  CEditDictionary::RemoveSelectedWords() {
+
+	STableCell currCellLoc(0,0);
+	int rowstodelete = 0;
+		
+	while (mWordsView->GetNextSelectedCell(currCellLoc)) {
+		rowstodelete++;
+	}
+	currCellLoc = mWordsView->GetFirstSelectedCell();
+	mWordsView->RemoveRows(rowstodelete, currCellLoc.row, true);
+	mNumWords-=rowstodelete;
+}
+
+//-------------------------------------------------------------------------------------
+// CEditDictionary::ReplaceSelectedWord
+// Remove currently selected word with word in New Word box
+//-------------------------------------------------------------------------------------
+void  CEditDictionary::ReplaceSelectedWord() {
+
+	STableCell currCellLoc;
+	Str255 theWord;
+	
+	mWordNameField->GetDescriptor(theWord);
+	currCellLoc = mWordsView->GetFirstSelectedCell();
+	if (mWordsView->IsValidCell(currCellLoc)) {
+		mWordsView->SetCellData(currCellLoc, theWord, theWord[0] + 1);
+		mWordsView->RefreshCell(currCellLoc);
+	}
+}
+
+
+//-------------------------------------------------------------------------------------
+// CEditDictionary::AddNewWord
+// Add the word in "New Word" edit field to personal dictionary
+//-------------------------------------------------------------------------------------
+void  CEditDictionary::AddNewWord()	{
+
+	Str255 theWord;
+	Str255 currWord;
+	Assert_(mWordNameField);
+	Assert_(mISpellChecker);
+	
+	STableCell cell(1,1);
+	Uint32 maxbytes;
+
+	mWordNameField->GetDescriptor(theWord);
+	
+	/*
+	Check to make sure word is not already in the list.  If it is, then highlight that word
+	and return so we don't insert.
+	*/
+	for (cell.row = 1; cell.row <= mNumWords; cell.row++) {
+		maxbytes = 255;
+		mWordsView->GetCellData(cell, currWord, maxbytes);
+		if (currWord[0] == theWord[0] && 
+		 !strncmp(reinterpret_cast<const char *>(&(currWord[1])), reinterpret_cast<const char *>(&(theWord[1])), theWord[0]) ) {		// If word already exists exit
+				mWordsView->UnselectAllCells();
+				mWordsView->SelectCell(cell);
+				return;
+		}
+	}
+	
+	mWordsView->InsertRows(1, mNumWords, theWord, theWord[0] + 1, Refresh_Yes);
+	mNumWords++;
+	cell.row = mNumWords;
+	mWordsView->UnselectAllCells();
+	mWordsView->SelectCell(cell);
+}
+
+
+//-------------------------------------------------------------------------------------
+// CEditDictionary::FinishCreateSelf
+// Setup object references
+//-------------------------------------------------------------------------------------
+void	CEditDictionary::FinishCreateSelf ()	{
+
+	mAddButton = dynamic_cast<LGAPushButton *>(FindPaneByID(AddButtonID));
+	mReplaceButton = dynamic_cast<LGAPushButton *>(FindPaneByID(ReplaceButtonID));
+	mRemoveButton = dynamic_cast<LGAPushButton *>(FindPaneByID(RemoveButtonID));
+	mHelpButton = dynamic_cast<LGAPushButton *>(FindPaneByID(HelpButtonID));
+	mWordNameField = dynamic_cast<CLargeEditFieldBroadcast *>(FindPaneByID(WordID));
+	mWordsView = dynamic_cast<CTextTable *>(FindPaneByID( WordsTableID ));
+	
+	ThrowIfNil_(mAddButton);
+	ThrowIfNil_(mReplaceButton);
+	ThrowIfNil_(mRemoveButton);
+	ThrowIfNil_(mHelpButton);
+	ThrowIfNil_(mWordNameField);
+	ThrowIfNil_(mWordsView);
+		
+	LGADialogBox::FinishCreateSelf();
+
+	PenState penState;
+	::GetPenState( &penState );
+	mWordsView->AddAttachment( new LColorEraseAttachment( &penState, NULL, NULL, true ) );
+	mAddButton->Disable();		// Add button should be originally disabled
+	mReplaceButton->Disable();
+	mRemoveButton->Disable();
+	
+	mAddButton->AddListener( this );
+	mReplaceButton->AddListener( this );
+	mRemoveButton->AddListener( this );
+	mWordNameField->AddListener( this );
+	mWordsView->AddListener( this );
+	mHelpButton->AddListener( this );
+}
+
+// Constructor
+
+CEditDictionary::CEditDictionary(LStream *inStream)	: mNumWords(0), 
+		mWordNameField(NULL), mISpellChecker(NULL), mAddButton(NULL), mWordsView(NULL), 
+		mHelpButton(NULL), LGADialogBox (inStream) {
+
+}
+
+//-------------------------------------------------------------------------------------
+// CEditDictionary::SetISPellChecker
+// Sets personal dictionary and inserts into GUI
+//-------------------------------------------------------------------------------------
+
+void CEditDictionary::SetISpellChecker(ISpellChecker *i)	{
+
+	STableCell	cell(0, 1);
+	int unusedNumber;
+	char word_buffer[max_word_length];
+	int curr_word_length;
+	
+	mISpellChecker = i;
+	cell.row = 0;
+	
+	if ((mISpellChecker->GetFirstPersonalDictionaryWord(word_buffer, max_word_length) >= 0) && mWordsView) {
+		mWordsView->FocusDraw();
+		do	{
+			mNumWords++;
+			cell.row++;
+			curr_word_length = strlen(word_buffer);
+			CStr255 pascalstring( word_buffer );
+			mWordsView->InsertRows(1, cell.row-1, NULL ,0, Refresh_Yes);
+			mWordsView->SetCellData(cell, pascalstring, curr_word_length + 1);
+			// Insert the words into dialog box here!
+		}	while	(mISpellChecker->GetNextPersonalDictionaryWord(word_buffer, max_word_length) >= 0);
+	}
+	
+	mWordsView->GetTableSize(mNumWords, unusedNumber);
+}
+
+//-------------------------------------------------------------------------------------
+// CEditDictionary::GetISPellChecker
+// Get the Personal Dictionary
+//-------------------------------------------------------------------------------------
+ISpellChecker *CEditDictionary::GetISpellChecker()	{
+
+	return mISpellChecker;
+}
+
+//-------------------------------------------------------------------------------------
+// CEditDictionaryTable::BeTarget()
+// Broadcast messages when we become target so we can setup buttons
+//-------------------------------------------------------------------------------------
+void CEditDictionaryTable::BeTarget() {
+
+	CTextTable::BeTarget();
+	BroadcastMessage(CEditDictionary::WordsTableID, NULL);
+}
+
+//-------------------------------------------------------------------------------------
+// CEditDictionaryTable::DontBeTarget()
+// Broadcast messages when we lose target so we can setup buttons
+//-------------------------------------------------------------------------------------
+void CEditDictionaryTable::DontBeTarget() {
+
+	CTextTable::DontBeTarget();
+	BroadcastMessage(CEditDictionary::msg_LeaveDictionaryTable, NULL);
+}
+
+//-------------------------------------------------------------------------------------
+// HiliteSelection
+// Setup back/front colors.  Otherwise we sometimes get the de-highlighting
+// wrong when switching selection
+//-------------------------------------------------------------------------------------
+void CEditDictionaryTable::HiliteSelection(	Boolean	inActively, 	Boolean	 inHilite )
+{
+	if (inActively) {
+		StColorPenState::Normalize();
+	}
+	LTableView::HiliteSelection( 	inActively, inHilite );
+}

mozilla/cmd/macfe/Composer/CEditDictionary.h

@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#include "CTextTable.h"
+#include <LGADialogBox.h>
+
+
+class LGAPushButton;
+class CLargeEditFieldBroadcast;
+class ISpellChecker;
+
+
+class CEditDictionary : public LGADialogBox {
+
+	public:
+
+		virtual 	void							ListenToMessage	(	MessageT inMessage, 
+																	void*		ioParam );		
+														
+		virtual		void							FinishCreateSelf();
+													CEditDictionary(LStream *inStream);
+																
+					void							SetISpellChecker(ISpellChecker *i);
+					ISpellChecker					*GetISpellChecker();						
+																
+		enum	{ class_ID = 'CEdD', res_ID = 5298 };
+		enum	{ AddButtonID	= 201 ,	WordID = 200, WordsTableID = 202, ReplaceButtonID = 203,
+				RemoveButtonID = 204, HelpButtonID = 205, msg_LeaveDictionaryTable = 208 };
+		enum	{ max_word_length = 50 };	// Max length of a word
+		
+	protected:
+	
+							void 							MakeDictionaryChangesPermanent();
+		virtual		void 							AddNewWord();
+		virtual		void  						RemoveSelectedWords();
+		virtual		void							ReplaceSelectedWord();
+		CLargeEditFieldBroadcast 		*mWordNameField;			// The field where user edits word
+		LGAPushButton 							*mAddButton;					// Add new word button
+		LGAPushButton								*mReplaceButton;
+		LGAPushButton								*mRemoveButton;
+		LGAPushButton								*mHelpButton;
+		CTextTable									*mWordsView;					// The Personal Dictionary view
+		
+		int													mNumWords;
+		
+		ISpellChecker								*mISpellChecker;
+};
+
+class CEditDictionaryTable : public CTextTable {
+
+	public:
+	
+			enum	{class_ID = 'CEDT' };
+			virtual void		BeTarget();
+			virtual void		DontBeTarget();
+											CEditDictionaryTable(LStream *inStream) : CTextTable(inStream) { }
+	
+							void 		HiliteSelection(	Boolean	inActively, 	Boolean	 inHilite );
+};

mozilla/cmd/macfe/Composer/CEditView.h

@@ -0,0 +1,271 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#include <TextServices.h>
+#include "CHTMLView.h"
+
+// dangling prototype
+Boolean GetCaretPosition(MWContext *context, LO_Element * element, int32 caretPos, 
+									int32* caretX, int32* caretYLow, int32* caretYHigh );
+
+
+class LGAPopup;
+class CPatternButtonPopup;
+class CColorPopup;
+class CComposeSession;
+class CFontMenuPopup;
+
+class HTMLInlineTSMProxy;
+class HoldUpdatesProxy;
+
+class CEditView: public CHTMLView
+{
+#if !defined(__MWERKS__) || (__MWERKS__ >= 0x2000)
+	typedef CHTMLView inherited;
+#endif
+
+public:
+	enum { pane_ID = 'html', class_ID = 'Edtp', dashMark = '-' };
+	enum {
+			STRPOUND_EDITOR_MENUS			= 5101,
+			EDITOR_MENU_SHOW_PARA_SYMBOLS		= 1,
+			EDITOR_MENU_HIDE_PARA_SYMBOLS		= 2,
+			EDITOR_MENU_UNDO					= 3,
+			EDITOR_MENU_REDO					= 4,
+			EDITOR_MENU_SHOW_COMP_TOOLBAR		= 5,
+			EDITOR_MENU_HIDE_COMP_TOOLBAR		= 6,
+			EDITOR_MENU_SHOW_FORMAT_TOOLBAR		= 7,
+			EDITOR_MENU_HIDE_FORMAT_TOOLBAR		= 8,
+			EDITOR_MENU_SHOW_TABLE_BORDERS		= 9,
+			EDITOR_MENU_HIDE_TABLE_BORDERS		= 10,
+			EDITOR_MENU_CHARACTER_ATTRIBS		= 11,
+			EDITOR_MENU_IMAGE_ATTRIBUTES		= 12,
+			EDITOR_MENU_LINK_ATTRIBUTES			= 13,
+			EDITOR_MENU_LINE_ATTRIBUTES			= 14,
+			EDITOR_MENU_TABLE_ATTRIBUTES		= 15,
+			EDITOR_MENU_UNKNOWN_ATTRIBUTES		= 16,
+			EDITOR_MENU_TARGET_ATTRIBUTES		= 17
+	};
+	enum {
+			eMouseHysteresis = 6,
+			eSelectionBorder = 3
+	};
+	
+	// ¥¥ Constructors
+					CEditView(LStream * inStream);
+					~CEditView();
+	virtual void	FinishCreateSelf(void);
+
+	// ¥¥ Command handling
+	virtual	Boolean ObeyCommand( CommandT inCommand, void *ioParam );
+	virtual void	ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual void  	FindCommandStatus( CommandT inCommand,
+							Boolean& outEnabled, Boolean& outUsesMark, 
+							Char16& outMark,Str255 outName );
+			Boolean	FindCommandStatusForContextMenu( CommandT inCommand,
+							Boolean &outEnabled, Boolean &outUsesMark,
+							Char16 &outMark, Str255 outName );
+	
+			Boolean IsPastable(Char16 theChar);
+			int 	FindQueuedKeys( char *keys_in_q );
+	virtual Boolean HandleKeyPress( const EventRecord& inKeyEvent );
+	
+	virtual void 	AdaptToSuperFrameSize( Int32 inSurrWidthDelta, 
+											Int32 inSurrHeightDelta, Boolean inRefresh );
+								
+	virtual void	BeTarget();
+	virtual void	DontBeTarget();
+
+			void	HandleCut();
+			void	HandleCopy();
+			void	HandlePaste();
+	
+	TSMDocumentID	midocID;
+	
+	virtual void	CreateFindWindow();
+	virtual void	SetContext( CBrowserContext* inNewContext );
+	virtual URL_Struct *GetURLForPrinting( Boolean& outSuppressURLCaption, MWContext *printingContext );
+
+	void			TakeOffDuty();
+	virtual void	PutOnDuty(LCommander*);
+	
+	Bool 			PtInSelectedRegion(SPoint32 cpPoint );
+	virtual void	DrawSelf( void );
+	virtual void 	ActivateSelf();
+	virtual void 	DeactivateSelf();
+	
+	Bool			SaveDocument();
+	Bool			SaveDocumentAs();
+	Bool			VerifySaveUpToDate();
+	
+
+	// ¥¥ cursor calls and caret functionality
+	virtual void	AdjustCursorSelf( Point inPortPt, const EventRecord& inMacEvent );
+
+	virtual void	SpendTime( const EventRecord& inMacEvent );
+	void	 		DrawCaret( Boolean doErase );
+	void	 		EraseCaret();
+	void			HideCaret( Boolean mhide ) { EraseCaret(); mHideCaret = mhide; }
+	void			PlaceCaret(int32 caretX, int32 caretYLow, int32 caretYHigh);
+	void			RemoveCaret();
+	void 			DisplayGenericCaret( MWContext *context, LO_Element * pLoAny, 
+										ED_CaretObjectPosition caretPos );
+	
+	// ¥¥ Drag and Drop 
+	virtual Boolean	ItemIsAcceptable (DragReference	dragRef, ItemReference itemRef);
+	virtual void	ReceiveDragItem( DragReference inDragRef, DragAttributes inDragAttr, 
+									ItemReference inItemRef, Rect& inItemBounds );
+	virtual void	DoDragSendData( FlavorType inFlavor, ItemReference inItemRef,
+									DragReference inDragRef );
+	
+	virtual void	ClickSelf (const SMouseDownEvent& where );
+	virtual	Boolean	ClickTrackSelection( const SMouseDownEvent&	inMouseDown, 
+										CHTMLClickRecord& inClickRecord );
+	
+	virtual Boolean	SetDefaultCSID( Int16 inPreferredCSID );
+	CBrowserContext	*GetNSContext() { return mContext; };
+
+	void			SetHoldUpdates(HoldUpdatesProxy* inHoldUpdates) {mHoldUpdates = inHoldUpdates;};
+
+	Boolean			mEditorDoneLoading;
+	Boolean			IsDoneLoading() const { return mEditorDoneLoading; }
+
+	// ¥¥ FE_* calls
+	void			DocumentChanged( int32 iStartY, int32 iHeight );
+	void			GetDocAndWindowPosition( SPoint32 &frameLocation, SPoint32 &imageLocation, SDimension16 &frameSize );
+	
+	// ¥¥ formatting query calls
+	void			UseCharFormattingCache() { CanUseCharFormatting(); mUseCharFormattingCache = true; }
+	void			DontUseCharFormattingCache() { mUseCharFormattingCache = false; }
+
+	class StUseCharFormattingCache
+	{
+		public:
+			StUseCharFormattingCache( CEditView& p ) : view(p) { view.UseCharFormattingCache(); }
+			~StUseCharFormattingCache() { view.DontUseCharFormattingCache(); }
+		
+		private:
+			CEditView &view;	
+	};
+
+	LGAPopup		* mParagraphToolbarPopup;
+	LGAPopup		* mSizeToolbarPopup;
+	CFontMenuPopup	* mFontToolbarPopup;
+	CPatternButtonPopup	* mAlignToolbarPopup;
+	CColorPopup		* mColorPopup;
+
+protected:
+	virtual Boolean		IsGrowCachingEnabled() const { return !mEditorDoneLoading; }
+
+	virtual void 		LayoutNewDocument( URL_Struct *inURL, Int32 *inWidth,
+										Int32 *inHeight, Int32 *inMarginWidth, Int32 *inMarginHeight );
+
+	// ¥¥ FE_* calls
+	virtual void 		SetDocPosition( int inLocation, Int32 inX, Int32 inY,
+									Boolean inScrollEvenIfVisible = false);
+	virtual void 		DisplayLineFeed( int inLocation, LO_LinefeedStruct *inLinefeedStruct, XP_Bool inNeedBG );
+	virtual void 		DisplayHR( int inLocation, LO_HorizRuleStruct *inRuleStruct );
+	virtual void 		DisplaySubtext( int inLocation, LO_TextStruct *inText, 
+										Int32 inStartPos, Int32 inEndPos, XP_Bool inNeedBG );
+	virtual void 		EraseBackground( int inLocation, Int32 inX, Int32 inY,
+										Uint32 inWidth, Uint32 inHeight, LO_Color *inColor );
+	virtual void		GetDefaultBackgroundColor(LO_Color* outColor) const;
+	virtual void 		DisplayTable( int inLocation, LO_TableStruct *inTableStruct );
+	virtual void		DisplayCell( int inLocation, LO_CellStruct *inCellStruct );
+	virtual	void 		InvalidateEntireTableOrCell( LO_Element* inElement );
+	virtual	void 		DisplayAddRowOrColBorder( XP_Rect* inRect, XP_Bool inDoErase );
+	virtual void		UpdateEnableStates();
+	virtual void		DisplayFeedback( int inLocation, LO_Element *inElement );
+	virtual void		DisplaySelectionFeedback( uint16 ele_attrmask, const Rect &inRect );
+	
+	
+	virtual void		InsideDropArea( DragReference inDragRef );
+	virtual void 		EnterDropArea( DragReference inDragRef, Boolean inDragHasLeftSender );
+	DragReference 		mDragRef;
+
+	enum {
+		ED_SELECTION_BORDER = 3
+		};
+	
+    enum { MAX_Q_SIZE = 12 };		// Used for checking out key strokes waiting in FindQueuedKeys
+
+	void 			InsertDefaultLine();
+	void			DoReload( void );
+	void			ToFromList( intn listType, ED_ListType elementType );
+	void			NoteEditorRepagination( void );
+	Boolean			CanUseCharFormatting();
+
+	Boolean			IsMouseInSelection( SPoint32 pt, CL_Layer *curLayer, Rect& selectRect );
+	Boolean			mDoContinueSelection;
+
+	HTMLInlineTSMProxy*		mProxy;
+	HoldUpdatesProxy* 		mHoldUpdates;
+
+	// more caret blinking and related stuff
+	Boolean			mCaretDrawn, mCaretActive;
+	Boolean			mHideCaret;
+	Boolean			mDisplayParagraphMarks;
+
+	Point			mOldPoint;	// Last place cursor was adjusted. No initializing
+	long			mOldLastElementOver;	// id of the last element the cursor was over
+
+	unsigned long	mLastBlink;
+	int32			mCaretX;
+	int32			mCaretYLow;
+	int32			mCaretYHigh;
+	
+	Boolean			mUseCharFormattingCache;
+	Boolean			mIsCharFormatting;
+	
+	// these are only to be used during drag of data in composer
+	char			*mDragData;	// warning this really isn't a "char" but void* data!!!
+	int32			mDragDataLength;
+};	// class CEditView
+
+
+//======================================
+class CMailEditView : public CEditView
+//======================================
+{
+public:
+	enum { pane_ID = 'html', class_ID = 'MEdp' };
+	
+	// ¥¥ Constructors
+
+					CMailEditView(LStream * inStream);
+	virtual void	InstallBackgroundColor();
+	virtual void	GetDefaultBackgroundColor(LO_Color* outColor) const;
+	virtual void	InitMailCompose();
+			void	SetComposeSession( CComposeSession *c ) { mComposeSession = c; };
+			void	SetInitialText( const char *textp );
+			void    InsertMessageCompositionText( const char* text,
+					 XP_Bool leaveCursorBeginning, XP_Bool isHTML );
+			void	DisplayDefaultTextBody();
+
+private:
+	Int32			mStartQuoteOffset;
+	Int32			mEndQuoteOffset;
+	Boolean			mHasAutoQuoted;
+	Boolean			mHasInsertSignature;
+	Boolean			mCursorSet;
+	char			*mInitialText; // Draft text
+	CComposeSession *mComposeSession;
+}; // class CMailEditView
+

mozilla/cmd/macfe/Composer/CEditorWindow.cp

@@ -0,0 +1,626 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "CEditorWindow.h"
+#include "CBrowserContext.h"
+#include "resgui.h"
+#include "CFormattingToolBar.h"
+#include "CFontMenuAttachment.h"
+#include "CToolbarPopup.h"
+#include "CPatternButtonPopupText.h"
+#include "COpenRecentlyEditedPopup.h"
+#include "CColorPopup.h"
+
+#include "CEditDictionary.h"
+
+#include "CTextTable.h"
+#include "CTableKeySingleSelector.h"
+
+	// macfe
+#include "mversion.h"	// ID_STRINGS
+#include "URobustCreateWindow.h"
+#include "uprefd.h"
+#include "uerrmgr.h"
+#include "uapp.h"
+#include "meditdlg.h"	// CTabbedDialog
+#include "meditor.h"	// HandleModalDialog
+#include "CEditView.h"
+#include "ufilemgr.h"
+
+	// Netscape
+#include "net.h"	// NET_cinfo_find_type
+#include "proto.h"	// XP_IsContextBusy
+#include "edt.h"
+#include "shist.h"
+#include "prefapi.h"	// PREF_GetBoolPref
+
+#ifdef PROFILE
+#pragma profile on
+#endif
+
+// pane id constants - for ShowOneDragBar
+const PaneIDT Paragraph_Bar_PaneID = 'DBar';
+const PaneIDT Character_Bar_PaneID = 'NBar';
+
+const char* Pref_ShowParagraphBar = "editor.show_paragraph_toolbar";
+const char* Pref_ShowCharacterBar = "editor.show_character_toolbar";
+
+enum {  eParagraphBar,
+		eCharacterBar	};
+
+CEditorWindow::CEditorWindow( LStream* inStream )
+	:CBrowserWindow(inStream)
+{
+	SetWindowType( WindowType_Editor );
+}
+
+ 
+static	// PRIVATE
+CMediatedWindow* GetFrontWindowByType( OSType windowType )
+{
+	CMediatedWindow* theWindow = NULL;
+	CWindowIterator iter(windowType);
+	iter.Next(theWindow);
+	return theWindow;
+}
+
+// given an mwcontext (non-busy, with a history), select the matching editor window
+// or open an editor window based on that mwcontext
+// if all else fails (and memory is not low), create an empty editor window
+void CEditorWindow::MakeEditWindowFromBrowser( MWContext* mwcontext )
+{
+	if ( Memory_MemoryIsLow() )
+		return;
+	
+	History_entry*	entry = NULL;
+	if ( mwcontext && !XP_IsContextBusy( mwcontext ) )
+		entry = SHIST_GetCurrent(&mwcontext->hist);
+	
+	if ( entry && entry->address)
+	{
+		// If there is already an editor window open for this url 
+		// just switch to it and keep this browser window open.
+		CMediatedWindow * win;
+		CWindowIterator iter(WindowType_Editor);
+		while (iter.Next(win))
+		{
+			CNSContext* curContext = ((CBrowserWindow *)win)->GetWindowContext();
+			MWContext*	context;
+			
+			context = curContext ? curContext->operator MWContext*() : NULL;
+			if (context && EDT_IS_EDITOR(context))
+			{
+				History_entry*	newEntry = SHIST_GetCurrent(&context->hist);
+				if (newEntry && newEntry->address && !strcmp(newEntry->address, entry->address))
+				{
+					win->Show();
+					win->Select();
+					return;
+				}
+			}
+		}
+		
+		if (CEditorWindow::MakeEditWindow(mwcontext, NULL) == NULL) 	// new window based on history of this window
+			return;		// don't close this one on error.
+	}
+	else
+	{
+		CEditorWindow::MakeEditWindow(NULL, NULL);	// make a completely new window
+	}
+}
+
+
+// EDT_PreOpenCallbackFn 
+static void createEditorWindowCallback( XP_Bool userCanceled, char* pURL, void* hook )
+{
+	if ( !userCanceled )
+	{
+		EditorCreationStruct *edtCreatePtr = (EditorCreationStruct *)hook;
+		
+		if ( hook )
+		{
+			if ( edtCreatePtr->existingURLstruct && edtCreatePtr->existingURLstruct->address )
+			{
+				XP_FREE( edtCreatePtr->existingURLstruct->address );
+				edtCreatePtr->existingURLstruct->address = XP_STRDUP( pURL );
+			}
+		}
+		
+		// substitute new URL
+		CEditorWindow::CreateEditorWindowStage2( edtCreatePtr );
+	}
+}
+
+
+CEditorWindow* CEditorWindow::MakeEditWindow( MWContext* old_context, URL_Struct* url )
+{
+	Boolean urlCameInNULL = (url == NULL);
+	
+	// if we don't have an URL, try to get it from the old_context's window history
+	if (url == NULL && old_context != NULL)
+	{
+		CBrowserContext *browserContext = (CBrowserContext *)old_context->fe.newContext;
+		History_entry*	entry = browserContext->GetCurrentHistoryEntry();	// Take the last instead of the first history entry.
+		if ( entry )
+		{
+			url = SHIST_CreateURLStructFromHistoryEntry( old_context, entry );
+			if ( url )
+				url->force_reload = NET_NORMAL_RELOAD;
+		}
+		else if ( CPrefs::GetBoolean( CPrefs::LoadHomePage ) )
+		{
+			CStr255 home = CPrefs::GetString( CPrefs::HomePage );
+			if ( home.Length() > 0 )
+				url = NET_CreateURLStruct( home, NET_NORMAL_RELOAD );
+		}
+	}
+
+	// we want to open a new blank edit window
+	// or we are still having troubles... fall back to our old tried and true blank page
+	if (url == NULL)
+		url = NET_CreateURLStruct ("about:editfilenew", NET_NORMAL_RELOAD );
+				// FIX THIS!!! the above line should use "XP_GetString(XP_EDIT_NEW_DOC_NAME)"
+
+	// time of reckoning. We really, really need an URL and address at this point...
+	// I don't know what an url without an address is anyway...
+	if (url == NULL || url->address == NULL)
+		return NULL;
+	
+	// now make sure that the url is a valid type to edit.
+	NET_cinfo *cinfo = NET_cinfo_find_type (url->address);
+	
+	if (cinfo == NULL || cinfo->type == NULL ||
+		  (strcasecomp (cinfo->type, TEXT_HTML)
+		&& strcasecomp (cinfo->type, UNKNOWN_CONTENT_TYPE)
+		&& strcasecomp (cinfo->type, TEXT_PLAIN)))
+	{
+		ErrorManager::PlainAlert( NOT_HTML );
+		return NULL;
+	}
+
+	EditorCreationStruct *edtCreatePtr = (EditorCreationStruct *)XP_ALLOC( sizeof( EditorCreationStruct ) );
+	if ( edtCreatePtr )
+	{
+		edtCreatePtr->context = old_context;
+		edtCreatePtr->existingURLstruct = url;
+		edtCreatePtr->isEmptyPage = old_context == NULL && urlCameInNULL;
+	}
+		
+	if ( urlCameInNULL && old_context == NULL )
+	{
+		return CreateEditorWindowStage2( edtCreatePtr );
+	}
+	else
+	{
+		EDT_PreOpen( old_context, url->address, createEditorWindowCallback, edtCreatePtr );
+		return NULL;
+	}
+}
+
+
+CEditorWindow *CEditorWindow::CreateEditorWindowStage2( EditorCreationStruct *edtCreatePtr )
+{
+	// now we can create an editor window since we don't already have one for this url.
+	
+	/* instead of just calling LWindow::CreateWindow(), we do it ourselves by hand here 
+	 * so that we can set the window bounds before we call FinishCreate().
+	 */
+	
+	if ( edtCreatePtr == NULL )
+		return NULL;
+	
+	CEditorWindow* newWindow = NULL;
+	SetDefaultCommander(CFrontApp::GetApplication());
+	try {
+		OSErr	error;
+		URobustCreateWindow::ReadObjects( 'PPob', CEditorWindow::res_ID, &newWindow, &error );
+		Assert_(newWindow);
+		FailOSErr_(error);
+		if (newWindow == NULL)
+		{
+			XP_FREE( edtCreatePtr );
+			return NULL;
+		}
+
+		newWindow->FinishCreate();
+		if (newWindow->HasAttribute(windAttr_ShowNew))
+			newWindow->Show();
+
+		UReanimator::LinkListenerToControls( newWindow, newWindow, CEditorWindow::res_ID );
+	}
+	catch(...)
+	{
+		if ( newWindow )
+			delete newWindow;
+		
+		XP_FREE( edtCreatePtr );
+		
+		return NULL;
+	}
+	
+	Boolean hasURLstruct = edtCreatePtr->existingURLstruct && edtCreatePtr->existingURLstruct->address;
+	CBrowserContext *nscontext = new CBrowserContext();
+	newWindow->SetWindowContext( nscontext );
+	
+	CURLDispatcher::DispatchURL( edtCreatePtr->existingURLstruct, nscontext, false, false, CEditorWindow::res_ID );
+	
+	if ( edtCreatePtr->context )
+	{
+		nscontext->InitHistoryFromContext( (CBrowserContext *)edtCreatePtr->context->fe.newContext );
+	}
+	else
+	{
+		// the url will eventually be freed when the load is complete.
+	}
+
+	// set window title here (esp. for "open")
+	if ( !edtCreatePtr->isEmptyPage
+	&& edtCreatePtr->existingURLstruct && edtCreatePtr->existingURLstruct->address )
+	{
+		char *pSlash = strrchr( edtCreatePtr->existingURLstruct->address, '/' );
+		if ( pSlash )
+			pSlash += 1;	// move past '/'
+		newWindow->NoteDocTitleChanged( pSlash );
+	}
+	
+	XP_FREE( edtCreatePtr );
+	
+	return newWindow;
+}
+
+		
+void CEditorWindow::SetWindowContext(CBrowserContext* inContext)
+{
+	if ( inContext )
+	{
+		MWContext *context;
+		context = inContext->operator MWContext*();
+		if ( context )
+		{
+			context->is_editor = true;
+			NET_CheckForTimeBomb( context );
+		}
+	}
+
+	CBrowserWindow::SetWindowContext( inContext );
+}
+
+
+void CEditorWindow::NoteDocTitleChanged( const char* inNewTitle )
+{
+	// there is one bogus set-title from layout that we want to skip...
+	// We are hard coding "editfilenew" here because it is already hardcoded 
+	// a million other places...
+	if ( inNewTitle && XP_STRCMP( inNewTitle, "editfilenew" ) == 0 )
+		return;
+
+	CNSContext *theContext = GetWindowContext();
+	
+	char *baseName = LO_GetBaseURL( theContext->operator MWContext*() );	// don't free this...
+	// strip out username and password so user doesn't see them in window title
+	char *location = NULL;
+	if ( baseName )
+		NET_ParseUploadURL( baseName, &location, NULL, NULL );
+	CStr255	csBaseURL(location);
+	// if this page has a local "file:" url, then just show the file name (skip the url and directory crap.)
+	
+	if ( location && NET_IsLocalFileURL(location) )
+	{
+		char *localName = NULL;
+		XP_ConvertUrlToLocalFile( location, &localName );
+		
+		if (localName)
+		{
+#if 0
+			char *pSlash = strrchr(localName, '/');
+			if (pSlash)
+			{		// is there is a slash, move everything AFTER the last slash to the front
+				pSlash++;
+				XP_STRCPY(localName, pSlash);
+			}
+#endif
+
+			csBaseURL = localName;
+			XP_FREE(localName);
+		}
+	}
+	
+	CStr255 	netscapeTitle;
+	CStr255		subTitle;
+	
+	::GetIndString( netscapeTitle, ID_STRINGS, APPNAME_STRING_INDEX );
+	::GetIndString( subTitle, WINDOW_TITLES_RESID, 3 );
+	
+	netscapeTitle += " ";
+	netscapeTitle += subTitle;
+	netscapeTitle += " - [";
+	
+	// set up page title manually; rather than rely on XP string passed in
+	EDT_PageData * pageData = EDT_GetPageData( theContext->operator MWContext*() );
+	if ( pageData && pageData->pTitle && pageData->pTitle[0] )
+	{
+		netscapeTitle += pageData->pTitle;
+		if (csBaseURL.Length())
+			netscapeTitle += " : ";
+	}
+	
+	if ( pageData )
+		EDT_FreePageData( pageData );
+	
+	// add file path to end
+	if (csBaseURL.Length())
+	{
+		netscapeTitle += csBaseURL;
+	}
+	netscapeTitle += "]";
+
+	SetDescriptor( netscapeTitle );
+
+	if ( location )
+		XP_FREE( location );
+}
+
+
+void CEditorWindow::RegisterViewTypes()
+{
+	// Registers all its view types
+	RegisterClass_( CEditorWindow);
+	RegisterClass_( CEditView);
+	RegisterClass_( MultipleSelectionSingleColumn);	// newer, better class?
+	RegisterClass_( CTarget);
+	RegisterClass_( CLineProp);
+	RegisterClass_( CFormattingToolBar);
+	
+	RegisterClass_( CToolbarPopup);					// newer, better class?
+	RegisterClass_( CIconToolbarPopup);				// newer, better class?
+	RegisterClass_( CColorPopup);
+	RegisterClass_( CFontMenuPopup );
+	
+	RegisterClass_( CChameleonCaption);				// newer, better class?
+	RegisterClass_( CChameleonView);				// newer, better class?
+	CTabbedDialog::RegisterViewTypes();
+	
+	RegisterClass_( CTextTable);					// newer, better class?
+	RegisterClass_( CTableKeySingleSelector);		// newer, better class?
+
+	RegisterClass_( CPatternButtonPopupText);		// newer, better class?
+	RegisterClass_( LOffscreenView);
+	RegisterClass_( COpenRecentlyEditedPopup );
+	
+	RegisterClass_( CEditDictionary);
+	RegisterClass_( CEditDictionaryTable);	
+}
+
+
+void CEditorWindow::FinishCreateSelf()
+{
+	CBrowserWindow::FinishCreateSelf();
+
+	// Show/hide toolbars based on preference settings
+	XP_Bool	value;
+	PREF_GetBoolPref(Pref_ShowParagraphBar, &value);
+	mToolbarShown[eParagraphBar] = value;
+	ShowOneDragBar(Paragraph_Bar_PaneID, value);
+	PREF_GetBoolPref(Pref_ShowCharacterBar, &value);
+	mToolbarShown[eCharacterBar] = value;
+	ShowOneDragBar(Character_Bar_PaneID, value);
+}
+
+
+void CEditorWindow::ListenToMessage( MessageT inMessage, void* ioParam )
+{
+	switch (inMessage)
+	{
+		case msg_NSCDocTitleChanged:
+			NoteDocTitleChanged((const char*)ioParam);
+			break;
+	
+		default:
+		{
+			if ( inMessage == 'Para' )
+			{
+				switch  (*(long*)ioParam)
+				{
+					case 1:		inMessage = cmd_Format_Paragraph_Normal;		break;
+					case 2:		inMessage = cmd_Format_Paragraph_Head1;			break;
+					case 3:		inMessage = cmd_Format_Paragraph_Head2;			break;
+					case 4:		inMessage = cmd_Format_Paragraph_Head3;			break;
+					case 5:		inMessage = cmd_Format_Paragraph_Head4;			break;
+					case 6:		inMessage = cmd_Format_Paragraph_Head5;			break;
+					case 7:		inMessage = cmd_Format_Paragraph_Head6;			break;
+					case 8:		inMessage = cmd_Format_Paragraph_Address;		break;
+					case 9:		inMessage = cmd_Format_Paragraph_Formatted;		break;
+					case 10:	inMessage = cmd_Format_Paragraph_List_Item;		break;
+					case 11:	inMessage = cmd_Format_Paragraph_Desc_Title;	break;
+					case 12:	inMessage = cmd_Format_Paragraph_Desc_Text;		break;
+				}
+			}
+			else if ( inMessage == 'Size' )
+			{
+				switch  (*(long*)ioParam)
+				{
+					case 1:		inMessage = cmd_Format_Font_Size_N2;	break;
+					case 2:		inMessage = cmd_Format_Font_Size_N1;	break;
+					case 3:		inMessage = cmd_Format_Font_Size_0;		break;
+					case 4:		inMessage = cmd_Format_Font_Size_P1;	break;
+					case 5:		inMessage = cmd_Format_Font_Size_P2;	break;
+					case 6:		inMessage = cmd_Format_Font_Size_P3;	break;
+					case 7:		inMessage = cmd_Format_Font_Size_P4;	break;
+				}
+			}
+			else if ( inMessage == 'Algn' )
+			{
+				switch  (*(long*)ioParam)
+				{
+					case 1:		inMessage = cmd_JustifyLeft;	break;
+					case 2:		inMessage = cmd_JustifyCenter;	break;
+					case 3:		inMessage = cmd_JustifyRight;	break;
+				}
+			}
+
+			// GetHTMLView() guaranteed not to fail
+			GetHTMLView()->ObeyCommand( inMessage, ioParam );
+			break;
+		}
+	}
+}
+
+
+// EDT_PreCloseCallbackFn 
+static void closeEditorWindowCallback( void* hook )
+{
+	CEditorWindow *editorWindow = (CEditorWindow *)hook;
+	if ( editorWindow )
+		editorWindow->SetPluginDoneClosing();
+}
+
+
+Boolean CEditorWindow::ObeyCommand( CommandT inCommand, void *ioParam )
+{
+	switch ( inCommand )
+	{
+		case cmd_NewWindowEditor:
+			CEditorWindow::MakeEditWindow( NULL, NULL );
+			break;
+		
+		case cmd_ViewSource:
+			// Delegate this to the view.
+			if ( ((CEditView *)GetHTMLView())->IsDoneLoading() )
+				GetHTMLView()->ObeyCommand(inCommand, ioParam);
+			break;
+				
+		case cmd_Toggle_Paragraph_Toolbar:
+			ToggleDragBar(Paragraph_Bar_PaneID, eParagraphBar, Pref_ShowParagraphBar);
+			break;
+		
+		case cmd_Toggle_Character_Toolbar:
+			ToggleDragBar(Character_Bar_PaneID, eCharacterBar, Pref_ShowCharacterBar);
+			break;
+
+		case cmd_Close:
+		case cmd_Quit:				// we'll just intercept these and then send them on to the default case
+			MWContext *mwcontext = GetWindowContext()->operator MWContext*();
+			History_entry*	newEntry = SHIST_GetCurrent(&mwcontext->hist);
+			CStr255 fileName;
+			if ( newEntry && newEntry->address )
+				fileName = newEntry->address;
+				
+			if ( ((CEditView *)GetHTMLView())->IsDoneLoading() && EDT_DirtyFlag( *GetWindowContext() ) )
+			{
+				Select(); // This helps during a quit or "close all"
+				
+				MessageT itemHit = HandleModalDialog( EDITDLG_SAVE_BEFORE_QUIT, fileName, NULL );
+				if (itemHit == cancel)
+					return true;
+				
+				if (itemHit == ok)
+				{				// save
+					if ( !((CEditView *)GetHTMLView())->SaveDocument() )
+						return true;			
+				}
+				EDT_SetDirtyFlag( mwcontext, false );		// we have to do this or else when we quit, we will be asked twice to save
+			}
+			
+			// need to let this work asynchronously; make our own internal loop
+			if ( ((CEditView *)GetHTMLView())->IsDoneLoading() && newEntry && newEntry->address )
+			{
+				mPluginDoneClosing = false;
+				EDT_PreClose( mwcontext, newEntry->address, closeEditorWindowCallback, this );
+				
+				do
+				{
+					CFrontApp::GetApplication()->ProcessNextEvent();
+				} while ( !mPluginDoneClosing );
+			}
+
+		// fall through
+
+		default:
+		{
+			return CBrowserWindow::ObeyCommand (inCommand, ioParam);
+		}
+	}
+	return TRUE;
+}
+
+
+void CEditorWindow::FindCommandStatus( CommandT inCommand,
+	Boolean& outEnabled, Boolean& outUsesMark, Char16& outMark,
+	Str255 outName )
+{
+	short index;
+	outUsesMark = FALSE;
+	outEnabled = false;
+
+	switch ( inCommand )
+	{
+		case cmd_ViewSource:
+			// Delegate this to the view.
+			if ( ((CEditView *)GetHTMLView())->IsDoneLoading() )
+				GetHTMLView()->FindCommandStatus(inCommand, outEnabled, outUsesMark, outMark, outName);
+			break;
+
+		case cmd_Toggle_Character_Toolbar:
+			outEnabled = ((CEditView *)GetHTMLView())->IsDoneLoading();
+			index = mToolbarShown[eCharacterBar] ? CEditView::EDITOR_MENU_HIDE_COMP_TOOLBAR 
+											: CEditView::EDITOR_MENU_SHOW_COMP_TOOLBAR;
+			::GetIndString( outName, CEditView::STRPOUND_EDITOR_MENUS, index );
+			break;
+
+		case cmd_Toggle_Paragraph_Toolbar:
+			outEnabled = ((CEditView *)GetHTMLView())->IsDoneLoading();
+			index = mToolbarShown[eParagraphBar] ? CEditView::EDITOR_MENU_HIDE_FORMAT_TOOLBAR 
+											: CEditView::EDITOR_MENU_SHOW_FORMAT_TOOLBAR;
+			::GetIndString( outName, CEditView::STRPOUND_EDITOR_MENUS, index );
+			break;
+
+		default:
+			CBrowserWindow::FindCommandStatus(inCommand, outEnabled, outUsesMark, outMark, outName );
+	}
+}
+
+
+// Called when we are trying to quit the application
+Boolean	CEditorWindow::AttemptQuitSelf( long inSaveOption )
+{
+	MWContext *mwcontext = GetWindowContext()->operator MWContext*();
+	if ( EDT_DirtyFlag( mwcontext ) )
+	{
+		History_entry*	newEntry = SHIST_GetCurrent(&mwcontext->hist);
+		CStr255 fileName;
+		if ( newEntry && newEntry->address )
+			fileName = newEntry->address;
+
+		if ( kAEAsk == inSaveOption )
+		{
+			MessageT itemHit = HandleModalDialog( EDITDLG_SAVE_BEFORE_QUIT, fileName, NULL );
+			if ( cancel == itemHit )
+				return false;
+		}
+		
+		// save
+		if ( !((CEditView *)GetHTMLView())->SaveDocument() ) 
+			return false;			
+	}
+	
+	return true;
+}
+
+#ifdef PROFILE
+#pragma profile off
+#endif

mozilla/cmd/macfe/Composer/CEditorWindow.h

@@ -0,0 +1,67 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#include "CBrowserWindow.h"
+
+
+struct EditorCreationStruct {
+	MWContext	*context;	// may be NULL
+	URL_Struct	*existingURLstruct;
+	Boolean		isEmptyPage;
+};
+
+
+
+/******************************************************************************
+ * CEditorWindow is really just a CBrowserWindow with some changes for an editor window.
+ ******************************************************************************/
+class CEditorWindow: public CBrowserWindow
+{	
+public:
+	enum {class_ID = 'edtw', res_ID = 10000};
+	
+	// ¥¥ Constructors
+
+	static void 		RegisterViewTypes();	// Registers all its view types
+	static CEditorWindow *MakeEditWindow( MWContext* old_context, URL_Struct* url );
+	static CEditorWindow *CreateEditorWindowStage2( EditorCreationStruct *edtCreatePtr);
+	static void 		MakeEditWindowFromBrowser( MWContext* mwcontext );
+
+						CEditorWindow(LStream * inStream);
+	virtual void 		FinishCreateSelf();
+	virtual void		SetWindowContext(CBrowserContext* inContext);
+
+	// ¥¥ Command handling
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual	Boolean 	ObeyCommand( CommandT inCommand, void *ioParam );
+	virtual void  		FindCommandStatus( CommandT inCommand,
+							Boolean& outEnabled, Boolean& outUsesMark, 
+							Char16& outMark,Str255 outName );
+	virtual void		NoteDocTitleChanged( const char* title );
+	virtual Boolean		AttemptQuitSelf( long inSaveOption );
+	static CEditorWindow*	FindAndShow(Boolean inMakeNew = false);
+	virtual void		SetPluginDoneClosing() { mPluginDoneClosing = true; }
+
+protected:
+
+	virtual ResIDT		GetStatusResID(void) const { return CEditorWindow::res_ID; }
+
+	Boolean  			mPluginDoneClosing;
+};

mozilla/cmd/macfe/Composer/CFontMenuAttachment.cp

@@ -0,0 +1,299 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "CFontMenuAttachment.h"
+#include "CEditView.h"
+#include "CBrowserContext.h"		// operator MWContext*()
+#include "resgui.h"					// cmd_FormatViewerFont, cmd_FormatFixedFont, FONT_MENU_BASE
+#include "macutil.h"				// CMediatedWindow
+#include "edt.h"
+
+
+
+LMenu *CFontMenuAttachment::sMenu = NULL;
+
+//===========================================================
+// CFontMenuAttachment
+//===========================================================
+CFontMenuAttachment::CFontMenuAttachment()
+{
+	UpdateMenu();
+}
+
+MWContext *CFontMenuAttachment::GetTopWindowContext()
+{
+							
+	// Ok, ok. I know this is skanky,
+	// but there is no common way to get the context from a window: it depends on the window type.
+	// So, we look around for a CEditView somewhere in the top window.
+	// A CEditView we understand (and get an MWContext from).
+	
+	CMediatedWindow* topWin = NULL;		// find the top window to use the plugin in
+	CWindowIterator iter(WindowType_Any);
+	iter.Next(topWin);
+	
+	if (topWin == NULL
+	|| ! (topWin->GetWindowType() == WindowType_Editor || topWin->GetWindowType() == WindowType_Compose) )
+		return NULL;
+	
+	CEditView *editView = (CEditView *)(topWin->FindPaneByID(CEditView::pane_ID));
+		
+	if (editView == NULL || editView->GetNSContext() == NULL)
+		return NULL;
+		
+	return editView->GetNSContext()->operator MWContext*();
+}
+
+
+// Processes:
+// 
+void CFontMenuAttachment::ExecuteSelf( MessageT inMessage, void* ioParam )
+{
+	mExecuteHost = FALSE;
+	switch ( inMessage )	
+	{
+		case msg_CommandStatus:
+		{
+			SCommandStatus*	status = (SCommandStatus*)ioParam;
+
+			EDT_CharacterData* better;
+			
+			if ( status->command == cmd_FormatViewerFont || status->command == cmd_FormatFixedFont 
+				|| ( status->command >= FONT_MENU_BASE && status->command <= FONT_MENU_BASE_LAST ) )
+			{
+				*(status->enabled) = true;
+				*(status->usesMark) = false;
+
+				better = NULL;
+				MWContext *cntxt = GetTopWindowContext();
+				if ( cntxt )
+					better = EDT_GetCharacterData( cntxt );
+				if ( better == NULL )
+				{
+					*(status->enabled) = false;
+					return;
+				}
+			}
+			
+			switch ( status->command )
+			{
+				case cmd_FormatViewerFont:
+					*(status->usesMark) = ( ! ( better->values & TF_FIXED ) && !( better->values & TF_FONT_FACE ) );
+					*(status->mark) = *(status->usesMark) ? checkMark : 0;
+					*(status->usesMark) = true;
+					
+					EDT_FreeCharacterData(better);
+					mExecuteHost = false;
+				 	return;
+					break;
+				
+				case cmd_FormatFixedFont:
+					*(status->usesMark) = ( better->values & TF_FIXED ) != 0;
+					*(status->mark) = *(status->usesMark) ? checkMark : 0;
+					*(status->usesMark) = true;
+					
+					EDT_FreeCharacterData(better);
+					mExecuteHost = false;
+					return;
+					break;
+				
+				default:
+					if ( status->command >= FONT_MENU_BASE && status->command <= FONT_MENU_BASE_LAST )
+					{
+						// get font menu item
+						Str255	fontItemString;
+						fontItemString[0] = 0;
+						MenuHandle menuh = GetMenu()->GetMacMenuH();
+						::GetMenuItemText ( menuh, status->command - FONT_MENU_BASE + PERM_FONT_ITEMS + 1, fontItemString );
+						p2cstr( fontItemString );
+
+// in mixed situation the mask bit will be cleared
+						*(status->usesMark) = ( better->values & TF_FONT_FACE && better->pFontFace && XP_STRLEN((char *)fontItemString) > 0 
+												&& XP_STRSTR( better->pFontFace, (char *)fontItemString ) != NULL );
+						*(status->mark) = *(status->usesMark) ? checkMark : 0;
+						*(status->usesMark) = true;
+
+						EDT_FreeCharacterData(better);
+						mExecuteHost = false;
+						return;
+					}
+			}
+		}
+		break;
+		
+		case cmd_FormatViewerFont:
+			MWContext *cntxt2 = GetTopWindowContext();
+			if ( cntxt2 )
+				EDT_SetFontFace( cntxt2, NULL, 0, NULL );
+			break;
+		
+		case cmd_FormatFixedFont:
+			MWContext *cntxt3 = GetTopWindowContext();
+			if ( cntxt3 )
+				EDT_SetFontFace( cntxt3, NULL, 1, NULL );
+			break;
+		
+		default:
+		{
+			if ( inMessage >= FONT_MENU_BASE && inMessage <= FONT_MENU_BASE_LAST )
+			{
+				MWContext *cntxt2 = GetTopWindowContext();
+				if ( cntxt2 )
+				{
+					// get font menu item
+					Str255	newFontItemString;
+					newFontItemString[0] = 0;
+					MenuHandle menuh = GetMenu()->GetMacMenuH();
+					::GetMenuItemText ( menuh, inMessage - FONT_MENU_BASE + PERM_FONT_ITEMS + 1, newFontItemString );
+					p2cstr( newFontItemString );
+					
+					EDT_SetFontFace( cntxt2, NULL, -1, (char *)newFontItemString );
+					
+					mExecuteHost = false;
+					return;
+ 				}
+			}
+		}
+		break;			
+	}
+	
+	mExecuteHost = TRUE;	// Let application handle it
+}
+
+LMenu *CFontMenuAttachment::GetMenu()
+{
+	if (!sMenu)
+		sMenu = new LMenu(cFontMenuID);
+	
+	return sMenu;
+}
+
+// build the font menu from the system
+void CFontMenuAttachment::UpdateMenu()
+{
+	if (!GetMenu() || !LMenuBar::GetCurrentMenuBar())
+		return;
+	
+	int i;
+	
+	// ¥ delete all the menu items after the separator line
+	MenuHandle menu = sMenu->GetMacMenuH();
+	if ( menu )
+	{
+		for ( i = ::CountMItems( menu ); i > PERM_FONT_ITEMS; i-- )
+			sMenu->RemoveItem( i );
+	}
+	
+	Try_
+	{
+		ThrowIfNil_( menu );
+	
+		// Add fonts to menu
+		::InsertResMenu( menu, 'FONT', PERM_FONT_ITEMS );
+		
+		int	commandNum = FONT_MENU_BASE;
+		int newHowMany = ::CountMItems( menu );
+		for (i = PERM_FONT_ITEMS + 1; i <= newHowMany; i++ )
+			sMenu->SetCommand( i, commandNum++ );
+	}
+	Catch_( inErr )
+	{
+	}
+	EndCatch_
+}
+
+
+void CFontMenuAttachment::RemoveMenus()
+{
+	if (sMenu)
+	{
+		LMenuBar *currentMenuBar = LMenuBar::GetCurrentMenuBar();
+		if (currentMenuBar)
+			currentMenuBar->RemoveMenu(sMenu);
+	}
+}
+
+
+void CFontMenuAttachment::InstallMenus()
+{
+	if (sMenu)
+	{
+		LMenuBar *currentMenuBar = LMenuBar::GetCurrentMenuBar();
+		if (currentMenuBar)
+		{
+			StValueChanger<EDebugAction> okayToFail(gDebugThrow, debugAction_Nothing);
+			currentMenuBar->InstallMenu(sMenu, hierMenu);
+			
+			ResIDT resID;
+			MenuHandle menuh;
+			Int16 whichItem;
+			currentMenuBar->FindMenuItem( cmd_ID_toSearchFor, resID, menuh, whichItem );
+			if ( menuh )
+			{
+				// make it hierarchical
+				::SetItemCmd( menuh, whichItem, hMenuCmd );
+				::SetItemMark( menuh, whichItem, menu_ID );
+			}
+		}
+	}
+}
+
+#pragma mark -
+
+CFontMenuPopup::CFontMenuPopup( LStream *inStream ) : CPatternButtonPopupText( inStream )
+{
+}
+
+CFontMenuPopup::~CFontMenuPopup()
+{
+}
+
+void CFontMenuPopup::FinishCreateSelf( void )
+{
+	CPatternButtonPopupText::FinishCreateSelf();
+
+	int i;
+	
+	// ¥ delete all the menu items after the separator line
+	LMenu *ppmenu = GetMenu();
+	MenuHandle menuh = ppmenu ? ppmenu->GetMacMenuH() : NULL;
+	if ( menuh )
+	{
+		for ( i = ::CountMItems( menuh ); i > CFontMenuAttachment::PERM_FONT_ITEMS; i-- )
+			ppmenu->RemoveItem( i );
+	}
+	
+	Try_
+	{
+		ThrowIfNil_( menuh );
+	
+		// Add fonts to menu
+		::InsertResMenu( menuh, 'FONT', CFontMenuAttachment::PERM_FONT_ITEMS );
+		
+		int	commandNum = FONT_MENU_BASE;
+		int newHowMany = ::CountMItems( menuh );
+		for (i = CFontMenuAttachment::PERM_FONT_ITEMS + 1; i <= newHowMany; i++ )
+			ppmenu->SetCommand( i, commandNum++ );
+		
+		SetMaxValue( newHowMany );
+	}
+	Catch_( inErr )
+	{
+	}
+	EndCatch_
+}

mozilla/cmd/macfe/Composer/CFontMenuAttachment.h

@@ -0,0 +1,73 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#ifndef CFONTMENUATTACHMENT_H_
+#define CFONTMENUATTACHMENT_H_
+
+#include <LAttachment.h>
+#include "CPatternButtonPopupText.h"
+#include "ntypes.h"	// MWContext
+
+
+class LMenu;
+
+/***********************************************************************************
+ * CFontMenuAttachment
+ * Processes Font menu commands -- should be attached to application
+ * Currently, this menu is only used in the Editor and mail compose window
+ ***********************************************************************************/
+class CFontMenuAttachment: public LAttachment
+{
+public:
+	enum { menu_ID = 13, PERM_FONT_ITEMS = 3, cmd_ID_toSearchFor = 'FONT' };
+
+	// ¥¥ constructors
+						CFontMenuAttachment();
+	// ¥¥Êevents
+	virtual void		ExecuteSelf( MessageT inMessage, void* ioParam );
+
+	static LMenu*		GetMenu();
+	static void			UpdateMenu();
+
+	static void			RemoveMenus();
+	static void			InstallMenus();
+	
+protected:
+	static MWContext*	GetTopWindowContext();
+
+	static LMenu*		sMenu;
+};
+
+
+
+class CFontMenuPopup : 	public CPatternButtonPopupText
+{
+	public:
+		enum { class_ID = 'Fpop' };
+		
+		static	void*	CreateCFontMenuPopupStream( LStream *inStream ) {return( new CFontMenuPopup (inStream ));};
+						CFontMenuPopup( LStream *inStream );		//	¥ Constructor
+						~CFontMenuPopup();							//	¥ Destructor
+
+						// ¥ drawing
+		void			FinishCreateSelf(void);
+};
+
+#endif

mozilla/cmd/macfe/Composer/CFormattingToolBar.cp

@@ -0,0 +1,124 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "CFormattingToolBar.h"
+#include "CEditView.h"
+#include "resgui.h"
+#include "edt.h"
+
+CFormattingToolBar::CFormattingToolBar(LStream * inStream) 
+							: CPatternBevelView(inStream)
+{
+}
+
+CFormattingToolBar::~CFormattingToolBar()
+{
+	mEditView = NULL;
+}
+
+void CFormattingToolBar::FinishCreateSelf()
+{
+	if ( GetSuperView() )
+	{
+		// get SuperView (we start with "this" so we're guaranteed non-0)
+		LView *superView = (LView *)this;
+		while (superView->GetSuperView() != NULL)
+			superView = superView->GetSuperView();
+		
+		mEditView = dynamic_cast<CEditView*>(superView->FindPaneByID( CEditView::pane_ID ));
+	}
+	else
+		mEditView = dynamic_cast<CEditView*>(FindPaneByID( CEditView::pane_ID ));
+
+	// if we have a mailcompose window show insert object popup menu
+	// check for presence of insert menu within CFormattingToolBar
+	LPane *pane = FindPaneByID('InsO');
+	if ( pane )
+	{
+		CMailEditView *mailview = dynamic_cast<CMailEditView*>( mEditView );
+		if ( mailview )
+			pane->Show();
+		else
+			pane->Hide();
+	}
+	
+	UReanimator::LinkListenerToControls(this, this, 11616);
+}
+
+void CFormattingToolBar::ListenToMessage( MessageT inMessage, void* ioParam )
+{
+	PaneIDT paneID = CEditView::pane_ID;
+	
+	if ( mEditView == NULL )
+		return;
+	
+	if ( inMessage == 'Para' )
+	{
+		switch  (*(long*)ioParam)
+		{
+			case 1:		inMessage = cmd_Format_Paragraph_Normal;		break;
+			case 2:		inMessage = cmd_Format_Paragraph_Head1;			break;
+			case 3:		inMessage = cmd_Format_Paragraph_Head2;			break;
+			case 4:		inMessage = cmd_Format_Paragraph_Head3;			break;
+			case 5:		inMessage = cmd_Format_Paragraph_Head4;			break;
+			case 6:		inMessage = cmd_Format_Paragraph_Head5;			break;
+			case 7:		inMessage = cmd_Format_Paragraph_Head6;			break;
+			case 8:		inMessage = cmd_Format_Paragraph_Address;		break;
+			case 9:		inMessage = cmd_Format_Paragraph_Formatted;		break;
+			case 10:	inMessage = cmd_Format_Paragraph_List_Item;		break;
+			case 11:	inMessage = cmd_Format_Paragraph_Desc_Title;	break;
+			case 12:	inMessage = cmd_Format_Paragraph_Desc_Text;		break;
+		}
+	}
+	else if ( inMessage == 'Size' )
+	{
+		switch  (*(long*)ioParam)
+		{
+			case 1:		inMessage = cmd_Format_Font_Size_N2;	break;
+			case 2:		inMessage = cmd_Format_Font_Size_N1;	break;
+			case 3:		inMessage = cmd_Format_Font_Size_0;		break;
+			case 4:		inMessage = cmd_Format_Font_Size_P1;	break;
+			case 5:		inMessage = cmd_Format_Font_Size_P2;	break;
+			case 6:		inMessage = cmd_Format_Font_Size_P3;	break;
+			case 7:		inMessage = cmd_Format_Font_Size_P4;	break;
+		}
+	}
+	else if ( inMessage == 'Algn' )
+	{
+		switch  (*(long*)ioParam)
+		{
+			case 1:		inMessage = cmd_JustifyLeft;	break;
+			case 2:		inMessage = cmd_JustifyCenter;	break;
+			case 3:		inMessage = cmd_JustifyRight;	break;
+		}
+	}
+	else if ( inMessage == 'InsO' )
+	{
+		switch  (*(long*)ioParam)
+		{
+			case 1:		inMessage = cmd_Insert_Link;	break;
+			case 2:		inMessage = cmd_Insert_Target;	break;
+			case 3:		inMessage = cmd_Insert_Image;	break;
+			case 4:		inMessage = cmd_Insert_Line;	break;
+			case 5:		inMessage = cmd_Insert_Table;	break;
+		}
+	}
+
+	mEditView->ObeyCommand( inMessage, ioParam );
+}
+

mozilla/cmd/macfe/Composer/CFormattingToolBar.h

@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#include "CPatternBevelView.h"
+#include <LListener.h>
+
+class CEditView;
+
+
+// used in Editor window and Mail Compose windows
+
+class CFormattingToolBar : public CPatternBevelView, public LListener
+{
+public:
+	enum {class_ID = 'FoTB'};
+					CFormattingToolBar(LStream * inStream);
+					~CFormattingToolBar();
+
+	virtual void	ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual void	FinishCreateSelf();
+
+protected:
+	CEditView* 		mEditView;
+};
+

mozilla/cmd/macfe/Composer/COpenRecentlyEditedPopup.cp

@@ -0,0 +1,184 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ===========================================================================
+//	COpenRecentlyEditedPopup.cp
+// ===========================================================================
+
+#include "COpenRecentlyEditedPopup.h"
+		
+#include "CWindowMediator.h"
+#include "CBrowserContext.h"
+#include "CEditorWindow.h"
+#include "UMenuUtils.h"
+#include "PascalString.h"
+
+#include "net.h"		// NET_CreateURLStruct
+#include "structs.h"	// TagType which is needed in edt.h
+#include "edt.h"
+
+		
+// ---------------------------------------------------------------------------
+//		¥ CreateNavigationButtonPopupStream [static]
+// ---------------------------------------------------------------------------
+
+COpenRecentlyEditedPopup*
+COpenRecentlyEditedPopup::CreateOpenRecentlyEditedPopupStream( LStream* inStream )
+{
+	return new COpenRecentlyEditedPopup(inStream);
+}
+		
+// ---------------------------------------------------------------------------
+//		¥ COpenRecentlyEditedPopup
+// ---------------------------------------------------------------------------
+
+COpenRecentlyEditedPopup::COpenRecentlyEditedPopup( LStream* inStream )
+	:	mBrowserContext(nil),
+		super(inStream)
+{
+}
+
+// ---------------------------------------------------------------------------
+//		¥ ~COpenRecentlyEditedPopup
+// ---------------------------------------------------------------------------
+
+COpenRecentlyEditedPopup::~COpenRecentlyEditedPopup()
+{
+}
+	
+#pragma mark -
+
+// ---------------------------------------------------------------------------
+//		¥ AdjustMenuContents
+// ---------------------------------------------------------------------------
+
+void
+COpenRecentlyEditedPopup::AdjustMenuContents()
+{
+	if (!GetMenu() || !GetMenu()->GetMacMenuH())
+		return;
+	
+	if (!AssertPreconditions())
+		return;
+		
+	// Purge the menu
+	UMenuUtils::PurgeMenuItems(GetMenu()->GetMacMenuH(), PERM_OPEN_ITEMS);
+	
+	// Fill the menu
+	int i;
+	char *urlp = NULL, *titlep = NULL;
+	for ( i = 0; i < MAX_EDIT_HISTORY_LOCATIONS 
+				&& EDT_GetEditHistory( ((MWContext *)(*mBrowserContext)), i, &urlp, &titlep ); i++ )
+	{
+		// strange logic:  if we have no URL (then how do we go there???) then use title if it exists
+		if ( urlp == NULL )
+			urlp = titlep;
+		
+		if ( urlp )
+		{
+			NET_UnEscape( urlp );
+			InsertItemIntoMenu( urlp, PERM_OPEN_ITEMS + i );
+		}
+		else
+			break;
+	}
+	
+	// delete menu break line if we don't have any history items
+	if ( i == 0 )
+	{
+		::DeleteMenuItem( GetMenu()->GetMacMenuH(), PERM_OPEN_ITEMS );
+	}
+
+	// Set the min/max values of the control since we populated the menu
+	SetPopupMinMaxValues();
+}
+
+// ---------------------------------------------------------------------------
+//		¥ InsertItemIntoMenu
+// ---------------------------------------------------------------------------
+
+void
+COpenRecentlyEditedPopup::InsertItemIntoMenu( char *urlp, Int16 inAfterItem )
+{
+	Assert_(GetMenu() && GetMenu()->GetMacMenuH());
+	Assert_(mBrowserContext);
+	CStr255 thePString( urlp );
+
+	// Insert a "blank" item first...
+	::InsertMenuItem( GetMenu()->GetMacMenuH(), "\p ", inAfterItem + 1 );
+	
+	// Then change it. We do this so that no interpretation of metacharacters will occur.
+	::SetMenuItemText( GetMenu()->GetMacMenuH(), inAfterItem + 1, thePString );
+}
+	
+#pragma mark -
+
+// ---------------------------------------------------------------------------
+//		¥ HandleNewValue
+// ---------------------------------------------------------------------------
+
+Boolean
+COpenRecentlyEditedPopup::HandleNewValue( Int32 inNewValue )
+{
+	if ( inNewValue >= 1 && inNewValue < PERM_OPEN_ITEMS )
+	{
+		// someone else will handle this
+		return false;
+	}
+	
+	if ( AssertPreconditions() && inNewValue )
+	{
+		MWContext *cntxt = ((MWContext *)(*mBrowserContext));
+		if ( cntxt )
+		{
+			char *aURLtoOpen = NULL;
+			// EDT_GetEditHistory is 0-based so deduct 1 from 2nd parameter
+			if ( EDT_GetEditHistory( cntxt, inNewValue - PERM_OPEN_ITEMS - 1, &aURLtoOpen, NULL) )
+			{
+				URL_Struct* theURL = NET_CreateURLStruct( aURLtoOpen, NET_NORMAL_RELOAD );
+				if ( theURL )
+					CEditorWindow::MakeEditWindow( NULL, theURL );
+			}
+		}
+	}
+	
+	return true;
+}
+
+// ---------------------------------------------------------------------------
+//		¥ AssertPreconditions
+// ---------------------------------------------------------------------------
+//	Assert preconditions and fill in interesting member data
+
+Boolean
+COpenRecentlyEditedPopup::AssertPreconditions()
+{	
+	CMediatedWindow* topWindow = CWindowMediator::GetWindowMediator()->FetchTopWindow( WindowType_Any, regularLayerType );
+	
+	if (!topWindow || topWindow->GetWindowType() != WindowType_Editor)
+		return false;
+	
+	CEditorWindow* composerWindow = dynamic_cast<CEditorWindow*>(topWindow);
+	if ( !composerWindow )
+		return false;
+	
+	if ( !(mBrowserContext = (CBrowserContext*)composerWindow->GetWindowContext()) )
+		return false;
+	
+	return true;
+}

mozilla/cmd/macfe/Composer/COpenRecentlyEditedPopup.h

@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ===========================================================================
+//	COpenRecentlyEditedPopup.h
+// ===========================================================================
+
+#ifndef COpenRecentlyEditedPopup_H
+#define COpenRecentlyEditedPopup_H
+#pragma once
+
+// Includes
+
+#include "CPatternButtonPopup.h"
+
+// Forward declarations
+
+class CBrowserContext;
+
+// Class declaration
+
+class COpenRecentlyEditedPopup : public CPatternButtonPopup
+{
+public:
+	enum { class_ID = 'PbRc', PERM_OPEN_ITEMS = 3 };
+
+	typedef CPatternButtonPopup super;
+							
+	static COpenRecentlyEditedPopup*	CreateOpenRecentlyEditedPopupStream(LStream* inStream);
+
+							COpenRecentlyEditedPopup(LStream* inStream);
+	virtual	 				~COpenRecentlyEditedPopup();
+	
+protected:
+	virtual void			AdjustMenuContents();
+
+	virtual void			InsertItemIntoMenu( char 	*urlp,
+												Int16	inAfterItem );
+
+	virtual Boolean			HandleNewValue(Int32 inNewValue);
+
+	Boolean					AssertPreconditions();
+
+	CBrowserContext*		mBrowserContext;
+};
+
+
+#endif

mozilla/cmd/macfe/Composer/CRecentEditMenuAttachment.cp

@@ -0,0 +1,210 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//===========================================================
+// CRecentEditMenuAttachment.cp
+//===========================================================
+
+#include "CRecentEditMenuAttachment.h"
+#include "CEditView.h"
+#include "CBrowserContext.h"				//	operator MWContext*()
+#include "resgui.h"
+#include "macutil.h"						//	CMediatedWindow
+#include "UMenuUtils.h"
+#include "edt.h"
+#include "CEditorWindow.h"
+
+
+
+LMenu *CRecentEditMenuAttachment::sMenu = NULL;
+
+CRecentEditMenuAttachment::CRecentEditMenuAttachment()
+{
+	UpdateMenu();
+}
+
+MWContext *CRecentEditMenuAttachment::GetTopWindowContext()
+{
+	// Ok, ok. I know this is skanky,
+	// but there is no common way to get the context from a window: it depends on the window type.
+	// So, we look around for a CEditView somewhere in the top window.
+	// A CEditView we understand (and get an MWContext from).
+	
+	CMediatedWindow* topWin = NULL;		// find the top window to use the plugin in
+	CWindowIterator iter(WindowType_Any);
+	iter.Next(topWin);
+	
+	if (topWin == NULL
+	|| ! (topWin->GetWindowType() == WindowType_Editor || topWin->GetWindowType() == WindowType_Compose) )
+		return NULL;
+	
+	CEditView *editView = (CEditView *)(topWin->FindPaneByID(CEditView::pane_ID));
+		
+	if (editView == NULL || editView->GetNSContext() == NULL)
+		return NULL;
+		
+	return editView->GetNSContext()->operator MWContext*();
+}
+
+
+// Processes
+void CRecentEditMenuAttachment::ExecuteSelf( MessageT inMessage, void* ioParam )
+{
+	switch ( inMessage )	
+	{
+		case msg_CommandStatus:
+		{
+			SCommandStatus*	status = (SCommandStatus*)ioParam;
+			
+			if ( status->command >= RECENT_EDIT_MENU_BASE && status->command <= RECENT_EDIT_MENU_BASE_LAST )
+			{
+				*(status->enabled) = true;
+				mExecuteHost = false;
+				return;
+			}
+		}
+		break;
+		
+		default:
+		{
+			if ( inMessage >= RECENT_EDIT_MENU_BASE && inMessage <= RECENT_EDIT_MENU_BASE_LAST )
+			{
+				MWContext *cntxt2 = GetTopWindowContext();
+				if ( cntxt2 )
+				{
+					char *aURLtoOpen = NULL;
+        			if ( EDT_GetEditHistory( cntxt2, inMessage - RECENT_EDIT_MENU_BASE - 1, &aURLtoOpen, NULL) )
+					{
+						URL_Struct* theURL = NET_CreateURLStruct( aURLtoOpen, NET_NORMAL_RELOAD );
+						if ( theURL )
+							CEditorWindow::MakeEditWindow( NULL, theURL );
+
+						mExecuteHost = false;
+						return;
+ 					}
+ 				}
+			}
+		}
+		break;			
+	}
+	
+	mExecuteHost = true;	// Let application handle it
+}
+
+
+LMenu *CRecentEditMenuAttachment::GetMenu()
+{
+	if (!sMenu)
+		sMenu = new LMenu( menu_ID );
+	
+	return sMenu;
+}
+
+
+// build the font menu from the system
+void CRecentEditMenuAttachment::UpdateMenu()
+{
+	if (!GetMenu() || !LMenuBar::GetCurrentMenuBar())
+		return;
+	
+	int i;
+	
+	// ¥ delete all the menu items after the separator line
+	MenuHandle menu = sMenu->GetMacMenuH();
+	if ( menu )
+	{
+		for ( i = ::CountMItems( menu ); i > 0; i-- )
+			sMenu->RemoveItem( i );
+	}
+	
+	Try_
+	{
+		ThrowIfNil_( menu );
+	
+		// Add recently edited URLs to menu
+		
+		int i;
+		char *urlp = NULL, *titlep = NULL;
+		
+		for ( i = 0; i < MAX_EDIT_HISTORY_LOCATIONS 
+					&& EDT_GetEditHistory( GetTopWindowContext(), i, &urlp, &titlep ); i++ )
+		{
+			NET_UnEscape( urlp );
+			
+			// convert string to pascal-string for menu
+			CStr255 menuStr(urlp);
+			if ( menuStr.IsEmpty() )
+				menuStr = titlep;
+			
+			if ( !menuStr.IsEmpty() )
+			{
+				// Insert a "blank" item first...
+				::InsertMenuItem( GetMenu()->GetMacMenuH(), "\p ", i );
+	
+				// Then change it. We do this so that no interpretation of metacharacters will occur.
+				::SetMenuItemText( GetMenu()->GetMacMenuH(), i + 1, menuStr );
+				
+				// SetCommand for menu item
+				sMenu->SetCommand( i, RECENT_EDIT_MENU_BASE + i );
+				sMenu->SetUsed( true );
+			}
+			else
+				break;
+		}
+	}
+	Catch_( inErr )
+	{
+	}
+	EndCatch_
+}
+
+
+void CRecentEditMenuAttachment::RemoveMenus()
+{
+	if (sMenu)
+	{
+		LMenuBar *currentMenuBar = LMenuBar::GetCurrentMenuBar();
+		if (currentMenuBar)
+			currentMenuBar->RemoveMenu(sMenu);
+	}
+}
+
+
+void CRecentEditMenuAttachment::InstallMenus()
+{
+	if (sMenu)
+	{
+		LMenuBar *currentMenuBar = LMenuBar::GetCurrentMenuBar();
+		if (currentMenuBar)
+		{
+			StValueChanger<EDebugAction> okayToFail(gDebugThrow, debugAction_Nothing);
+			currentMenuBar->InstallMenu(sMenu, hierMenu);
+			
+			ResIDT resID;
+			MenuHandle menuh;
+			Int16 whichItem;
+			currentMenuBar->FindMenuItem( cmd_ID_toSearchFor, resID, menuh, whichItem );
+			if ( menuh )
+			{
+				// make it hierarchical
+				::SetItemCmd( menuh, whichItem, hMenuCmd );
+				::SetItemMark( menuh, whichItem, menu_ID );
+			}
+		}
+	}
+}

mozilla/cmd/macfe/Composer/CRecentEditMenuAttachment.h

@@ -0,0 +1,55 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#ifndef CRECENTEDITMENUATTACHMENT_H_
+#define CRECENTEDITMENUATTACHMENT_H_
+
+#include <LAttachment.h>
+#include <LMenu.h>
+#include "ntypes.h"
+
+/***********************************************************************************
+ * CRecentEditMenuAttachment
+ * Processes Recent-Edited files menu commands -- should be attached to application
+ * Currently, this menu is only used in the Editor window
+ ***********************************************************************************/
+class CRecentEditMenuAttachment: public LAttachment
+{
+public:
+	enum { menu_ID = 24, cmd_ID_toSearchFor = 'Rece' };
+	
+	// ¥¥ constructors
+						CRecentEditMenuAttachment();
+	// ¥¥Êevents
+	virtual void		ExecuteSelf( MessageT inMessage, void* ioParam );
+
+	static LMenu*		GetMenu();
+	static void			UpdateMenu();
+
+	static void			RemoveMenus();
+	static void			InstallMenus();
+	
+protected:
+	static MWContext*	GetTopWindowContext();
+
+	static LMenu*		sMenu;
+};
+
+#endif

mozilla/cmd/macfe/Composer/CSpellChecker.h

@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#include "spellchk.h"
+#include "ntypes.h"		// MWContext
+
+class CEditView;
+class LEditField;
+class CTextTable;
+class CSimpleTextView;
+
+// public definitions
+void do_spellcheck( MWContext *mwcontext, CEditView *editView, CSimpleTextView *textView );
+#define cmd_CheckSpelling					'ChSp'
+
+
+// internal
+const int SpellCheckerResource = 5109;
+const int ChangeStringIndex = 1;
+const int DoneStringIndex = 2;
+const int NSDictionaryNameIndex = 3;
+const int UserDictionaryNameIndex = 4;
+
+
+// UI management class
+class CMacSpellChecker
+{
+public:
+	enum { class_ID = 'Spel', res_ID = 5299 };
+	enum { pane_NewWord = 'NewW', pane_SuggestionList = 'AltW',
+			msg_Change = 'Chng', msg_Change_All = 'CAll', 
+			msg_Ignore = 'Ignr', msg_Ignore_All = 'IAll',
+			msg_Add_Button = 'AddB', msg_Check = 'Chck',
+			msg_Stop = 'Stop', msg_NewLanguage = 'Lang',
+			msg_SelectionChanged = 'SelC', msg_EditDictionary = 'EdDc' };
+	
+				CMacSpellChecker( MWContext *context,
+									CEditView *editView, CSimpleTextView *textView );
+	
+	char		*GetTextBuffer();
+	void		GetSelection( int32 &selStart, int32 &selEnd );
+	void		ReplaceHilitedText( char *newText, Boolean doAll );
+	void		IgnoreHilitedText( Boolean doAll );
+	void		SetNextMisspelledWord( char *textP, LEditField *typoField, CTextTable *t, LCommander *c );
+	Boolean		GetNextMisspelledWord( Boolean doFirstWord );
+	void		ClearReplacementWord( LEditField *newWord, CTextTable *table );
+	void		GetAlternativesForWord( LEditField *newWord, CTextTable *table, LCommander *c );
+	
+	Boolean		StartProcessing( Boolean startOver );
+	void		ShowDialog( char *textP );
+	
+	MWContext	*GetMWContext()	{ return mMWContext; };
+	ISpellChecker *GetISpellChecker()	{ return mISpellChecker; };
+	void		SetISpellChecker( ISpellChecker *i ) { mISpellChecker = i; };
+	
+	Boolean		isHTMLeditor()	{ return mEditView != NULL; };
+	
+private:
+	ISpellChecker	*mISpellChecker;
+	MWContext		*mMWContext;	// only if mEditView; ignored if mTextView
+	Str255			mOrigMisspelledWord;
+	
+	// we should have one and only one of these-->evidence that this class is mis-designed
+	CEditView		*mEditView;
+	CSimpleTextView	*mTextView;
+};

mozilla/cmd/macfe/Composer/CToolsAttachment.cp

@@ -0,0 +1,338 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "CToolsAttachment.h"
+
+#include "CEditView.h"
+#include "CBrowserContext.h"		// operator MWContext*()
+#include "resgui.h"					// TOOLS_MENU_BASE_LAST
+#include "macutil.h"				// CMediatedWindow
+#include "UMenuUtils.h"
+#include "edt.h"
+//#include "CSpellChecker.h"
+#include <LArray.h>
+
+
+#define PERM_TOOLS_ITEMS 2
+#define PERM_TOOLS_END_ITEMS 1
+
+const CommandT cmd_ToolsHierItem = TOOLS_MENU_BASE_LAST;
+
+LMenu *CToolsAttachment::sMenu = NULL;
+Boolean CToolsAttachment::sInvalidMenu = true;
+LArray CToolsAttachment::sMenusList;
+
+//===========================================================
+// CToolsAttachment
+//===========================================================
+CToolsAttachment::CToolsAttachment()
+{
+}
+
+
+MWContext *CToolsAttachment::GetTopWindowContext()
+{
+	// Ok, ok. I know this is skanky,
+	// but there is no common way to get the context from a window: it depends on the window type.
+	// So, we look around for a CEditView somewhere in the top window.
+	// A CEditView we understand (and get an MWContext from).
+	
+	CMediatedWindow* topWin = NULL;		// find the top window to use the plugin in
+	CWindowIterator iter(WindowType_Any);
+//	do {
+		iter.Next(topWin);
+//	} while (topWin && topWin->GetWindowType() != WindowType_Editor && topWin->GetWindowType() != WindowType_Compose);
+				
+	if (topWin == NULL)
+		return NULL;
+	
+	if ( topWin->GetWindowType() != WindowType_Editor && topWin->GetWindowType() != WindowType_Compose )
+		return NULL;
+	
+	CEditView *editView = (CEditView *)(topWin->FindPaneByID(CEditView::pane_ID));
+		
+	if (editView == NULL || editView->GetNSContext() == NULL)
+		return NULL;
+		
+	return editView->GetNSContext()->operator MWContext*();
+}
+
+
+// Processes:
+void CToolsAttachment::ExecuteSelf( MessageT inMessage, void* ioParam )
+{
+	mExecuteHost = FALSE;
+	switch ( inMessage )	
+	{
+//		case cmd_CheckSpelling:		// spell checker
+//			return;
+		
+		case cmd_EditorPluginStop:
+			MWContext *cntxt = GetTopWindowContext();
+			if (cntxt)
+				EDT_StopPlugin(cntxt);
+			return;
+		
+		case msg_CommandStatus:
+		{
+			SCommandStatus*		status = (SCommandStatus*)ioParam;
+				
+			switch ( status->command )
+			{
+				case cmd_EditorPluginStop:
+					MWContext *cntxt = GetTopWindowContext();
+					*(status->enabled) = cntxt && EDT_IsPluginActive(cntxt);
+					*(status->usesMark) = FALSE;
+					return;
+					
+				default:
+					if ( status->command >= TOOLS_MENU_BASE && status->command <= TOOLS_MENU_BASE_LAST )
+					{
+					 	*(status->enabled) = TRUE;
+					 	*(status->usesMark) = FALSE;
+						return;
+					}
+				break;
+			}
+		}
+		break;
+		
+		default:
+		{
+			if ( inMessage >= TOOLS_MENU_BASE && inMessage <= TOOLS_MENU_BASE_LAST )
+			{
+				int32 index = inMessage - TOOLS_MENU_BASE;
+				
+				for (int32 CategoryIndex = 0; CategoryIndex < EDT_NumberOfPluginCategories(); CategoryIndex++)
+					for (int32 PluginIndex = 0; PluginIndex < EDT_NumberOfPlugins(CategoryIndex); PluginIndex++)
+						if (index-- == 0)
+						{		// count down until we find which one...
+							MWContext *cntxt = GetTopWindowContext();
+							if (cntxt)
+								EDT_PerformPlugin(cntxt, CategoryIndex, PluginIndex, 0, 0);		// what is the result for?
+
+							return;
+						}
+			}
+		}
+		break;			
+	}
+	mExecuteHost = TRUE;	// Let application handle it
+}
+
+
+LMenu *CToolsAttachment::GetMenu()
+{
+	if (!sMenu)
+		sMenu = new LMenu(cToolsMenuID);
+	
+	return sMenu;
+}
+
+void CToolsAttachment::UpdateMenu()
+{
+	if (!sInvalidMenu || !GetMenu() || !LMenuBar::GetCurrentMenuBar())
+		return;
+	
+	int i;
+	
+	// ¥ delete all the dynamically created menus
+	// ¥Êdelete all the hierarchical menus we have added from the menubar
+	for ( i = 1; i <= sMenusList.GetCount(); i++ )
+	{
+		LMenu* m;
+		sMenusList.FetchItemAt( i, &m );
+		if ( m )
+			LMenuBar::GetCurrentMenuBar()->RemoveMenu( m );
+		delete m;
+	}
+
+	// ¥ delete all the menu items after the line in Tools menu
+	MenuHandle menu = sMenu->GetMacMenuH();
+	if ( menu )
+	{
+		int howMany = ::CountMItems( menu );
+		for ( i = howMany - PERM_TOOLS_END_ITEMS; i > PERM_TOOLS_ITEMS; i-- )
+			sMenu->RemoveItem( i );
+	}
+	sMenusList.RemoveItemsAt( sMenusList.GetCount(), 1 );
+
+	int	whichItem = PERM_TOOLS_ITEMS;
+	int	commandNum = TOOLS_MENU_BASE;
+	int nextMenuID = cEditorPluginsFirstHierMenuID;
+	
+	Try_
+	{
+		ThrowIfNil_( sMenu );
+		MenuHandle		mHand = sMenu->GetMacMenuH();
+	
+		ThrowIfNil_( mHand );
+	
+		for (int32 CategoryIndex = 0; CategoryIndex < EDT_NumberOfPluginCategories(); CategoryIndex++) {
+		
+			CStr255 headerName( EDT_GetPluginCategoryName( CategoryIndex ) );
+			CreateMenuString( headerName );						// make sure it isn't too long
+
+			whichItem = UMenuUtils::InsertMenuItem(mHand, headerName, whichItem); // returns actual insert loc
+			sMenu->SetCommand(whichItem, cmd_ToolsHierItem);
+				
+			// ¥ Are there actually any menu items to put on this Hierarchical menu?
+			if (EDT_NumberOfPlugins(CategoryIndex)) {
+			
+				// ¥ do we have any hierarchical menus left? 
+				if (nextMenuID <= cEditorPluginsLastHierMenuID) {
+				
+					LMenu* subMenu = (LMenuBar::GetCurrentMenuBar())->FetchMenu( nextMenuID );
+					if ( !subMenu )
+					{
+						StringHandle menuStringH = GetString( NEW_RESID );
+						Assert_(menuStringH);
+						if (menuStringH)
+						{
+							StHandleLocker locker((Handle)menuStringH);
+							subMenu = new LMenu( nextMenuID,
+												(unsigned char *)*menuStringH );
+							LMenuBar::GetCurrentMenuBar()->InstallMenu( subMenu, hierMenu );
+						}
+					}
+					else
+						SysBeep( 1 );
+
+					nextMenuID++;
+					
+					if ( subMenu )
+					{
+						sMenusList.InsertItemsAt( 1, sMenusList.GetCount(),  &subMenu );
+						// ¥Êmake item hierarchical
+						::SetItemCmd( mHand, whichItem, hMenuCmd );
+						::SetItemMark( mHand, whichItem, subMenu->GetMenuID() );
+						FillMenu(
+								CategoryIndex,
+								subMenu,
+								commandNum,
+								0 );
+					}
+					
+				} else {
+					
+					// ¥ There are no hierarchical menus left,
+					// so we will just add these onto the bottom of the main tools menu.
+					// We have already put the (disabled) category name in the main tools menu
+					
+					FillMenu(
+							CategoryIndex,
+							sMenu,
+							commandNum,
+							whichItem );
+							
+					whichItem += EDT_NumberOfPlugins(CategoryIndex);
+				}
+				
+			}
+			
+		}
+		
+		// this is a hack. The menu item "Stop Active Plug-in" gets pushed around and loses its command. So, reset it.
+		sMenu->SetCommand(++whichItem, cmd_EditorPluginStop);
+
+	}
+	Catch_( inErr )
+	{
+	}
+	EndCatch_
+
+
+	sInvalidMenu = true;
+}
+
+void CToolsAttachment::FillMenu(
+	int32 CategoryIndex,
+	LMenu* newMenu,
+	int& commandNum,		// next menu to create
+	int whichItem )			// id of the first item to insert
+{
+	Try_
+	{
+		ThrowIfNil_( newMenu );
+		MenuHandle		mHand = newMenu->GetMacMenuH();
+	
+		ThrowIfNil_( mHand );
+	
+		for (int32 PluginIndex = 0; PluginIndex < EDT_NumberOfPlugins(CategoryIndex); PluginIndex++) {
+
+		 	// ¥ should really convert this to sMenu chars
+			CStr255 pluginName( EDT_GetPluginName( CategoryIndex, PluginIndex) );
+			CreateMenuString( pluginName );
+
+			whichItem = UMenuUtils::InsertMenuItem(mHand, pluginName, whichItem); // returns actual insert loc
+			newMenu->SetCommand(whichItem, commandNum++);
+			
+		}
+	}
+	Catch_( inErr )
+	{
+	}
+	EndCatch_
+}
+
+void CToolsAttachment::RemoveMenus()
+{
+	if (sMenu)
+	{
+		LMenuBar *currentMenuBar = LMenuBar::GetCurrentMenuBar();
+		
+		if (currentMenuBar)
+		{
+			currentMenuBar->RemoveMenu(sMenu);
+			
+			for (ArrayIndexT index = 1; index <= sMenusList.GetCount(); ++index)
+			{
+				LMenu *menu;
+				sMenusList.FetchItemAt(index, &menu);
+				
+				if (menu)
+					currentMenuBar->RemoveMenu(menu);
+			}
+		}
+	}
+}
+
+void CToolsAttachment::InstallMenus()
+{
+	if (sMenu)
+	{
+		LMenuBar *currentMenuBar = LMenuBar::GetCurrentMenuBar();
+		
+		if (currentMenuBar)
+		{
+			for (ArrayIndexT index = sMenusList.GetCount(); index > 0; --index)
+			{
+				LMenu *menu;
+				sMenusList.FetchItemAt(index, &menu);
+				
+				if (menu)
+				{
+					StValueChanger<EDebugAction> okayToFail(gDebugThrow, debugAction_Nothing);
+					currentMenuBar->InstallMenu(menu, hierMenu);
+				}
+			}
+			StValueChanger<EDebugAction> okayToFail(gDebugThrow, debugAction_Nothing);
+			currentMenuBar->InstallMenu(sMenu, InstallMenu_AtEnd);
+		}
+	}
+}

mozilla/cmd/macfe/Composer/CToolsAttachment.h

@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#ifndef CTOOLSATTACHMENT_H_
+#define CTOOLSATTACHMENT_H_
+
+#include <LAttachment.h>
+#include "ntypes.h"
+
+class LMenu;
+class LArray;
+
+/***********************************************************************************
+ * CToolsAttachment
+ * Processes Tools menu commands -- should be attached to application
+ * Currently, this menu is only used in the Editor window
+ ***********************************************************************************/
+class CToolsAttachment: public LAttachment
+{
+public:
+	// ¥¥ constructors
+						CToolsAttachment();
+	// ¥¥Êevents
+	virtual void		ExecuteSelf( MessageT inMessage, void* ioParam );
+
+	static LMenu*		GetMenu();
+	static void			InvalidateMenu() { sInvalidMenu = true; }
+	static void			UpdateMenu();
+
+	static void			RemoveMenus();
+	static void			InstallMenus();
+	
+protected:
+	static void			FillMenu(
+							int32 CategoryIndex,
+							LMenu* newMenu,
+							int& commandNum,
+							int whichItem );
+							
+	static MWContext*	GetTopWindowContext();
+
+	static LMenu*		sMenu;
+	static Boolean		sInvalidMenu;
+	static LArray		sMenusList;
+};
+
+#endif

mozilla/cmd/macfe/Composer/build/Composer_DebugPrefix.h

@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	Composer_DebugPrefix.h
+//
+//	NOTE:
+//			You typically won't need to change anything in this file.
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#include "MacPrefix_debug.h"
+ 
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	When we split out the procompiled headers seperately, we will not
+//		be including them here.  We will instead define things like
+//		PowerPlant_PCH and include them at the top of the applicable source
+//		modules
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#ifdef __powerc
+	#ifdef __cplusplus
+		#include "Composer_HeadersPPC++"
+	#else
+		#include "Composer_HeadersPPC"
+	#endif
+#else
+	#ifdef __cplusplus
+		#include "Composer_Headers68K++"
+	#else
+		#include "Composer_Headers68K"
+	#endif
+#endif
+
+

mozilla/cmd/macfe/Composer/build/Composer_Headers.pch

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	Composer_Headers.pch
+//
+//	NOTE:
+//
+//		You will typically not need to edit this file.  If you want to add
+//		a file to the C/C++ precompiled header, do it in Comm_Headers.c
+//		or Borwser_Headers.cp respectively.
+//
+//		If you're doing a non-debug build, use the non-debug project which
+//		will has pch files that generate non-debug dumps.  
+//
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#include "MacPrefix.h"
+
+#ifdef powerc
+	#pragma precompile_target "Composer_HeadersPPC"
+#else
+	#pragma precompile_target "Composer_Headers68K"
+#endif
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+// 	¥	Include the list of headers.
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#include "Comm_Headers.c"
+

mozilla/cmd/macfe/Composer/build/Composer_Headers.pch++

@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+// 
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	Composer_Headers.pch++
+//
+//	NOTE:
+//
+//		You will typically not need to edit this file.  If you want to add
+//		a file to the C/C++ precompiled header, do it in Comm_Headers.c
+//		or Borwser_Headers.cp respectively.
+//
+//		If you're doing a non-debug build, use the non-debug project which
+//		will has pch files that generate non-debug dumps.  
+//
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#include "MacPrefix.h"
+
+#ifdef powerc
+	#pragma precompile_target "Composer_HeadersPPC++"
+#else
+	#pragma precompile_target "Composer_Headers68K++"
+#endif
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+// 	¥	Include the headers.
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+extern "C" {
+	#include "Comm_Headers.c"
+}
+
+#include "Comm_Headers.cp"
+
+

mozilla/cmd/macfe/Composer/build/Composer_Prefix.h

@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	Composer_DebugPrefix.h
+//
+//	NOTE:
+//			You typically won't need to change anything in this file.
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#include "MacPrefix.h"
+ 
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	When we split out the procompiled headers seperately, we will not
+//		be including them here.  We will instead define things like
+//		PowerPlant_PCH and include them at the top of the applicable source
+//		modules
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#ifdef __powerc
+	#ifdef __cplusplus
+		#include "Composer_HeadersPPC++"
+	#else
+		#include "Composer_HeadersPPC"
+	#endif
+#else
+	#ifdef __cplusplus
+		#include "Composer_Headers68K++"
+	#else
+		#include "Composer_Headers68K"
+	#endif
+#endif
+
+

mozilla/cmd/macfe/Composer/meditdlg.h

@@ -0,0 +1,841 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+ 
+#pragma once
+
+#include "CTabSwitcher.h"
+#include "ntypes.h"	// MWContext
+#include "lo_ele.h"		// LO_Color
+#include "intl_csi.h"	// INTL_GetCSIWinCSID
+
+#ifdef COOL_IMAGE_RADIO_BUTTONS
+# include "CBevelButton.h"
+#endif
+
+class OneRowLListBox;
+class CColorButton;
+class CTabControl;
+class CLargeEditField;
+class LGAEditField;
+class LGAPopup;
+
+
+class CChameleonView: public LView
+{
+public:
+	enum				{ class_ID = 'cviw' };
+						CChameleonView(LStream * inStream) : LView(inStream) {};
+	virtual void		SetColor(RGBColor textColor);
+	virtual void		DrawSelf();	
+
+protected:
+
+	RGBColor			fTextColor;
+	
+};
+
+
+class CChameleonCaption: public LCaption
+{
+public:
+	enum				{class_ID = 'ccpt' };
+						CChameleonCaption(LStream * inStream) : LCaption(inStream) {};
+	virtual void		SetColor(RGBColor textColor, RGBColor backColor);
+	
+protected:
+
+	RGBColor			fTextColor;
+	RGBColor			fBackColor;
+	virtual void		DrawSelf();	
+};
+
+	
+// This class simply creates a dialog and extracts the context from the SuperCommand so
+// that we can set the values of the controls in the dialog based on the context which created it.
+
+class CEditDialog: public LDialogBox
+{
+public:
+						CEditDialog( LStream* inStream ): LDialogBox( inStream ), mUndoInited(false) { pExtra = NULL; }
+						~CEditDialog() { XP_FREEIF(pExtra); }
+	static Boolean		Start(ResIDT inWindowID, MWContext * context = NULL, short initTabValue = 0, Boolean insert = FALSE);
+
+	Boolean				AllowSubRemoval( LCommander *inSub );
+	void				FindCommandStatus( CommandT inCommand, Boolean &outEnabled, 
+									Boolean&, Char16&, Str255);
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+
+	virtual void		InitializeDialogControls() = NULL;
+	
+	void				SetContext(MWContext*	context) {fContext = context;}				
+	MWContext*			GetContext() { return fContext;}				
+
+	void				SetInitTabValue(short initValue) {fInitTabValue = initValue;}
+	short				GetInitTabValue() { return fInitTabValue;}
+					
+	void				SetInWindowID(ResIDT inWindowID) {fInWindowID = inWindowID;}
+	ResIDT				GetInWindowID() { return fInWindowID;}
+					
+	void				SetInsertFlag(Boolean insert) {fInsert = insert;}
+	Boolean				GetInsertFlag() { return fInsert;}
+
+	int16				GetWinCSID() { return INTL_GetCSIWinCSID(LO_GetDocumentCharacterSetInfo(fContext)); }
+
+	static void			ChooseImageFile(CLargeEditField* editField);
+
+protected:
+
+	virtual Boolean		CommitChanges(Boolean allPanes) = NULL;
+	virtual void		Help() = NULL;
+
+	MWContext*			fContext;
+			short		fInitTabValue;
+			Boolean		fInsert;
+			ResIDT		fInWindowID;
+
+	char*				pExtra;
+	Boolean				mUndoInited;
+};
+
+
+class CEditTabSwitcher: public CTabSwitcher
+{
+public:
+	enum				{ class_ID = 'EtSw' };
+	
+						CEditTabSwitcher(LStream* inStream);
+	virtual				~CEditTabSwitcher();
+						
+	virtual	void		DoPostLoad(LView* inLoadedPage, Boolean inFromCache);
+	void 				SetData(MWContext* context, Boolean insert);
+	void				Help();
+
+protected:	
+	MWContext*			fContext;
+	Boolean				fInsert;
+	char*				fLinkName;			// need to share between link and image pages
+	
+};
+
+
+class CTableInsertDialog: public CEditDialog
+{
+public:
+	enum				{ class_ID = 'ETBT' };
+	
+						CTableInsertDialog( LStream* inStream );
+	virtual				~CTableInsertDialog();
+						
+	virtual Boolean		CommitChanges(Boolean allPanes);
+	void				AdjustEnable();
+	virtual void		FinishCreateSelf();
+	virtual void		InitializeDialogControls();
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+
+protected:	
+	virtual void		Help();
+	
+	LGAEditField*		fNumRowsEditText;
+	LGAEditField*		fNumColsEditText;
+	
+	LControl*			fBorderCheckBox;
+	LGAEditField*		fBorderWidthEditText;
+	LGAEditField*		fCellSpacingEditText;
+	LGAEditField*		fCellPaddingEditText;
+	
+	LControl*			fCustomWidth;
+	LGAEditField*		fWidthEditText;
+	LControl*			fWidthPopup;
+	
+	LControl*			fCustomHeight;
+	LGAEditField*		fHeightEditText;
+	LControl*			fHeightPopup;
+	
+	LControl*			fCustomColor;
+	CColorButton*		fColorCustomColor;
+
+	LControl*			fCaptionAboveBelow;
+	
+	LGAPopup*			mTableAlignment;
+	
+	LControl*			mFastLayout;
+	LControl*			mUseImage;
+	CLargeEditField*	mImageFileName;
+	LControl*			mLeaveImage;
+};
+
+
+class CFormatMsgColorAndImageDlog: public CEditDialog
+{
+public:
+	enum				{ class_ID = 'Ec+i' };
+	
+						CFormatMsgColorAndImageDlog( LStream* inStream ) : CEditDialog( inStream ) {;}
+	virtual				~CFormatMsgColorAndImageDlog() {;}
+						
+	virtual Boolean		CommitChanges(Boolean allPanes);
+	virtual void		InitializeDialogControls();
+
+protected:	
+	virtual void		Help();
+};
+
+
+class CTarget: public CEditDialog
+{
+public:
+	enum				{ class_ID = 'ETRG' };
+	
+						CTarget( LStream* inStream );
+	virtual				~CTarget();
+						
+	void				CleanUpTargetString(char *target);
+	Boolean				AlreadyExistsInDocument(char *anchor);
+	virtual Boolean		CommitChanges(Boolean allPanes);
+	virtual void		InitializeDialogControls();
+
+protected:	
+	virtual void		Help() {;} // Sorry, no help.
+	
+	char*				fOriginalTarget;
+	CLargeEditField*	fTargetName;
+};
+
+class CLineProp: public CEditDialog
+{
+public:
+	enum				{ class_ID = 'EDL0' };
+	
+						CLineProp( LStream* inStream );
+	virtual				~CLineProp( );
+						
+	virtual Boolean		CommitChanges(Boolean allPanes);
+	virtual void		FinishCreateSelf();
+	virtual void		InitializeDialogControls();
+//	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+
+protected:	
+	virtual void		Help();
+
+	LControl*			fLeftAlign;
+	LControl*			fCenterAlign;
+	LControl*			fRightAlign;
+	
+	LGAEditField*		fHeightEditText;
+	LGAEditField*		fWidthEditText;
+	LControl*			fPixelPercent;
+	LControl*			fShading;
+};
+
+
+class CUnknownTag: public CEditDialog
+{
+public:
+	enum				{ class_ID = 'EDUT' };
+	
+						CUnknownTag( LStream* inStream );
+	virtual				~CUnknownTag();
+						
+	virtual Boolean		CommitChanges(Boolean allPanes);
+	virtual void		InitializeDialogControls();
+	virtual void		FinishCreateSelf();
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+
+protected:	
+	virtual void		Help();
+	
+	CLargeEditField*	fTargetName;
+};
+
+
+class MultipleSelectionSingleColumn: public LListBox
+{
+public:
+	enum				{ class_ID = 'MSSC' };
+	
+						MultipleSelectionSingleColumn( LStream* inStream );
+						
+	virtual int16		NumItems();		
+	virtual void		DeselectAll();		
+	virtual void		SelectAll();		
+	virtual void		AddItem( char* data, Boolean isSelected );
+	virtual StringPtr	GetItem(Str255 outDescriptor, int32 rowNum) const;	// rowNum is zero based
+	virtual void		RemoveAllItems();
+	virtual Boolean		IsSelected(int32 rowNum);	// rowNum is zero based
+
+};
+
+
+class CPublishHistory
+{
+public:
+	// Do we have any history at all?
+	static Boolean		IsTherePublishHistory();
+	
+	// Get a particular entry
+	static char*		GetPublishHistoryCharPtr(short whichone);
+	 
+	// Set a particular entry
+	static void			SetPublishHistoryCharPtr(char* entry, short whichone);
+	
+	// Put an entry at the top of the list (and remove any duplicate)
+	static void			AddPublishHistoryEntry(char *entry);
+};
+
+class CPublish: public CEditDialog
+{
+public:
+	enum				{ class_ID = 'EPLS' };
+	
+						CPublish( LStream* inStream );
+	virtual				~CPublish();
+						
+	virtual Boolean		CommitChanges(Boolean allPanes);
+	virtual void		FinishCreateSelf();
+	virtual void		InitializeDialogControls();
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+
+protected:	
+	virtual void		Help();
+	char *				DocName();
+	
+	LCaption*			fLocalLocation;
+	
+	LControl*			fImageFiles;
+	LControl*			fFolderFiles;
+	LControl*			fDefaultLocation;
+	
+	MultipleSelectionSingleColumn*		fFileList;
+	
+	LGAEditField*		fPublishLocation;
+	LGAEditField*		fUserID;
+	LGAEditField*		fPassword;
+
+	LControl*			fSavePassword;
+	LGAPopup*			mHistoryList;
+};
+
+
+// This is a dialog box which contains a Tab control.
+// This code was written using Cmd-C & Cmd-V from the CPrefWindow class.
+// We don't need everything in CPrefWindow though, and I'm too lazy to make
+// a nice base class for both at the moment.
+
+class CTabbedDialog : public CEditDialog
+{
+public:
+	enum 				{class_ID = 'EDTB'};
+	
+						CTabbedDialog( LStream* inStream );
+	virtual				~CTabbedDialog();
+	
+	static void			RegisterViewTypes();
+	void				FinishCreateSelf();
+	virtual void		InitializeDialogControls();
+	
+	virtual void		SavePlace( LStream* ) { }
+	virtual void		RestorePlace( LStream* ) { }
+
+//	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	
+protected:		   
+	virtual void		Help();
+	virtual Boolean		CommitChanges(Boolean allPanes);
+		   
+	CTabControl*		mTabControl;
+	CEditTabSwitcher*	mTabSwitcher;
+
+};
+
+
+/*****************************************************************************
+ * class CEditorPrefContain. (used to be CPrefContain)
+ *	Container for a related group of controls (1 pane of preference window)
+ * 		and know how to:
+ * - get proper variables from data, and assign the values to controls
+ * - get values from controls back into data.
+ *****************************************************************************/
+class CEditorPrefContain : public LView, public LListener, public LTabGroup
+{
+public:
+						CEditorPrefContain( LStream* inStream ) : LView( inStream ) {};
+	virtual				~CEditorPrefContain() { };
+
+	// ¥ link to little controls, and reset their values
+	virtual void		FinishCreateSelf() { LView::FinishCreateSelf(); UReanimator::LinkListenerToControls(this, this, GetPaneID()); ControlsFromPref();}
+
+	// ¥Êlistens to 'default' message
+	void				ListenToMessage( MessageT, void* ) {};
+								
+	// ¥ initialize from preferences
+	virtual void		ControlsFromPref() = 0;
+	virtual void		PrefsFromControls() = 0;
+
+	virtual void		DrawSelf();
+};
+
+
+class CEditContain: public CEditorPrefContain, public LBroadcaster
+{
+public:
+						CEditContain(LStream* inStream): CEditorPrefContain( inStream ){ pExtra = NULL; }
+						~CEditContain(){ XP_FREEIF(pExtra); }
+	
+	void				SetContext(MWContext*	context) {fContext = context;}				
+	MWContext*			GetContext() { return fContext;}				
+
+	void				SetInsertFlag(Boolean insert) {fInsert = insert;}
+	Boolean				GetInsertFlag() { return fInsert;}
+	
+	void				SetLinkToLinkName(char** LinkNameLink) {fLinkName = LinkNameLink;}
+	void				SetExtraHTMLString(char *s) { pExtra = s; }; 
+	virtual void		Help() = NULL;
+	
+	int16				GetWinCSID() { return INTL_GetCSIWinCSID(LO_GetDocumentCharacterSetInfo(fContext)); }
+
+	virtual Boolean		AllFieldsOK() = NULL;
+
+protected:
+	MWContext*			fContext;
+		   Boolean		fInsert;
+		   char**		fLinkName;
+		   char*		pExtra;
+};
+
+
+class CEDCharacterContain: public CEditContain
+{
+public:	
+	enum 				{class_ID = '1edl'};
+	
+						CEDCharacterContain( LStream* inStream ) : CEditContain( inStream ){};
+	
+	virtual void		FinishCreateSelf();
+	
+	virtual void		PrefsFromControls();
+	virtual void		ControlsFromPref();
+
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual void		Help();
+	
+	virtual Boolean		AllFieldsOK() { return TRUE;}
+	
+protected:
+	Boolean				fColorChanged;
+	Boolean				fSizeChanged;
+	
+	LControl*			fTextSizePopup;
+	LControl*			mFontMenu;
+	Boolean				mFontChanged;
+	
+	LControl*			fColorDefaultRadio;
+	LControl*			fColorCustomRadio;
+	CColorButton*		fColorCustomColor;
+	
+	LControl*			fTextBoldCheck;
+	LControl*			fTextItalicCheck;
+	LControl*			fTextSuperscriptCheck;
+	LControl*			fTextSubscriptCheck;
+	LControl*			fTextNoBreaksCheck;
+	LControl*			fTextUnderlineCheck;
+	LControl*			fTextStrikethroughCheck;
+	LControl*			fTextBlinkingCheck;
+
+	LControl*			fClearTextStylesButton;
+	LControl*			fClearAllStylesButton;
+};
+
+
+class CEDParagraphContain: public CEditContain
+{
+public:	
+	enum 				{class_ID = '2edl'};
+	
+						CEDParagraphContain( LStream* inStream ) : CEditContain( inStream ){};
+	
+	virtual void		FinishCreateSelf();
+
+	virtual void		PrefsFromControls();
+	virtual void		ControlsFromPref();
+
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	
+	virtual void		Help();
+	
+	virtual Boolean		AllFieldsOK();
+
+protected:
+	void				AdjustPopupsVisibility();
+	
+	LControl*			fParagraphStylePopup;
+	LControl*			fContainerStylePopup;
+	
+	LControl*			fListStylePopup;
+	LControl*			fNumberPopup;
+	LControl*			fBulletPopup;
+	LControl*			fStartNumberCaption;
+	LGAEditField*		fStartNumberEditText;
+
+	LControl*			fLeftAlignRadio;
+	LControl*			fCenterAlignRadio;
+	LControl*			fRightAlignRadio;
+
+};
+
+
+#ifdef COOL_IMAGE_RADIO_BUTTONS
+class CImageAlignButton: public CBevelButton
+{
+public:
+					enum { class_ID = 'BvRB' };
+					
+					CImageAlignButton( LStream* inStream ) : CBevelButton( inStream ){};
+	virtual void		SetValue(
+								Int32				inValue);
+
+private:
+		virtual void		HotSpotAction(
+									Int16			inHotSpot,
+									Boolean 		inCurrInside,
+									Boolean			inPrevInside);
+									
+		virtual void		HotSpotResult(Int16 inHotSpot);
+};
+#endif
+
+
+class CEDLinkContain: public CEditContain
+{
+public:	
+	enum 				{class_ID = '3edl'};
+	
+						CEDLinkContain( LStream* inStream ) : CEditContain( inStream ){};
+	virtual				~CEDLinkContain();
+						
+	virtual void		FinishCreateSelf();
+
+	virtual void		PrefsFromControls();
+	virtual void		ControlsFromPref();
+	virtual void		Show();
+	virtual void		Hide();
+
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual void		Help();
+	
+	virtual Boolean		AllFieldsOK() { return TRUE;}
+
+protected:
+	void				SelectedFileUpdate();
+	void				CurrentFileTargs();
+	
+	CLargeEditField*	fLinkedTextEdit;
+
+	LControl*			fChooseFileLinkButton;
+	LControl*			fRemoveLinkButton;
+	CLargeEditField*	fLinkPageTextEdit;
+
+	LControl*			fCurrentDocumentRadio;
+	LControl*			fSelectedFileRadio;
+	OneRowLListBox*		fTargetList;
+	char*				fTargs;
+};
+
+
+class CEDImageContain: public CEditContain
+{
+public:	
+	enum 				{class_ID = '4edl'};
+	
+						CEDImageContain( LStream* inStream );
+	virtual				~CEDImageContain();
+	
+	virtual void		FinishCreateSelf();
+
+	virtual void		PrefsFromControls();
+	virtual void		ControlsFromPref();
+	EDT_ImageData *		ImageDataFromControls();
+	virtual void		Show();
+	virtual void		Hide();
+
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual void		Help();
+	virtual Boolean		AllFieldsOK();
+	
+protected:
+	void				AdjustEnable();
+
+	char *				fSrcStr;
+	char *				fLowSrcStr;
+	
+	CLargeEditField*	fImageFileName;	// was CEditBroadcaster
+	CLargeEditField*	fImageAltFileName;
+	CLargeEditField*	fImageAltTextEdit;
+	
+	LGAEditField*		fHeightTextEdit;
+	LGAEditField*		fWidthTextEdit;
+	LControl*			fImageLockedCheckBox;
+	
+	int32  				fOriginalWidth;        /* Width and Height we got on initial loading */
+    int32  				fOriginalHeight;
+    
+	LGAEditField*		fLeftRightBorderTextEdit;
+	LGAEditField*		fTopBottomBorderTextEdit;
+	LGAEditField*		fSolidBorderTextEdit;
+
+	LControl*			fCopyImageCheck;
+	LControl*			fBackgroundImageCheck;
+	LControl*			fRemoveImageMapButton;
+	LControl*			fEditImageButton;
+
+    Boolean				fLooseImageMap;
+    Boolean				mBorderUnspecified;
+	
+	LControl*			mImageAlignmentPopup;
+};
+
+
+class CEDDocPropGeneralContain: public CEditContain
+{
+public:	
+	enum 				{class_ID = '5edl'};
+	
+						CEDDocPropGeneralContain( LStream* inStream ) : CEditContain( inStream ){};
+	
+	virtual void		FinishCreateSelf();
+	
+	virtual void		PrefsFromControls();
+	virtual void		ControlsFromPref();
+	void				AddMeta(char *Name, CLargeEditField* value);
+
+//	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual void		Help();
+	virtual Boolean		AllFieldsOK() { return TRUE;}
+	
+protected:
+	CLargeEditField*	fLocation;
+	CLargeEditField*	fTitle;
+	CLargeEditField*	fAuthor;
+	CLargeEditField*	fDescription;
+	CLargeEditField*	fKeywords;
+	CLargeEditField*	fClassification;
+};
+
+
+// This should be moved to XP code in the future
+
+typedef struct _EDT_ColorSchemeData {
+    char *     pSchemeName;
+    LO_Color   ColorText;
+    LO_Color   ColorLink;
+    LO_Color   ColorActiveLink;
+    LO_Color   ColorFollowedLink;
+    LO_Color   ColorBackground;
+    char *     pBackgroundImage;
+} EDT_ColorSchemeData;
+
+
+class AppearanceContain: public CEditContain
+{
+						AppearanceContain( LStream* inStream ) : CEditContain( inStream ){};
+	virtual void		FinishCreateSelf();
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	void 				ChooseImageFile();
+
+protected:
+	void 				UpdateTheWholeDamnDialogBox();
+	
+	LControl*			fCustomColor;
+	LControl*			fBrowserColor;
+	
+	LControl*			fColorScheme;
+	
+	CChameleonView*		fExampleView;
+	CColorButton*		fNormalText;
+	CColorButton*		fLinkedText;
+	CColorButton*		fActiveLinkedText;
+	CColorButton*		fFollowedLinkedText;
+	
+	CChameleonCaption*	fExampleNormalText;
+	CChameleonCaption*	fExampleLinkedTex;
+	CChameleonCaption*	fExampleActiveLinkedText;
+	CChameleonCaption*	fExampleFollowedLinkedText;
+	
+	CColorButton*		fSolidColor;
+	LControl*			fImageFile;
+	CLargeEditField*	fImageFileName;
+
+	XP_List*			fSchemeData;
+};
+
+
+class CEDDocPropAppearanceContain: public AppearanceContain
+{
+public:	
+	enum 				{class_ID = '6edl'};
+	
+						CEDDocPropAppearanceContain( LStream* inStream ) : AppearanceContain( inStream ){};
+	virtual				~CEDDocPropAppearanceContain();
+	
+	
+	virtual void		PrefsFromControls();
+	virtual void		ControlsFromPref();
+
+	virtual Boolean		AllFieldsOK() { return TRUE;}
+	virtual void		Help();
+};
+
+
+class CEDDocAppearanceNoTab: public CEDDocPropAppearanceContain
+{
+public:	
+	enum 				{class_ID = '6edL'};
+	
+						CEDDocAppearanceNoTab( LStream* inStream ) : CEDDocPropAppearanceContain( inStream ){};
+	virtual				~CEDDocAppearanceNoTab() {;}
+	
+	virtual void		DrawSelf();
+};
+
+
+class CEDDocPropAdvancedContain: public CEditContain
+{
+public:	
+	enum 				{class_ID = '7edl'};
+	
+						CEDDocPropAdvancedContain( LStream* inStream ) : CEditContain( inStream ){};
+	virtual				~CEDDocPropAdvancedContain();
+	
+	virtual void		FinishCreateSelf();
+	void				PutStringsInBuffer();
+	Boolean				BufferUnique();
+	virtual void		PrefsFromControls();
+	virtual void		ControlsFromPref();
+
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual void		Help();
+	virtual Boolean		AllFieldsOK() { return TRUE;}
+	
+protected:
+	int16				fbufferlen;
+	char*				fbuffer;
+
+	OneRowLListBox*		fSystemVariables;
+	OneRowLListBox*		fUserVariables;
+		
+	CLargeEditField*	fName;
+	CLargeEditField*	fValue;
+};
+
+class CEDTableContain: public CEditContain
+{
+public:	
+	enum 				{class_ID = '8edl'};
+	
+						CEDTableContain( LStream* inStream ) : CEditContain( inStream ) { pExtra = NULL; }
+						~CEDTableContain() { XP_FREEIF(pExtra); }
+	
+	virtual void		FinishCreateSelf();
+	virtual void		Help();
+	void				AdjustEnable();
+	
+	virtual void		PrefsFromControls();
+	virtual void		ControlsFromPref();
+
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual Boolean		AllFieldsOK();
+	
+protected:
+	LControl*			fBorderCheckBox;
+	LGAEditField*		fBorderWidthEditText;
+	LGAEditField*		fCellSpacingEditText;
+	LGAEditField*		fCellPaddingEditText;
+	
+	LControl*			fCustomWidth;
+	LGAEditField*		fWidthEditText;
+	LControl*			fWidthPopup;
+	
+	LControl*			fCustomHeight;
+	LGAEditField*		fHeightEditText;
+	LControl*			fHeightPopup;
+	
+	LControl*			fCustomColor;
+	CColorButton*		fColorCustomColor;
+
+	LControl*			fIncludeCaption;
+	LControl*			fCaptionAboveBelow;
+	
+	LGAPopup*			mTableAlignment;
+
+	LControl*			mFastLayout;
+	LControl*			mUseImage;
+	CLargeEditField*	mImageFileName;
+	LControl*			mLeaveImage;
+	
+	char*				pExtra;
+};
+
+
+class CEDTableCellContain: public CEditContain
+{
+public:	
+	enum 				{class_ID = 'aedl'};
+	
+						CEDTableCellContain( LStream* inStream ) : CEditContain( inStream ) { pExtra = NULL; }
+						~CEDTableCellContain() { XP_FREEIF(pExtra); }
+	
+	virtual void		FinishCreateSelf();
+	virtual void		Help();
+	void				AdjustEnable();
+	
+	virtual void		PrefsFromControls();
+	virtual void		ControlsFromPref();
+
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	virtual Boolean		AllFieldsOK();
+	
+protected:
+	LGAEditField*		fRowSpanEditText;
+	LGAEditField*		fColSpanEditText;
+
+	LGAPopup*			fHorizontalAlignment;
+	LGAPopup*			fVerticalAlignment;
+
+	LControl*			fHeaderStyle;
+	LControl*			fWrapText;
+
+	LControl*			fCustomWidth;
+	LGAEditField*		fWidthEditText;
+	LControl*			fWidthPopup;
+	
+	LControl*			fCustomHeight;
+	LGAEditField*		fHeightEditText;
+	LControl*			fHeightPopup;
+	
+	LControl*			fCustomColor;
+	CColorButton*		fColorCustomColor;
+	
+	LControl*			mNextButton;
+	LControl*			mPreviousButton;
+
+	LControl*			mUseImage;
+	CLargeEditField*	mImageFileName;
+	LControl*			mLeaveImage;
+
+	char*				pExtra;
+};
+

mozilla/cmd/macfe/Composer/meditor.cp

@@ -0,0 +1,342 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "meditor.h"	// HandleModalDialog
+#include "StBlockingDialogHandler.h"
+#include "CEditView.h"
+#include "macgui.h"		// UGraphics::MakeLOColor
+#include "CPaneEnabler.h"
+#include "resgui.h"		// EDITDLG_AUTOSAVE
+#include "edt.h"
+#include "fe_proto.h"
+#include "prefapi.h"	// PREF_GetBoolPref, PREF_GetIntPref
+#include "shist.h"		// SHIST_GetCurrent
+#include "uapp.h"		// CFrontApp
+#include "CColorPopup.h"
+
+extern "C" {
+#include "xpgetstr.h"
+#define WANT_ENUM_STRING_IDS
+#include "allxpstr.h"
+#undef WANT_ENUM_STRING_IDS
+}
+
+#include "CNSContext.h"	// ExtractHyperView
+
+
+// takes pascal-strings
+MessageT HandleModalDialog( int id, const unsigned char *prompt1, const unsigned char* prompt2)
+{
+	StPrepareForDialog		prepare;
+	
+	StBlockingDialogHandler handler( id, NULL );
+	LDialogBox* dialog = (LDialogBox *)handler.GetDialog();
+	if ( prompt1 )
+	{
+		LCaption *caption = (LCaption *)dialog->FindPaneByID( '^1  ' );
+		if ( caption )
+			caption->SetDescriptor( prompt1 );
+	}
+	if ( prompt2 )
+	{
+		LCaption *caption = (LCaption *)dialog->FindPaneByID( '^2  ' );
+		if ( caption )
+			caption->SetDescriptor( prompt2 );
+	}
+	
+	MessageT message;
+	do {
+		message = handler.DoDialog();
+	}
+	while ( message == 0 );
+	
+	return message;
+}
+
+/* Set default colors, background from user Preferences via the Page Data structure 
+*/
+void FE_SetNewDocumentProperties(MWContext * pContext)
+{
+	if ( pContext && pContext->is_editor && pContext->bIsComposeWindow )
+		return;
+
+    EDT_PageData *pageData = EDT_NewPageData();
+
+    if (pageData == NULL)  return;
+
+	if (CPrefs::GetBoolean(CPrefs::EditorUseCustomColors )) {
+	
+		LO_Color EditorText = UGraphics::MakeLOColor(CPrefs::GetColor(CPrefs::EditorText));
+		LO_Color EditorLink = UGraphics::MakeLOColor(CPrefs::GetColor(CPrefs::EditorLink));
+		LO_Color EditorActiveLink = UGraphics::MakeLOColor(CPrefs::GetColor(CPrefs::EditorActiveLink));
+		LO_Color EditorFollowedLink = UGraphics::MakeLOColor(CPrefs::GetColor(CPrefs::EditorFollowedLink));
+		LO_Color EditorBackground = UGraphics::MakeLOColor(CPrefs::GetColor(CPrefs::EditorBackground));
+
+		pageData->pColorText = &EditorText;
+		pageData->pColorLink= &EditorLink;
+		pageData->pColorActiveLink = &EditorActiveLink;
+		pageData->pColorFollowedLink = &EditorFollowedLink;
+		pageData->pColorBackground = &EditorBackground;
+	
+	} else {
+	
+		pageData->pColorText = NULL;			// I assume this is how we get the browser defaults...
+		pageData->pColorLink=  NULL;
+		pageData->pColorActiveLink =  NULL;
+		pageData->pColorFollowedLink =  NULL;
+		pageData->pColorBackground =  NULL;
+		
+	}
+
+	Bool hasBackgroundImage;
+	if ( ( PREF_GetBoolPref( "editor.use_background_image", &hasBackgroundImage ) == PREF_NOERROR )
+		&& hasBackgroundImage )
+	{
+		pageData->pBackgroundImage = CPrefs::GetCharPtr(CPrefs::EditorBackgroundImage);
+		if (pageData->pBackgroundImage && XP_STRLEN(pageData->pBackgroundImage) == 0)			// if there is really nothing there, skip it.
+			pageData->pBackgroundImage = NULL;
+	}
+	else
+		pageData->pBackgroundImage = NULL;
+	    
+	if ( pContext && pContext->title )
+		pageData->pTitle = XP_STRDUP(pContext->title);
+		
+
+	EDT_SetPageData(pContext, pageData);
+	
+	pageData->pColorText = NULL;		//  don't free out lacal data!!!
+	pageData->pColorLink=  NULL;
+	pageData->pColorActiveLink =  NULL;
+	pageData->pColorFollowedLink =  NULL;
+	pageData->pColorBackground =  NULL;
+	pageData->pBackgroundImage =  NULL;
+	
+	EDT_FreePageData(pageData);
+
+    // Set Author name:
+
+//	CStr255	EditorAuthor(CPrefs::GetString(CPrefs::EditorAuthor));
+	
+//	FE_UsersFullName();
+	
+
+    EDT_MetaData *metaData = EDT_NewMetaData();
+    if (metaData == NULL) return;
+    metaData->bHttpEquiv = FALSE;
+    metaData->pName = XP_STRDUP("Author");
+    metaData->pContent = XP_STRDUP(CPrefs::GetString(CPrefs::EditorAuthor));
+    EDT_SetMetaData(pContext, metaData);     
+    EDT_FreeMetaData(metaData);
+}
+
+
+/* 
+ * Brings up a modal image load dialog and returns.  Calls
+ *  EDT_ImageLoadCancel() if the cancel button is pressed
+*/
+void FE_ImageLoadDialog( MWContext * /* pContext */ )
+{
+}
+
+/* 
+ * called by the editor engine after the image has been loaded
+*/
+void FE_ImageLoadDialogDestroy( MWContext * /* pContext */ )
+{
+}
+
+void FE_EditorDocumentLoaded( MWContext *pContext )
+{
+	if (pContext == NULL || !EDT_IS_EDITOR(pContext))
+		return;
+	
+	CEditView *editView = (CEditView *)ExtractHyperView(pContext);
+
+	int32 iSave;
+	if ( pContext->bIsComposeWindow )
+	{
+		iSave = 0;	// auto-save
+		
+		CMailEditView *mailEditView = dynamic_cast<CMailEditView *>(editView);
+		if ( mailEditView )
+			mailEditView->InitMailCompose();
+	}
+	else
+	{ 
+		XP_Bool doAutoSave;
+		PREF_GetBoolPref( "editor.auto_save", &doAutoSave );
+		if ( doAutoSave )
+			PREF_GetIntPref( "editor.auto_save_delay", &iSave );
+		else
+			iSave = 0;
+	}
+	
+	EDT_SetAutoSavePeriod(pContext, iSave );
+	
+	// remember when the file was (last) modified
+	// initializes date/time stamp for external editor warning
+	EDT_IsFileModified(pContext);
+	
+	// We had disabled everything, now we have to enable it again. This happens automatically on activate, but we might not get an activate
+	// if we don't have a dialog poping up (like if the user just creates a new document, there is no dialog...)
+
+	// set this after calling InitMailCompose
+	if ( editView )
+	{
+		editView->mEditorDoneLoading = true;
+			
+		// set color popup control to show correct default color (now that we have an mwcontext)
+		editView->mColorPopup->InitializeCurrentColor();
+	}
+	
+	InitCursor();
+	(CFrontApp::GetApplication())->UpdateMenus();
+}
+
+
+Bool FE_CheckAndAutoSaveDocument(MWContext *pContext)
+{
+	if (pContext == NULL || !EDT_IS_EDITOR(pContext) || ExtractHyperView(pContext) == NULL )
+		return FALSE;
+	
+	if ( pContext->bIsComposeWindow )
+		return FALSE;
+	
+	CEditView *editView = (CEditView *)ExtractHyperView(pContext);
+	if ( FrontWindow() != editView->GetMacPort() )
+		return true;
+	
+	if (!EDT_DirtyFlag(pContext) && !EDT_IS_NEW_DOCUMENT(pContext))
+		return TRUE;
+	
+	History_entry*	newEntry = SHIST_GetCurrent(&pContext->hist);
+	CStr255 fileName;
+	if ( newEntry && newEntry->address )
+		fileName = newEntry->address;
+				
+	MessageT itemHit = HandleModalDialog(EDITDLG_AUTOSAVE, fileName, NULL );
+	if (itemHit != ok)
+		return FALSE;
+		
+	return ((CEditView *)ExtractHyperView(pContext))->SaveDocument();
+}
+
+
+void FE_FinishedSave( MWContext * /* pMWContext */, int /* status */, char * /* pDestURL */, int /* iFileNumber */ )
+{
+}
+
+// in xp_file.h
+// Create a backup filename for renaming current file before saving data
+//    Input should be be URL file type "file:///..."
+//    Caller must free the string with XP_FREE
+
+/*
+ * I don't know what the logic here should be, so I mostly copied this from the Windows code in:
+ * src/ns/cmd/winfe/fegui.cpp#XP_BackupFileName()
+ * (I didn't copy all the Windows code which deals with 8.3 filenames.)
+ */
+
+char * XP_BackupFileName( const char * szURL )
+{
+    // Must have "file:" URL type and at least 1 character after "///"
+	if ( szURL == NULL || !NET_IsLocalFileURL((char*)szURL) || XP_STRLEN(szURL) <= 8 )
+		return NULL;
+
+    // Add extra space for '\0' and '.BAK', but subtract space for "file:///"
+
+	char *szFileName = (char *)XP_ALLOC((XP_STRLEN(szURL)+1+4-7)*sizeof(char));
+	if ( szFileName == NULL )
+		return NULL;
+
+	// Get filename but ignore "file:///"
+
+//	{
+//		char* filename = WH_FileName(szURL+7, xpURL);
+//		if (!filename) return NULL;
+//		XP_STRCPY(szFileName,filename);
+//		XP_FREE(filename);
+//	}
+	XP_STRCPY(szFileName, szURL+7);
+
+    // Add extension to the filename
+    XP_STRCAT( szFileName, ".BAK" );
+
+    return szFileName;
+}
+
+   
+
+// If pszLocalName is not NULL, we return the full pathname
+//   in local platform syntax, even if file is not found.
+//   Caller must free this string.
+// Returns TRUE if file already exists
+//
+
+/*
+ * I don't know what the logic here should be, so I mostly copied this from the Windows code in:
+ * src/ns/cmd/winfe/fegui.cpp#XP_ConvertUrlToLocalFile()
+ * (I didn't copy all the Windows code which deals with 8.3 filenames.)
+ */
+
+// The results of this call are passed directly to functions like XP_Stat and XP_FileOpen.
+// brade--use xpURL format
+Bool XP_ConvertUrlToLocalFile(const char * szURL, char **pszLocalName)		// return TRUE if the file exists!! or return FALSE;
+{
+    // Default assumes no file found - no local filename
+    
+    Boolean bFileFound = FALSE;
+	if ( pszLocalName )
+		*pszLocalName = NULL;
+
+	// if "file:///Untitled" fail to convert
+	if ( szURL && XP_STRCMP( szURL, XP_GetString(XP_EDIT_NEW_DOC_NAME) ) == 0 )
+		return bFileFound;
+
+	// Must have "file:" URL type and at least 1 character after "///"
+	if ( szURL == NULL || !NET_IsLocalFileURL((char*)szURL) || XP_STRLEN(szURL) <= 8 )
+		return FALSE;
+
+
+    // Extract file path from URL: e.g. "/c|/foo/file.html"
+
+	char *szFileName = NET_ParseURL( szURL, GET_PATH_PART);
+	if (szFileName == NULL)
+		return FALSE;
+
+	// NET_UnEscape(szFileName);  This will be done in WH_FileName, so don't unescape twice.
+
+	// Test if file exists
+    XP_StatStruct statinfo; 
+	if ( -1 != XP_Stat(szFileName, &statinfo, xpURL)			// if the file exists
+		&& statinfo.st_mode & S_IFREG )							// and its a normal file
+			bFileFound = TRUE;									// We found it!
+
+	if ( pszLocalName )
+	{
+		// Pass string to caller
+		*pszLocalName = WH_FileName(szFileName, xpURL);
+		if (szFileName)
+			XP_FREE( szFileName );
+	}
+	else 
+		XP_FREE(szFileName);
+
+	return bFileFound;
+}

mozilla/cmd/macfe/Composer/meditor.h

@@ -0,0 +1,19 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+MessageT HandleModalDialog( int id , const unsigned char *prompt0, const unsigned char* prompt1);

mozilla/cmd/macfe/applevnt/mplugin.h

@@ -0,0 +1,141 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#include "np.h"
+#include "npapi.h"
+
+#include <Printing.h>
+#include <Icons.h>
+
+#include <LView.h>
+#include <LPeriodical.h>
+#include <LCommander.h>
+#include <LDragAndDrop.h>
+#include <TArray.h>
+
+class StPluginFocus;
+
+//
+// Return the "plug-in descriptor" that we pass to XP code
+// (this is really just a pointer to a CPluginHandler).
+//
+class CStr255;
+extern void* GetPluginDesc(const CStr255& pluginName);
+
+
+/*********************************************************************************
+ * CPluginView
+ * Embeds the plugin, and passes on the events to it
+ *********************************************************************************/
+
+class CPluginView : public LView,		// Drawing, etc
+					public LPeriodical,	// Idling
+					public LCommander,	// Key events
+					public LDragAndDrop	// Dragging
+{
+public:
+	friend class StPluginFocus;
+	enum { class_ID = 'plug' };
+
+// ¥¥ constructors
+							CPluginView(LStream *inStream);
+	virtual					~CPluginView();
+
+			void			EmbedCreate(MWContext* context, LO_EmbedStruct* embed_struct);
+			void			EmbedFree(MWContext* context, LO_EmbedStruct* embed_struct);
+			void			EmbedSize(LO_EmbedStruct* embed_struct, SDimension16 hyperSize);
+			void			EmbedDisplay(LO_EmbedStruct* embed_struct, Boolean isPrinting);
+
+// ¥¥ access
+			NPWindow*		GetNPWindow() 						{ return &fNPWindow; }
+			NPEmbeddedApp*	GetNPEmbeddedApp()					{ return fApp; }
+
+// ¥¥ event processing
+	static	CPluginView*	sPluginTarget;
+	static	void			BroadcastPluginEvent(const EventRecord& event);
+	static	Boolean			PluginWindowEvent(const EventRecord& event);
+	
+	virtual void			ClickSelf(const SMouseDownEvent& inMouseDown);
+	virtual void			EventMouseUp(const EventRecord &inMacEvent);
+	virtual Boolean			ObeyCommand(CommandT inCommand, void *ioParam);
+	virtual Boolean			HandleKeyPress(const EventRecord& inKeyEvent);
+	virtual void			DrawSelf();
+	virtual void			SpendTime(const EventRecord& inMacEvent);
+	virtual void			ActivateSelf();
+	virtual void			DeactivateSelf();
+	virtual void			BeTarget();
+	virtual void			DontBeTarget();
+	virtual void			AdjustCursorSelf(Point inPortPt, const EventRecord& inMacEvent);
+			Boolean			PassEvent(EventRecord& inEvent);
+	virtual Boolean			HandleEmbedEvent(CL_Event *event);
+	
+// ¥¥ positioning
+	virtual void			AdaptToNewSurroundings();
+	virtual void			AdaptToSuperFrameSize(Int32 inSurrWidthDelta, Int32 inSurrHeightDelta, Boolean inRefresh);
+	virtual void			MoveBy(Int32 inHorizDelta, Int32 inVertDelta, Boolean inRefresh);
+			Boolean			IsPositioned() const { return fPositioned; }
+// ¥¥Êdragging
+	virtual Boolean			DragIsAcceptable(DragReference inDragRef);
+	virtual void			HiliteDropArea(DragReference inDragRef);
+	virtual void			UnhiliteDropArea(DragReference inDragRef);
+
+// ¥¥ printing
+			Boolean			PrintFullScreen(Boolean printOne, THPrint printRecHandle);
+			void			PrintEmbedded();
+			
+// ¥¥ broken plugin
+			void			SetBrokenPlugin();
+			void			DrawBroken(Boolean hilite);
+
+			void			SetPositioned(Boolean positioned = true) { fPositioned = positioned; }
+
+// ¥¥ window control
+
+			void 			RegisterWindow(void* window);
+			void 			UnregisterWindow(void* window);
+			Boolean			PassWindowEvent(EventRecord& inEvent, WindowPtr window);
+			
+			SInt16			AllocateMenuID(Boolean isSubmenu);
+			Boolean			IsPluginCommand(CommandT inCommand);
+			
+	static	CPluginView*	FindPlugin(WindowPtr window);
+	
+private:
+			void			ResetDrawRect();
+	
+			NPEmbeddedApp*	fApp;
+			NPWindow		fNPWindow;
+			NP_Port			fNPPort;
+			CPluginView*	fOriginalView;
+			CIconHandle		fBrokenIcon;
+			short			fHorizontalOffset;
+			short			fVerticalOffset;
+			Boolean			fBrokenPlugin;
+			Boolean			fPositioned;
+			Boolean			fHidden;
+			Boolean			fWindowed;
+			LO_EmbedStruct* fEmbedStruct;
+			Boolean			fIsPrinting;
+			LArray*			fWindowList;
+			TArray<SInt16>*	fMenuList;
+			
+	static	LArray*			sPluginList;
+};
+

mozilla/cmd/macfe/applevnt/mregistr.cp

@@ -0,0 +1,539 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// mregistr.cp
+// Registry for AppleEvent notifiers
+// Pretty clumsy right now, but separating this functionality out of uapp seems
+// to be the right thing.
+// It is just a collection of routines
+
+// MacNetscape
+#include "mregistr.h"
+#include "macutil.h"
+#include "CAppleEventHandler.h"
+#include "resae.h"
+#include "resgui.h"
+#include "ufilemgr.h"
+#include "uprefd.h"
+#include "CNSContext.h"
+
+#ifndef MOZ_MAIL_NEWS
+#include "InternetConfig.h"
+#endif
+
+// xp
+#include "client.h"
+
+static LArray sURLEchoHandlers(sizeof(ProcessSerialNumber));
+static LArray sProtocolHandlers;
+
+/************************************************************************************
+ * class CProtocolHelper
+ * Holds the information about protocol helpers, and knows how to launch them
+ ************************************************************************************/
+
+class CProtocolHelper	{
+public:
+	char * fProtocolInfo;	// String that specifies the protocol
+	OSType fApplSig;		// Application to launch. Do not use these unless in saving/restoring
+	
+	// ¥¥ constructors
+	CProtocolHelper(char * protocolInfo, OSType applSig);
+	virtual ~CProtocolHelper();
+	// ¥¥ access
+	Boolean	AttemptLaunch(URL_Struct *url, MWContext *context);
+	Boolean EqualTo(char * protocolInfo, OSType applSig);
+	Boolean operator==(CProtocolHelper * p);
+	static void AddNewHelper(CProtocolHelper * helper);
+	
+};
+
+CProtocolHelper::CProtocolHelper(char * protocolInfo, OSType applSig)
+{
+	fProtocolInfo = protocolInfo;
+	fApplSig = applSig;
+}
+
+CProtocolHelper::~CProtocolHelper()
+{
+	if (fProtocolInfo)
+		XP_FREE(fProtocolInfo);
+}
+
+Boolean CProtocolHelper::operator==(CProtocolHelper * p)
+{
+	if (fProtocolInfo && p->fProtocolInfo)
+		return (strcmp(fProtocolInfo, p->fProtocolInfo) == 0);
+	return false;
+}
+
+// This is used for the helper removal
+// It returns true if we do not have the protocol info
+Boolean CProtocolHelper::EqualTo(char * protocolInfo, OSType applSig)
+{
+	if (applSig != fApplSig)
+		return false;
+	if (protocolInfo && fProtocolInfo)
+		if (strcmp(protocolInfo, fProtocolInfo) == 0)
+			return true;
+		else
+			return false;
+	else
+		return true;
+	return false;
+}
+
+// Finds the running helper application
+// Tries to send a OpenURL event to the registered protocol handler
+// If this does not work, sends the standard GetURL event
+Boolean CProtocolHelper::AttemptLaunch(URL_Struct *url, MWContext */*context*/)
+{
+	if (!url->address)
+		return false;
+	if (strncasecomp(url->address, fProtocolInfo, strlen(fProtocolInfo)) != 0)
+		return false;
+
+	ProcessSerialNumber psn;
+	FSSpec dummy;
+	OSErr err = FindProcessBySignature(fApplSig,'APPL',psn,&dummy);
+	if (err != noErr)
+	{
+		FSSpec appSpec;
+		err = CFileMgr::FindApplication(fApplSig, appSpec);
+		if (err != noErr)
+			return false;
+	
+		LaunchParamBlockRec launchParams;
+		launchParams.launchBlockID = extendedBlock;
+		launchParams.launchEPBLength = extendedBlockLen;
+		launchParams.launchFileFlags = 0;
+		launchParams.launchControlFlags = launchContinue + launchNoFileFlags;
+		launchParams.launchAppSpec = &appSpec;
+		launchParams.launchAppParameters = NULL;
+		err = LaunchApplication(&launchParams);
+		if (err != noErr)
+			return false;
+		err = FindProcessBySignature(fApplSig,'APPL',psn,&dummy);
+		if (err != noErr)
+			return false;
+	}
+	Try_	// Try the old Spyglass AE suite way first
+	{
+		AppleEvent event;
+		
+		err = AEUtilities::CreateAppleEvent(AE_spy_send_suite, AE_spy_openURL, event, psn);
+		ThrowIfOSErr_(err);
+		// put in the URL
+		StAEDescriptor urlDesc(typeChar, url->address, url->address ? strlen(url->address) : 0);
+		err = ::AEPutParamDesc(&event,keyDirectObject,&urlDesc.mDesc);
+		ThrowIfOSErr_(err);
+		// Send it
+		AppleEvent reply;
+		Try_
+		{
+			err = ::AESend(&event, &reply, kAEWaitReply,kAENormalPriority,60,nil, nil);
+			AEDisposeDesc(&event);
+			err = AEUtilities::EventHasErrorReply(reply);
+			ThrowIfOSErr_(err);
+			AEDisposeDesc(&reply);
+		}
+		Catch_(inErr)
+		{
+			AEDisposeDesc(&reply);
+			
+			// Bug #86055
+			// A -1 means the handler didn't want the event, not that it didn't handle it.
+			// In this case we should just return that the helper can't handle the protocol
+			// and Communicator/Navigator should handle it rather than also sending a GURL
+			// event to the helper app.  This works around a problem under MacOS 8 where
+			// sending a GURL event to an app that didn't handle it could result in an infinite
+			// loop when the OS decided to re-direct the GURL back to us and we promptly sent
+			// it back to the handler that didn't handle it.
+			if (err == -1)
+				return false;
+			else
+				Throw_(inErr);			
+		}
+		EndCatch_
+	}
+	Catch_(inErr)	// old Spyglass AE suite way failed, try the standard event
+	{
+		AppleEvent reply;
+		Try_
+		{
+			AppleEvent event;
+			err = AEUtilities::CreateAppleEvent(AE_url_suite, AE_url_getURL, event, psn);
+			// put in the URL
+			StAEDescriptor urlDesc(typeChar, url->address, url->address ? strlen(url->address) : 0);
+			err = ::AEPutParamDesc(&event,keyDirectObject,&urlDesc.mDesc);
+			ThrowIfOSErr_(err);
+			err = ::AESend(&event, &reply, kAEWaitReply,kAENormalPriority,60,nil, nil);
+			AEDisposeDesc(&event);
+			ThrowIfOSErr_(AEUtilities::EventHasErrorReply(reply));
+			AEDisposeDesc(&reply);
+		}
+		Catch_(inErr)
+		{
+			AEDisposeDesc(&reply);
+			return false;
+		}
+		EndCatch_
+	}
+	EndCatch_
+	return true;
+}
+
+void CProtocolHelper::AddNewHelper(CProtocolHelper* helper)
+{
+	if (helper == NULL)
+		return;
+
+	LArrayIterator iter(sProtocolHandlers);
+	CProtocolHelper * otherHelper;
+	while (iter.Next(&otherHelper))	// Delete duplicate registration for this protocol
+		if (*helper == otherHelper)
+		{
+			delete otherHelper;
+			sProtocolHandlers.Remove(&otherHelper);
+		}
+	sProtocolHandlers.InsertItemsAt(1,1, &helper);
+	NET_AddExternalURLType(helper->fProtocolInfo);
+	CPrefs::SetModified();
+}
+
+// Called from preferences, saves all the protocol  handlers
+void CNotifierRegistry::ReadProtocolHandlers()
+{	
+	// Add the bolo handler
+	CProtocolHelper *helper = new CProtocolHelper(strdup("bolo"), 'BOLO');
+	
+	CProtocolHelper::AddNewHelper(helper);
+	CPrefs::UsePreferencesResFile();
+	
+	Handle stringListHandle = ::Get1Resource('STR#', PROT_HANDLER_PREFS_RESID);
+	
+	if (stringListHandle && *stringListHandle)
+	{
+		if (::GetHandleSize(stringListHandle) < sizeof(short))
+		{
+			::RemoveResource(stringListHandle);
+			::DisposeHandle(stringListHandle);
+			return;
+		}
+	}
+	
+	CStringListRsrc		stringRsrc(PROT_HANDLER_PREFS_RESID);
+	Int16 howMany = stringRsrc.CountStrings();
+	if (howMany == 0)
+		return;
+	//  Each protocol handler is represented by 2 strings
+	// 1 - the application sig
+	// 2 - the protocol string
+	for (int i=1; i < howMany; i=i+2)	// Increment by 2.
+	{
+		CStr255 applSigStr, protocol;
+		stringRsrc.GetString(i, applSigStr);
+		if (ResError()) return;
+		stringRsrc.GetString(i+1, protocol);
+		if (ResError()) return;
+
+		OSType appSig;
+		LString::PStrToFourCharCode(applSigStr, appSig);
+		CProtocolHelper * newHelper = new CProtocolHelper(XP_STRDUP((char*)protocol), appSig);
+		CProtocolHelper::AddNewHelper(newHelper);
+	}
+}
+
+// Called from preferences, writes all the protocol  handlers
+void CNotifierRegistry::WriteProtocolHandlers()
+{
+	Int32 howMany = sProtocolHandlers.GetCount();
+	if (howMany <= 1)
+		return;
+	
+	Handle stringListHandle = ::Get1Resource('STR#', PROT_HANDLER_PREFS_RESID);
+
+	if (!stringListHandle) {
+		stringListHandle = ::NewHandle(0);
+		::AddResource(stringListHandle, 'STR#',
+			PROT_HANDLER_PREFS_RESID, CStr255::sEmptyString);
+	}
+	
+	if (stringListHandle && *stringListHandle)
+	{
+		SInt8 flags = ::HGetState(stringListHandle);
+		::HNoPurge(stringListHandle);
+		
+		CStringListRsrc		stringRsrc(PROT_HANDLER_PREFS_RESID);
+		stringRsrc.ClearAll();
+		for (int i=1; i<=howMany - 1; i++)
+		{
+			CProtocolHelper * helper = NULL;
+			if (sProtocolHandlers.FetchItemAt(i, &helper))
+			{
+				CStr255 protocol(helper->fProtocolInfo);
+				Str255 sig;
+				LString::FourCharCodeToPStr(helper->fApplSig, sig);
+				stringRsrc.AppendString(sig);
+				stringRsrc.AppendString(protocol);
+			}
+		}
+		::WriteResource(stringListHandle);
+		::HSetState(stringListHandle, flags);
+	}
+}
+
+void CNotifierRegistry::HandleAppleEvent(const AppleEvent &inAppleEvent, AppleEvent &outAEReply,
+									AEDesc &outResult, long	inAENumber)
+{
+	switch(inAENumber)	{
+		case AE_RegisterURLEcho:
+			HandleRegisterURLEcho(inAppleEvent, outAEReply, outResult, inAENumber);
+			break;
+		case AE_UnregisterURLEcho:
+			HandleUnregisterURLEcho(inAppleEvent, outAEReply, outResult, inAENumber);
+			break;
+		case AE_RegisterProtocol:
+			HandleRegisterProtocol(inAppleEvent, outAEReply, outResult, inAENumber);
+			break;			
+		case AE_UnregisterProtocol:
+			HandleUnregisterProtocol(inAppleEvent, outAEReply, outResult, inAENumber);
+			break;
+		default:
+			ThrowOSErr_(errAEEventNotHandled);
+	}
+}
+
+// Always save the PSN
+void CNotifierRegistry::HandleRegisterURLEcho(const AppleEvent &inAppleEvent, AppleEvent &outAEReply,
+									AEDesc &/*outResult*/, long	/*inAENumber*/)
+{
+	OSType appSignature;
+	ProcessSerialNumber psn;
+	
+	Size 	realSize;
+	OSType	realType;
+	
+	OSErr err = ::AEGetParamPtr(&inAppleEvent, keyDirectObject, typeApplSignature, &realType,
+						&appSignature, sizeof(appSignature), &realSize);
+	if (err == noErr)	// No parameters, extract the signature from the Apple Event
+		psn = GetPSNBySig(appSignature);
+	else
+		psn = MoreExtractFromAEDesc::ExtractAESender(inAppleEvent);
+	// Each application can register only once
+	LArrayIterator iter(sURLEchoHandlers);
+	ProcessSerialNumber newPSN;
+	while (iter.Next(&newPSN))	// If we are already registered, returns 
+		if ((newPSN.highLongOfPSN == psn.highLongOfPSN) && (newPSN.lowLongOfPSN == psn.lowLongOfPSN))
+			ThrowOSErr_(errAECoercionFail);
+	sURLEchoHandlers.InsertItemsAt(1,1, &psn);
+	{
+		Boolean success = true;
+		StAEDescriptor	replyDesc(success);
+		err = ::AEPutParamDesc(&outAEReply, keyAEResult, &replyDesc.mDesc);
+	}
+}
+
+
+
+void CNotifierRegistry::HandleUnregisterURLEcho(const AppleEvent &inAppleEvent,
+	AppleEvent &/*outAEReply*/, AEDesc &/*outResult*/, long	/*inAENumber*/)
+{
+	OSType appSignature;
+	ProcessSerialNumber psn;
+	
+	Size 	realSize;
+	OSType	realType;
+
+	OSErr err = ::AEGetParamPtr(&inAppleEvent, keyDirectObject, typeApplSignature, &realType,
+						&appSignature, sizeof(appSignature), &realSize);
+	if (err == noErr)	// No parameters, extract the signature from the Apple Event
+		psn = GetPSNBySig(appSignature);
+	else
+		psn = MoreExtractFromAEDesc::ExtractAESender(inAppleEvent);
+	LArrayIterator	iter(::sURLEchoHandlers);
+	ProcessSerialNumber newPSN;
+	while (iter.Next(&newPSN))
+		if ((newPSN.highLongOfPSN == psn.highLongOfPSN) && (newPSN.lowLongOfPSN == psn.lowLongOfPSN))
+			sURLEchoHandlers.Remove(&newPSN);
+}
+
+// Echoing of the URLs. For each registered application, send them the URLEcho AE
+void FE_URLEcho(URL_Struct *url, int /*iStatus*/, MWContext *context)
+{
+	ProcessSerialNumber psn;
+	OSErr err;
+	LArrayIterator	iter(sURLEchoHandlers);
+	while (iter.Next(&psn))
+	Try_
+	{
+	// Create the event, fill in all the arguments, and send it
+		AEAddressDesc	target;	// Target the event
+		err = AECreateDesc(typeProcessSerialNumber, &psn,sizeof(psn), &target);
+		ThrowIfOSErr_(err);
+		AppleEvent	echoEvent;
+		err = ::AECreateAppleEvent(AE_spy_send_suite, AE_spy_URLecho,
+									&target,
+									kAutoGenerateReturnID,
+									kAnyTransactionID,
+									&echoEvent);
+		ThrowIfOSErr_(err);
+		AEDisposeDesc(&target);
+	// Add the URL
+		if (url->address)
+		{
+			err = ::AEPutParamPtr(&echoEvent, keyDirectObject, typeChar, url->address, strlen(url->address)); 
+			ThrowIfOSErr_(err);
+		}
+	// Add the MIME type
+		if (url->content_type)
+		{
+			err = ::AEPutParamPtr(&echoEvent, AE_spy_URLecho_mime, typeChar, url->content_type, strlen(url->content_type)); 
+			ThrowIfOSErr_(err);
+		}
+	// Add the refererer
+		if (url->referer)
+		{
+			err = ::AEPutParamPtr(&echoEvent, AE_spy_URLecho_referer, typeChar, url->referer, strlen(url->referer)); 
+			ThrowIfOSErr_(err);
+		}	
+	// Add the window ID
+		CNSContext* nsContext = ExtractNSContext(context);
+		ThrowIfNil_(context);
+		Int32 windowID = nsContext->GetContextUniqueID();
+		err = ::AEPutParamPtr(&echoEvent, AE_spy_URLecho_win, typeLongInteger, &windowID, sizeof(windowID)); 
+		ThrowIfOSErr_(err);
+		AppleEvent reply;
+		err = ::AESend(&echoEvent, &reply, kAENoReply,kAENormalPriority,0,nil, nil);
+		AEDisposeDesc(&echoEvent);
+		ThrowIfOSErr_(err);
+	}
+	Catch_(inErr){}
+	EndCatch_
+}
+
+// Registering the protocol
+// The protocol is registered by application signature
+void CNotifierRegistry::HandleRegisterProtocol(const AppleEvent &inAppleEvent,
+	AppleEvent &/*outAEReply*/, AEDesc &/*outResult*/, long	/*inAENumber*/)
+{
+	Size realSize;
+	DescType realType;
+	OSType appSignature;
+	char * protocol = nil;
+	CProtocolHelper * volatile helper;
+	
+	Try_
+	{
+		OSErr err = ::AEGetParamPtr(&inAppleEvent, keyDirectObject, typeApplSignature, &realType,
+							&appSignature, sizeof(appSignature), &realSize);
+		if (err != noErr)	// Signature was not passed appropriately typed, try as type
+		{
+			OSErr err = ::AEGetParamPtr(&inAppleEvent, keyDirectObject, typeType, &realType,
+							&appSignature, sizeof(appSignature), &realSize);
+			if (err != noErr)	// No signature passed, extract it from the Apple Event
+			{
+				ProcessSerialNumber psn = MoreExtractFromAEDesc::ExtractAESender(inAppleEvent);
+				ProcessInfoRec pir;
+				FSSpec dummy;
+				pir.processAppSpec = &dummy;
+				err = ::GetProcessInformation(&psn, &pir);
+				ThrowIfOSErr_(err);
+				appSignature = pir.processSignature;
+			}
+		}
+		// Extract the protocol
+		MoreExtractFromAEDesc::GetCString(inAppleEvent, AE_spy_register_protocol_pro, protocol);
+		// Have app signature, and protocol, add them to the list
+		helper = new CProtocolHelper(protocol, appSignature);
+		CProtocolHelper::AddNewHelper(helper);
+	}
+	Catch_(inErr){}
+	EndCatch_
+}
+
+void CNotifierRegistry::HandleUnregisterProtocol(const AppleEvent &inAppleEvent,
+	AppleEvent &/*outAEReply*/, AEDesc &/*outResult*/, long	/*inAENumber*/)
+{
+	Size realSize;
+	DescType realType;
+	OSType appSignature;
+	char * protocol = nil;
+	
+	Try_
+	{
+		OSErr err = ::AEGetParamPtr(&inAppleEvent, keyDirectObject, typeApplSignature, &realType,
+							&appSignature, sizeof(appSignature), &realSize);
+		if (err != noErr)
+			err = ::AEGetParamPtr(&inAppleEvent, keyDirectObject, typeType, &realType,
+							&appSignature, sizeof(appSignature), &realSize);
+		if (err != noErr)	// No signature passed, extract it from the Apple Event
+		{
+			ProcessSerialNumber psn = MoreExtractFromAEDesc::ExtractAESender(inAppleEvent);
+			ProcessInfoRec pir;
+			FSSpec dummy;
+			pir.processAppSpec = &dummy;
+			err = ::GetProcessInformation(&psn, &pir);
+			ThrowIfOSErr_(err);
+			appSignature = pir.processSignature;
+		}
+		// Extract the protocol. Not necessary. If we only have the sig, remove all the registered protocols
+		Try_
+		{
+			MoreExtractFromAEDesc::GetCString(inAppleEvent, AE_spy_register_protocol_pro, protocol);
+		}
+		Catch_(inErr){}
+		EndCatch_
+		// Delete it from the list
+		LArrayIterator iter(sProtocolHandlers);
+		CProtocolHelper * helper;
+		while (iter.Next(&helper))	// Delete duplicate registration for this protocol
+			if (helper->EqualTo(protocol, appSignature))
+			{
+				delete helper;
+				sProtocolHandlers.Remove(&helper);
+			}
+		if (protocol)
+			NET_DelExternalURLType(protocol);
+	}
+	Catch_(inErr){}
+	EndCatch_
+}
+
+
+XP_Bool FE_UseExternalProtocolModule(MWContext *context,
+	FO_Present_Types /*iFormatOut*/, URL_Struct *url,
+	Net_GetUrlExitFunc */*pExitFunc*/)
+{
+
+#ifndef MOZ_MAIL_NEWS	
+	if (url->address && CInternetConfigInterface::CurrentlyUsingIC()) {
+		ICError err = CInternetConfigInterface::SendInternetConfigURL(url->address);
+		if (err == noErr)
+			return true;
+	}
+#endif
+
+	LArrayIterator iter(sProtocolHandlers);
+	CProtocolHelper * helper;
+	while (iter.Next(&helper))
+		if (helper->AttemptLaunch(url, context))
+			return true;
+	return false;
+}
+

mozilla/cmd/macfe/applevnt/mregistr.h

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// mregistr.h
+// Registry for AppleEvent notifiers
+// Pretty clumsy right now, but separating this functionality out of uapp seems
+// to be the right thing.
+// It is just a collection of routines
+
+#pragma once
+
+#include <LArray.h>
+
+class CNotifierRegistry	{
+public:
+// ¥¥ÊAppleEvent handling
+	static void			HandleAppleEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	static void			ReadProtocolHandlers();	// Saving to prefs interface
+	static void			WriteProtocolHandlers();
+
+private:
+	static void 		HandleRegisterProtocol(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	static void 		HandleUnregisterProtocol(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+// ¥¥ url echo
+	static void 		HandleRegisterURLEcho(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	static void 		HandleUnregisterURLEcho(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+};

mozilla/cmd/macfe/applevnt/ulaunch.cp

@@ -0,0 +1,489 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ulaunch.cp
+// Launching of external applications through AppleEvents
+// Created by atotic, June 14th, 1994
+// Based on Apple's LaunchWithDoc example snippet
+
+#include <Folders.h>
+#include <AERegistry.h>
+#include <Errors.h>
+
+#include "BufferStream.h"
+
+#include "PascalString.h"
+
+#include "macutil.h"
+#include "uprefd.h"
+#include "ufilemgr.h"
+#include "uerrmgr.h"
+#include "reserr.h"
+#include "ulaunch.h"
+
+// ¥¥ PROTOTYPES
+OSErr FindAppOnVolume(OSType sig, short vRefNum, FSSpec& thefile);
+
+// Sends an ODOC event to creator in fndrInfo,
+// with file in fileSpec
+OSErr SendODOCEvent(OSType appSig, 
+				LFileBufferStream * inFile);
+				
+// Launches the application with the given doc
+void LaunchWithDoc(FInfo& fndrInfo, 
+					FSSpec& appSpec,
+					LFileBufferStream * inFile,
+					const FSSpec inFileSpec);
+
+
+// Displays a launching error alert.
+int LaunchError(ResIDT alertID, OSType creator, const Str63& fileName, OSErr err);
+
+// Creates Finder's OpenSelection event
+OSErr BuildOpenSelectionEvent(FSSpec & fileSpec, AppleEvent& theEvent);
+
+// Sends OpenSelection to Finder
+OSErr SendOpenSelectionToFinder(FSSpec & fileSpec);
+
+// ¥¥ Implementation
+
+
+
+// Builds an ODOC event
+OSErr BuildODOCEvent(OSType applSig, 
+					FSSpec fileSpec, 
+					AppleEvent& theEvent)	{
+// Builds all the arguments for the event
+	AEDesc myAddress;
+	AEDesc docDesc;
+	AEDescList theList;
+	AliasHandle withThis;
+	OSErr err;
+	
+// Anatomy of the event:
+// Event class: kCoreEventClass
+// Event ID: kAEOpenDocuments
+// Event has target description (in the form of typeApplSignature)
+// keyDirectObject is a list of aliases
+
+  	err = AECreateDesc(typeApplSignature,
+  						(Ptr)&applSig, sizeof(applSig),
+  					 	&myAddress);
+	if (err) return err;
+	
+	err = AECreateAppleEvent(kCoreEventClass, kAEOpenDocuments, 
+							&myAddress, 
+							kAutoGenerateReturnID, kAnyTransactionID, 
+							&theEvent);
+	if (err) return err;
+	// create a list for the alaises.  In this case, I only have one, but 
+	// you still need a list
+
+	err = AECreateList(NULL, 0, FALSE, &theList);
+	if (err) return err;
+
+	/* create an alias out of the file spec */
+	/* I'm not real sure why I did this, since there is a system coercion handler for */
+	/* alias to FSSpec, but I'm paranoid */
+
+	err = NewAlias(NULL, &fileSpec, &withThis);
+	if (err) return err;
+
+	HLock((Handle)withThis);
+
+	/* now create an alias descriptor */
+	err = AECreateDesc(typeAlias, (Ptr) * withThis, GetHandleSize((Handle)withThis), &docDesc);
+	if (err) return err;
+
+	HUnlock((Handle)withThis);
+
+	/* put it in the list */
+	err = AEPutDesc(&theList, 0, &docDesc);
+	if (err) return err;
+	err = AEPutParamDesc(&theEvent, keyDirectObject, &theList);
+	err = AEDisposeDesc(&myAddress);
+	err = AEDisposeDesc(&docDesc);
+	err = AEDisposeDesc(&theList);
+	return err;
+}
+
+// Sends an ODOC event to appliation
+OSErr SendODOCEvent(OSType appSig, 
+				LFileBufferStream * inFile)
+{
+	OSErr err;
+	Try_ {
+		AppleEvent	openEvent;
+		FSSpec inFileSpec;
+		inFile->GetSpecifier(inFileSpec);
+		err = BuildODOCEvent(appSig, 
+							inFileSpec, 
+							openEvent);
+		ThrowIfOSErr_(err);
+		AppleEvent result;
+		err = AESend(&openEvent, &result, 
+					kAENoReply  + kAECanSwitchLayer,
+					kAENormalPriority, kAEDefaultTimeout,
+					NULL,NULL);
+		AEDisposeDesc(&openEvent);
+		// err could be memFullErr, app is out of memory
+		ThrowIfOSErr_(err);
+	}
+	Catch_(inErr) {
+		return inErr;
+	} EndCatch_
+	return err;
+}
+
+#define kDelete 2
+#define kSave	1
+#define kTryAgain 3
+// Displays launch error dialogs with appropriate arguments.
+// Alerts used are:
+// ALRT_ODOCFailed
+// ALRT_AppNotFound
+// ALRT_AppMemFull
+// ALRT_MiscLaunchError
+// Returns: kDelete, kSave, or kTryAgain
+int LaunchError(ResIDT alertID, OSType creator, const Str63& fileName, OSErr err)
+{
+		CMimeMapper * map = CPrefs::sMimeTypes.FindCreator(creator);
+		ErrorManager::PrepareToInteract();
+		CStr255		errorString;
+		ErrorManager::OSNumToStr(err, errorString);
+		ParamText(map->GetAppName(), fileName, errorString, "\p");
+		UDesktop::Deactivate();
+		int retVal = ::CautionAlert(alertID, NULL);
+		UDesktop::Activate();
+		return retVal;
+}
+
+// Launches an application with a given doc
+OSErr StartDocInApp(FSSpec theDocument,  FSSpec theApplication)
+{
+	FInfo fndrInfo;
+	OSErr	err;
+	
+	HGetFInfo(	theApplication.vRefNum,
+				theApplication.parID,
+				theApplication.name,
+				&fndrInfo);
+				
+	FSSpec applSpecTemp;
+	ProcessSerialNumber processSN;
+	err = FindProcessBySignature(fndrInfo.fdCreator, 'APPL',  processSN, &applSpecTemp);
+	if (err == noErr)	// App is running. Send 'odoc'
+	{
+		Try_ {
+			AppleEvent theEvent;
+			err = BuildODOCEvent(fndrInfo.fdCreator, theDocument, theEvent);
+			ThrowIfOSErr_(err);
+			AppleEvent result;
+			err = AESend(&theEvent, &result, 
+						kAENoReply + kAEAlwaysInteract + kAECanSwitchLayer,
+						kAENormalPriority, kAEDefaultTimeout,
+						NULL,NULL);
+			AEDisposeDesc(&theEvent);
+			// err could be memFullErr, app is out of memory
+			ThrowIfOSErr_(err);
+			if (IsFrontApplication())
+				SetFrontProcess(&processSN);
+		}
+		Catch_(inErr) {
+			return inErr;
+		} EndCatch_
+		
+		return noErr;
+	}
+
+	Try_	{
+		LaunchParamBlockRec launchThis;
+		AEDesc launchDesc;
+		AppleEvent theEvent;
+	
+		ThrowIfOSErr_(BuildODOCEvent(fndrInfo.fdCreator, theDocument, theEvent));
+		ThrowIfOSErr_(AECoerceDesc(&theEvent, typeAppParameters, &launchDesc));
+		
+		launchThis.launchAppSpec = (FSSpecPtr)&theApplication;
+		launchThis.launchAppParameters = (AppParametersPtr)*(launchDesc.dataHandle);
+		launchThis.launchBlockID = extendedBlock;
+		launchThis.launchEPBLength = extendedBlockLen;
+		launchThis.launchFileFlags = NULL;
+		launchThis.launchControlFlags = launchContinue + launchNoFileFlags + launchUseMinimum;
+		if (!IsFrontApplication())
+			launchThis.launchControlFlags += launchDontSwitch;
+		err = LaunchApplication(&launchThis);
+		ThrowIfOSErr_(err);
+	}
+	Catch_(inErr)
+	{
+	} EndCatch_
+	return err;
+}
+
+// Launches the application with the given doc
+void LaunchWithDoc(FInfo& fndrInfo, 
+				FSSpec& appSpec,
+				LFileBufferStream * inFile,
+				const FSSpec inFileSpec)
+{
+	OSErr err = CFileMgr::FindApplication(fndrInfo.fdCreator, appSpec);
+	if (err)	// Application not found error
+	{
+		int whatToDo = ::LaunchError(ALRT_AppNotFound, fndrInfo.fdCreator, 
+									inFileSpec.name, err);
+		if (whatToDo == kSave)
+			CFileMgr::sFileManager.CancelRegister(inFile);		// Save the file
+		else	// kDelete
+			CFileMgr::sFileManager.CancelAndDelete(inFile);		// Delete the file
+		return;
+	}
+	
+	Try_	{
+		LaunchParamBlockRec launchThis;
+		AEDesc launchDesc;
+		AppleEvent theEvent;
+	
+		ThrowIfOSErr_(BuildODOCEvent(fndrInfo.fdCreator, inFileSpec, theEvent));
+		ThrowIfOSErr_(AECoerceDesc(&theEvent, typeAppParameters, &launchDesc));
+		
+		launchThis.launchAppSpec = (FSSpecPtr)&appSpec;
+		launchThis.launchAppParameters = (AppParametersPtr)*(launchDesc.dataHandle);
+		/* launch the thing */
+		launchThis.launchBlockID = extendedBlock;
+		launchThis.launchEPBLength = extendedBlockLen;
+		launchThis.launchFileFlags = NULL;
+		launchThis.launchControlFlags = launchContinue + launchNoFileFlags + launchUseMinimum;
+		if (!IsFrontApplication())
+			launchThis.launchControlFlags += launchDontSwitch;
+		do		// Launch until we succeed, or user gives up.
+		{
+			err = LaunchApplication(&launchThis);
+			if ((err == memFullErr) || (err == memFragErr))	
+			// Launch failed because of low memory
+			{
+				int whatToDo = ::LaunchError(ALRT_AppMemFull, fndrInfo.fdCreator, 
+											inFileSpec.name, err);
+				switch (whatToDo)	{
+				case kSave:
+					CFileMgr::sFileManager.CancelRegister(inFile);		// Save the file
+					err = noErr;
+					break;
+				case kDelete:
+					CFileMgr::sFileManager.CancelAndDelete(inFile);		// Save the file
+					err = noErr;
+					break;
+				case kTryAgain:								// Loop again
+					break;
+				}
+			}
+			else	// Unknown launch error
+				ThrowIfOSErr_(err);
+		} while (err != noErr);
+	}
+	Catch_(inErr)
+	{
+		int whatToDo = ::LaunchError(ALRT_AppMiscError, fndrInfo.fdCreator, 
+									inFileSpec.name, inErr);
+		if (whatToDo == kSave)
+			CFileMgr::sFileManager.CancelRegister(inFile);		// Save the file
+		else	// kDelete
+			CFileMgr::sFileManager.CancelAndDelete(inFile);		// Delete the file
+	} EndCatch_
+}
+
+
+OSErr
+CreateFinderAppleEvent(		AEEventID		eventID,
+							SInt16 			returnID, 
+							SInt32 			transactionID,
+							AppleEvent	&	theEvent)
+{
+	OSErr				err;
+	FSSpec				finder;
+	ProcessSerialNumber	psn;
+	AEDesc				finderAddress;
+	Boolean				validAddress = false;
+	
+	try
+	{
+		err = FindProcessBySignature('MACS', 'FNDR', psn, &finder);
+		ThrowIfOSErr_(err);
+ 		
+ 		err = ::AECreateDesc(typeProcessSerialNumber, (Ptr)&psn, sizeof(psn), &finderAddress);
+		ThrowIfOSErr_(err);
+		validAddress = true;
+		
+		err = ::AECreateAppleEvent(	kAEFinderEvents, 
+									eventID, 
+									(const AEAddressDesc *) &finderAddress, 
+									returnID, 
+									transactionID, 
+									&theEvent	);
+
+	}
+	catch(long tErr)
+	{
+		if (validAddress) 
+			::AEDisposeDesc(&finderAddress);
+	}
+
+	return err;
+}
+
+// Builds an OpenSelection event for Finder
+OSErr BuildOpenSelectionEvent(FSSpec & fileSpec, AppleEvent& theEvent)	{
+	FSSpec dirSpec, procSpec;
+	FSSpecPtr theFileToOpen = nil;
+	CStr63 processName;
+	AEDesc aeDirDesc, listElem;
+	AEDesc fileList;
+	ConstStr255Param * dummy  = NULL;
+// Create the event
+	OSErr err;
+	Try_ {
+		ProcessInfoRec pir;
+		pir.processInfoLength = sizeof(ProcessInfoRec);
+		pir.processName = (StringPtr)&processName;
+		pir.processAppSpec = &procSpec;
+	// Find a Finder, and create its description as an address for an apple event
+	
+		err = CreateFinderAppleEvent(kAEOpenSelection, kAutoGenerateReturnID, kAnyTransactionID, theEvent);
+		ThrowIfOSErr_(err);
+		
+	// Create a description of the file, and the enclosing folder
+	// keyDirectObject is directory description
+	//
+		err = CFileMgr::FolderSpecFromFolderID(fileSpec.vRefNum, fileSpec.parID, dirSpec);
+		ThrowIfOSErr_(err);
+		
+		err = AECreateList(nil, 0, false, &fileList);
+		ThrowIfOSErr_(err);
+
+	 	AliasHandle DirAlias, FileAlias;
+		NewAlias(nil, &dirSpec, &DirAlias);
+		HLock((Handle)DirAlias);
+		err = AECreateDesc(typeAlias, (Ptr)*DirAlias, GetHandleSize((Handle)DirAlias), &aeDirDesc);
+		ThrowIfOSErr_(err);
+		HUnlock((Handle)DirAlias);
+		DisposeHandle((Handle)DirAlias);
+		
+		err = AEPutParamDesc(&theEvent, keyDirectObject, &aeDirDesc);
+		ThrowIfOSErr_(err);
+		AEDisposeDesc(&aeDirDesc);
+
+		NewAlias(nil, &fileSpec, &FileAlias);
+		HLock((Handle)FileAlias);
+		err = AECreateDesc(typeAlias, (Ptr)*FileAlias, GetHandleSize((Handle)FileAlias), &listElem);
+		ThrowIfOSErr_(err);
+		HUnlock((Handle)FileAlias);
+		err = AEPutDesc(&fileList, 0, &listElem);
+		ThrowIfOSErr_(err);
+		DisposeHandle((Handle)FileAlias);
+
+		err = AEPutParamDesc( &theEvent, keySelection, &fileList);
+		ThrowIfOSErr_(err);		
+	}
+	Catch_(inErr)
+	{
+		return inErr;
+	} EndCatch_
+	return noErr;
+}
+
+// Sends 'open selection event to Finder
+OSErr SendOpenSelectionToFinder(FSSpec & fileSpec)
+{
+	AppleEvent event;
+	AppleEvent result;
+	OSErr err = BuildOpenSelectionEvent(fileSpec, event);
+	if (err)
+		return err;
+	err = AESend(&event, &result, 
+					kAENoReply + kAEAlwaysInteract + kAECanSwitchLayer,
+					kAENormalPriority, kAEDefaultTimeout,
+					NULL,NULL);
+	AEDisposeDesc(&event);
+	return err;
+}
+
+// A somewhat tricky way of opening a foreign document
+// Algorithm: 
+//	- if a process is not running, launch it with the document
+//  - if a process is running and AE aware, send it an AppleEvent
+//  - if a process is running and is not AE aware, send openSelection to the Finder.
+void LaunchFile(LFileBufferStream * inFile)
+{
+	FSSpec applSpec;
+	FInfo fndrInfo;
+	
+// Get file info
+	FSSpec inFileSpec;
+	inFile->GetSpecifier(inFileSpec);
+	
+	HGetFInfo(inFileSpec.vRefNum,
+				inFileSpec.parID,
+				inFileSpec.name,
+				&fndrInfo);
+
+// Find if the application is already running
+	ProcessSerialNumber processSN;
+	ProcessInfoRec infoRecToFill;
+	Str63 processName;
+	infoRecToFill.processInfoLength = sizeof(ProcessInfoRec);
+	infoRecToFill.processName = (StringPtr)&processName;
+	infoRecToFill.processAppSpec = &applSpec;
+	OSErr err = FindProcessBySignature(fndrInfo.fdCreator, 'APPL',  processSN, &applSpec);
+	
+	if (err == noErr)	// App is running. Send 'odoc'
+	{
+		err = SendODOCEvent(fndrInfo.fdCreator, inFile);
+		if (err == noErr)
+		{
+			if (IsFrontApplication())
+				SetFrontProcess(&processSN);
+		}
+		else
+		{
+			// Application did not accept apple event for some reason (err = connectionInvalid)
+			// Send 'odoc' to Finder. Finder can figure out how to fake menu events when
+			// it tries to open the file
+			err = SendOpenSelectionToFinder(inFileSpec);
+			if (err == noErr)
+			{		// If finder launched the application successfully, find it and bring it to front
+				err = FindProcessBySignature(fndrInfo.fdCreator, 'APPL',  processSN, &applSpec);
+				if (err == noErr && IsFrontApplication())
+					SetFrontProcess(&processSN);
+			}
+			else	// Finder launch also failed. Notify the user
+			{
+				//Notify the user, try to handle the error
+				int whatToDo = LaunchError(ALRT_ODOCFailed, 
+											fndrInfo.fdCreator,
+											 inFileSpec.name, err);
+				if (whatToDo == 1)
+					CFileMgr::sFileManager.CancelRegister(inFile);		// Save the file
+				else
+					CFileMgr::sFileManager.CancelAndDelete(inFile);		// Delete the file
+			}
+		}
+	}
+	else				// App is not running. Launch it with this file
+		LaunchWithDoc(fndrInfo, applSpec, inFile, inFileSpec);
+}
+

mozilla/cmd/macfe/applevnt/ulaunch.h

@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ===========================================================================
+// ulaunch.h
+// External application launching routines
+// ===========================================================================
+
+#pragma once
+
+class LFileBufferStream;
+
+// Opens the file in its creator application					
+void LaunchFile(LFileBufferStream * inFile);
+
+// Launches an application with a given doc
+OSErr StartDocInApp(FSSpec theDocument,  FSSpec theApplication);
+
+// Builds an ODOC event for appliation specified by applSig,
+// with file in fileSpec
+OSErr BuildODOCEvent(OSType applSig, 
+					FSSpec fileSpec, 
+					AppleEvent& theEvent);
+
+OSErr
+CreateFinderAppleEvent(		AEEventID		eventID,
+							SInt16 			returnID, 
+							SInt32 			transactionID,
+							AppleEvent	&	theEvent);
+

mozilla/cmd/macfe/central/BookmarksFile.cp

@@ -0,0 +1,108 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "BookmarksFile.h"
+#include "resgui.h"
+#include "fe_proto.h"
+#include <LStream.h>
+
+#include <algorithm>
+
+
+//
+// ReadBookmarksFile
+//
+// Given a file containing a single URL (probably dropped on the Finder), open it and
+// read the URL so we can load it.
+//
+OSErr 
+ReadBookmarksFile ( vector<char> & oURL, FSSpec & inSpec )
+{
+	FInfo info;
+	OSErr err = ::FSpGetFInfo (&inSpec, &info);
+	if (err != noErr)
+		return err;
+	
+	if (info.fdType != emBookmarkFile)
+		return fnfErr;
+
+	try {
+		LFileStream stream(inSpec);
+		stream.OpenDataFork(fsRdPerm);
+		Int32 howMuch;
+		
+		// Read in the URL, which is in the form URL\rTITLE
+		howMuch = stream.ReadData(oURL.begin(), oURL.size());
+		char* where = find(oURL.begin(), oURL.end(), '\r');
+		ThrowIfNil_(where);
+		*where = 0;
+	}
+	catch ( Uint32 inErr )
+	{
+		return inErr;
+	}
+	
+	return noErr;
+}
+
+
+//
+// WriteBookmarksFile
+//
+// Given an URL (probably dropped on the Finder), create a file and store the URL
+//
+OSErr WriteBookmarksFile(char * url, FSSpec & spec)
+{
+	if (!url)
+		return noErr;
+	LFileStream stream(spec);
+	try
+	{
+		stream.CreateNewDataFile(emSignature, emBookmarkFile, 0);
+	}
+	catch (OSErr inErr)
+	{
+		if (inErr != dupFNErr)
+			return inErr;
+	}
+	catch (...)
+	{
+		return memFullErr;
+	}
+
+	try
+	{
+		// Set up the file
+		stream.OpenDataFork(fsRdWrPerm);
+		stream.SetMarker(0, streamFrom_Start);
+
+		char lineEnding = CR;
+		// Write the URL
+		stream.WriteData((void*)url, XP_STRLEN(url) );
+		stream.WriteData(&lineEnding, 1);
+	}
+	catch (OSErr err)
+	{
+		return err;
+	}
+	catch (...)
+	{
+		return memFullErr;
+	}
+	return noErr;
+}

mozilla/cmd/macfe/central/BookmarksFile.h

@@ -0,0 +1,27 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#include <Files.h>
+
+#include <vector.h>
+
+OSErr ReadBookmarksFile( vector<char> & oURL, FSSpec & spec);
+//OSErr WriteBookmarksFile(BM_Entry * entry, FSSpec & spec);
+OSErr WriteBookmarksFile(char * url, FSSpec & spec);

mozilla/cmd/macfe/central/BrowserClasses.cp

@@ -0,0 +1,331 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	BrowserClasses.cp
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#include "BrowserClasses.h"
+
+// ¥¥¥ PowerPlant Classes
+	#include <URegistrar.h>
+	#include <LActiveScroller.h>
+	#include <LButton.h>
+	#include <LCaption.h>
+	#include <LDialogBox.h>
+	#include <LEditField.h>
+	#include <LGroupBox.h>
+	#include <LIconPane.h>
+	#include <LListBox.h>
+	#include <LPicture.h>
+	#include <LPlaceHolder.h>
+	#include <LPrintout.h>
+	#include <LScroller.h>
+	#include <LStdControl.h>
+	#include <LTable.h>
+	#include <LTextEdit.h>
+	#include <LWindow.h>
+	#include <LRadioGroup.h>
+	#include <LTabGroup.h>
+	#include <LTextColumn.h>
+	#include "CTextColumn.h"		// Netscape's own LTextColumn
+	#include <LSubOverlapView.h>
+	
+// ¥¥¥ PowerPlant Grayscale Classes
+	#include <UGALibRegistry.h>
+
+// ¥¥¥ General Purpose UI Classes
+	#include "CBevelButton.h"
+	#include "CPatternButton.h"	
+	#include "CGrayBevelView.h"
+	#include "CPatternBevelView.h"
+	#include "CPatternButtonPopup.h"
+	#include "CGuidePopupMenu.h"
+	#include "CNavigationButtonPopup.h"
+	#include "CCloseAllAttachment.h"
+	#include "CColorEraseAttachment.h"
+	#include "CGABorderPane.h"
+	#include "CPatternPane.h"
+				
+	#include "CIncludeView.h"
+	#include "CPlaceHolderView.h"
+	#include "COffscreenCaption.h"
+	#include "CClusterView.h"
+	#include "CTabSwitcher.h"
+	#include "CPatternTabControl.h"	
+	#include "CProgressBar.h"
+//	#include "CProgressCaption.h"
+	#include "CTaskBarView.h"
+	#include "LTableHeader.h"
+	#include "LTableViewHeader.h"
+	#include "CSimpleDividedView.h"
+	#include "CKeyScrollAttachment.h"	
+	#include "CToolTipAttachment.h"	
+	#include "CDynamicTooltips.h"
+	#include "CPaneEnabler.h"
+	#include "CStringListToolTipPane.h"	
+	#include "CSaveProgress.h"	
+	#include "CPatternProgressBar.h"
+	#include "CScrollerWithArrows.h"
+	
+#ifdef MOZ_MAIL_NEWS
+	#include "CBiffButtonAttachment.h"
+	#include "CSingleLineEditField.h"
+#endif
+	
+// ¥¥¥ Browser Specific UI Classes
+	
+	#include "CDragBar.h"
+	#include "CDragBarContainer.h"
+	#include "CDragBarDockControl.h"
+	#include "CPatternedGrippyPane.h"
+	#include "CDividerGrippyPane.h"
+	#include "CSwatchBrokerView.h"
+	#include "CToolbarDragBar.h"
+	#include "CToolbarPatternBevelView.h"
+	#include "CProxyPane.h"
+	#include "CProxyCaption.h"
+	#include "PopupBox.h"
+	#include "CPersonalToolbarTable.h"
+	#include "CNavCenterWindow.h"
+	#include "CNavCenterSelectorPane.h"
+	#include "CNavCenterContextMenuAtt.h"
+	#include "CNavCenterTitle.h"
+	#include "CInlineEditField.h"
+
+	#include "CConfigActiveScroller.h"
+	#include "CTSMEditField.h"
+//	#include "VEditField.h"
+//	#include "CSimpleTextView.h"
+	
+	#include "CDownloadProgressWindow.h"
+	#include "CURLEditField.h"
+	#include "CAutoCompleteURLEditField.h"
+	#include "CURLCaption.h"
+	#include "CHyperScroller.h"
+	#include "CButtonEnablerReloadStop.h"
+
+	#include "CBrowserWindow.h"
+	#include "CHTMLView.h"
+	#include "CBrowserView.h"
+
+	#include "CSpinningN.h"
+	#include "CBrowserSecurityButton.h"
+	#include "CMiniSecurityButton.h"
+
+	#include "mprint.h"
+	#include "macgui.h"
+	#include "findw.h"
+//	#include "prefw.h"
+
+	#include "BookmarksDialogs.h"
+	#include "mplugin.h"
+	#include "divview.h"
+//	#include "mattach.h"
+	#include "UFormElementFactory.h"
+	
+	#include "CMenuTable.h"
+	#include "CPrefsMediator.h"
+	#include "CAssortedMediators.h"
+
+#if defined (JAVA)
+	#include "mjava.h"
+#endif
+	
+	#include "CEditorWindow.h"
+
+//	#include "mhistory.h"
+	#include "CContextMenuAttachment.h"
+	
+	#include "CHyperTreeFlexTable.h"
+	#include "CRDFCoordinator.h"
+	#include "CHyperTreeHeader.h"
+
+//-----------------------------------
+void RegisterAllBrowserClasses(void)
+//-----------------------------------
+{
+	// AutoRegister classes
+	
+	RegisterClass_(CProxyPane);
+	RegisterClass_(CProxyCaption);
+	RegisterClass_(CCloseAllAttachment);
+	RegisterClass_(CColorEraseAttachment);
+	RegisterClass_(CGABorderPane);
+	RegisterClass_(CPatternPane);
+	
+	RegisterClass_(LSubOverlapView);
+
+	// ¥¥¥ PowerPlant Classes
+	RegisterClass_(LButton);
+	RegisterClass_(LCaption);
+	RegisterClass_(LDialogBox);
+	RegisterClass_(LEditField);
+	RegisterClass_(LListBox);
+	RegisterClass_(LPane);
+	RegisterClass_(LPicture);
+	RegisterClass_(LPlaceHolder);
+	RegisterClass_(LPrintout);
+	RegisterClass_(LScroller);
+	RegisterClass_(LStdControl);
+	RegisterClass_(LStdButton);
+	RegisterClass_(LStdCheckBox);
+	RegisterClass_(LStdRadioButton);
+	RegisterClass_(LStdPopupMenu);
+	RegisterClass_(LTextEdit);
+	RegisterClass_(LView);
+	RegisterClass_(LWindow);
+	RegisterClass_(LRadioGroup);
+	RegisterClass_(LTabGroup);
+	RegisterClass_(LActiveScroller);
+
+	//LRegistrar::RegisterClass('prto', (ClassCreatorFunc);LPrintout::CreateOldPrintoutStream);
+
+#ifdef PP_NewClasses
+	#include <LCicnButton.h>
+	#include <LOffscreenView.h>
+	#include <LTextButton.h>
+
+	RegisterClass_(LCicnButton);
+	RegisterClass_(LOffscreenView);
+	RegisterClass_(LTextButton);
+#endif
+	RegisterClass_(LTable);
+	RegisterClass_(LIconPane);
+	RegisterClass_(LGroupBox);
+	RegisterClass_(LTextColumn);
+	RegisterClass_(CTextColumn);	// Netscape's own LTextColumn
+
+	RegisterClass_(CGAPopupMenu);
+	
+	// ¥¥¥ PowerPlant Grayscale Classes
+	RegisterGALibraryClasses();
+
+	// ¥¥¥ General Purpose UI Classes
+	RegisterClass_(CBevelButton);
+	RegisterClass_(CDeluxeBevelButton);
+	RegisterClass_(CPatternButton);
+	RegisterClass_(CPatternButtonPopup);
+	RegisterClass_(CGrayBevelView);
+	RegisterClass_(CPatternBevelView);
+	
+		
+	RegisterClass_(CIncludeView);
+	RegisterClass_(CPlaceHolderView);
+	RegisterClass_(COffscreenCaption);
+	RegisterClass_(CClusterView);
+	RegisterClass_(CPatternTabControl);
+	RegisterClass_(CTabSwitcher);
+	RegisterClass_(CProgressBar);
+	RegisterClass_(CKeyScrollAttachment);
+	RegisterClass_(CToolTipAttachment);
+	RegisterClass_(CDynamicTooltipPane);
+	RegisterClass_(CSharedToolTipAttachment);
+	RegisterClass_(CMenuTable);
+	RegisterClass_(CPaneEnabler);
+	RegisterClass_(CSlaveEnabler);
+	RegisterClass_(CScrollerWithArrows);
+	RegisterClass_(CScrollArrowControl);
+	
+#ifdef MOZ_MAIL_NEWS
+	RegisterClass_(CSingleLineEditField);
+	RegisterClass_(CSelectFolderMenu);
+//#else
+//	RegisterClass_(CBiffButtonAttachment);
+#endif // MOZ_MAIL_NEWS
+	RegisterClass_(CSimpleDividedView);
+	//RegisterClass_(CProgressCaption);
+	RegisterClass_(CTaskBarView);
+
+	RegisterClass_(CToolTipPane);
+	RegisterClass_(CStringListToolTipPane);
+
+	RegisterClass_(LTableHeader);
+	RegisterClass_(LTableViewHeader);
+
+	RegisterClass_(CPatternProgressBar);
+	RegisterClass_(CPatternProgressCaption);
+
+	RegisterClass_(CTextEdit);
+	RegisterClass_(CEditBroadcaster);
+
+	RegisterClass_(CGuidePopupMenu);
+	RegisterClass_(CNavigationButtonPopup);
+	
+	// *** Browser Specific UI Classes
+
+	RegisterClass_(CDragBar);
+	RegisterClass_(CDragBarContainer);
+	RegisterClass_(CDragBarDockControl);
+	RegisterClass_(CBrokeredView);
+	RegisterClass_(CSwatchBrokerView);
+	RegisterClass_(CToolbarDragBar);
+	RegisterClass_(CToolbarPatternBevelView);
+	RegisterClass_(CPersonalToolbarTable);
+	
+	RegisterClass_(CConfigActiveScroller);
+	RegisterClass_(CTSMEditField);
+//	REGISTERV(EditField);
+	
+	RegisterClass_(CDownloadProgressWindow);
+	RegisterClass_(CBrowserWindow);
+	RegisterClass_(CHTMLView);
+	RegisterClass_(CURLEditField);
+	RegisterClass_(CAutoCompleteURLEditField);
+	RegisterClass_(CURLCaption);
+	RegisterClass_(CSaveProgress);
+	RegisterClass_(CHyperScroller);
+	RegisterClass_(CButtonEnablerReloadStop);
+	RegisterClass_(CBrowserView);
+
+	RegisterClass_(CPatternedGrippyPane);
+	RegisterClass_(CDividerGrippyPane);
+	RegisterClass_(CSpinningN);
+	RegisterClass_(CBrowserSecurityButton);
+	RegisterClass_(CMiniSecurityButton);
+	
+	RegisterClass_(CHyperTreeFlexTable);
+	RegisterClass_(CNavCenterSelectorPane);
+	RegisterClass_(CRDFCoordinator);
+	RegisterClass_(CHyperTreeHeader);
+	RegisterClass_(CInlineEditField);
+
+	RegisterClass_(CNavCenterWindow);
+	RegisterClass_(CBookmarksFindDialog);
+	RegisterClass_(CPluginView);
+	RegisterClass_(LDividedView);
+	RegisterClass_(CNavCenterContextMenuAttachment);
+	RegisterClass_(CNavCenterSelectorContextMenuAttachment);
+	RegisterClass_(CNavCenterTitle);
+	
+#ifdef EDITOR
+	CEditorWindow::RegisterViewTypes();
+#endif // EDITOR
+	CFindWindow::RegisterViewTypes();
+	UFormElementFactory::RegisterFormTypes();
+	UHTMLPrinting::RegisterHTMLPrintClasses();
+	CPrefsMediator::RegisterViewClasses();
+	CPrefsDialog::RegisterViewClasses();
+	UAssortedPrefMediators::RegisterViewClasses();
+
+	RegisterClass_(CContextMenuAttachment);
+#ifdef JAVA
+	RegisterClass_(CJavaView);
+#endif
+
+} // RegisterAllBrowserClasses

mozilla/cmd/macfe/central/BrowserClasses.h

@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	BrowserClasses.h
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#pragma once
+
+void RegisterAllBrowserClasses(void);

mozilla/cmd/macfe/central/BufferStream.cp

@@ -0,0 +1,144 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "BufferStream.h"
+
+#include "client.h"
+
+#ifdef PROFILE
+#pragma profile on
+#endif
+
+#define STREAM_BUFFER_SIZE	32000
+
+LFileBufferStream::LFileBufferStream( FSSpec& inFileSpec ): LFileStream( inFileSpec )
+{
+	fBuffer = NULL;
+	fBufferSize = 0;
+	fLastWritten = 0;
+	fUseBuffer = FALSE;
+	fURL = NULL;
+	fWriteFailed = FALSE;
+}
+
+LFileBufferStream::~LFileBufferStream()
+{
+	Try_
+	{
+		FlushBuffer( FALSE );
+	}
+	Catch_(inErr)
+	{
+	}
+	EndCatch_
+	if ( fURL )
+		XP_FREE( fURL );
+}
+
+OSErr LFileBufferStream::FlushBuffer( Boolean allocateNew )
+{
+	OSErr	err = noErr;
+	
+	if ( !fUseBuffer )
+		return err;
+
+	if ( fBuffer && ( fLastWritten > 0 ) )
+	{
+		HLock( fBuffer );
+		Try_	
+		{
+			err = LFileStream::PutBytes( *fBuffer, fLastWritten );
+			ThrowIfOSErr_(err);
+			HUnlock( fBuffer );
+		}
+		Catch_(inErr)
+		{
+			HUnlock( fBuffer );
+			DisposeHandle(fBuffer);
+			fBuffer = NULL;
+			fWriteFailed = TRUE;
+		}
+		EndCatch_
+		fLastWritten = 0;
+	}
+	
+	if (fWriteFailed)
+		return err;
+
+	if ( allocateNew && ( !fBuffer ) )
+	{
+		fBuffer = ::NewHandle( STREAM_BUFFER_SIZE );
+		fBufferSize = STREAM_BUFFER_SIZE;
+		fLastWritten = 0;
+	}
+
+	if ( !allocateNew && fBuffer )
+	{
+		DisposeHandle( fBuffer );
+		fBuffer = NULL;
+	}
+	
+	return err;
+}
+
+Int32 LFileBufferStream::ReadData( void* outBuffer, Int32 inByteCount )
+{
+	return LFileStream::ReadData( outBuffer, inByteCount );
+}
+
+void LFileBufferStream::DoUseBuffer()
+{
+	fUseBuffer = TRUE;
+}
+
+void LFileBufferStream::CloseDataFork()
+{
+	FlushBuffer( FALSE );
+	LFileStream::CloseDataFork();
+}
+
+Int32 LFileBufferStream::WriteData( const void* inFromBuffer, Int32 inByteCount )
+{
+	OSErr err = noErr;
+	
+	if ( fUseBuffer && ( fLastWritten + inByteCount ) > fBufferSize )
+		err = FlushBuffer( TRUE );
+		
+	ThrowIfOSErr_(err);
+
+	if ( ( fBuffer ) && 	// If we have space, fill up the buffer
+		( ( fLastWritten + inByteCount ) <= fBufferSize ) )
+	{
+		::BlockMoveData( inFromBuffer, &( (*fBuffer)[fLastWritten] ), inByteCount );
+		fLastWritten += inByteCount;
+		return inByteCount;
+	}
+	// Otherwise, just do a normal write
+	else
+	{
+		err = LFileStream::PutBytes( inFromBuffer, inByteCount );
+		ThrowIfOSErr_(err);
+	}
+
+	return inByteCount;
+}
+
+
+#ifdef PROFILE
+#pragma profile off
+#endif

mozilla/cmd/macfe/central/BufferStream.h

@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#ifndef __BUFFERSTREAM__
+#define __BUFFERSTREAM__
+
+#include <LFileStream.h>
+#include <stddef.h>
+
+// Does plain buffered read/writes
+// Buffering strategy:
+//	reading:	read all you can fit in the buffer
+//				give it to the client in small chunks
+//	writing:	write all you can fit in the buffer
+//				on overflow, flush everything, then write the rest
+// for now, we only buffer writing
+class LFileBufferStream: public LFileStream
+{
+public:
+					LFileBufferStream( FSSpec& inFileSpec );
+	virtual			~LFileBufferStream();
+	virtual Int32	WriteData( const void *inFromBuffer, Int32 inByteCount );
+	virtual Int32	ReadData( void* outToBuffer, Int32 inByteCount );
+	virtual	void	CloseDataFork();
+	void			DoUseBuffer();
+	void			SetURL( char* url ) { fURL = url; }
+	char*			GetURL()	{ return fURL; }
+protected:
+	OSErr			FlushBuffer( Boolean allocateNew );
+	Boolean			fUseBuffer;
+	Handle			fBuffer;
+	UInt32			fBufferSize;
+	UInt32			fLastWritten;
+	Boolean			fWriteFailed;
+	char *			fURL;
+};
+
+#endif // __BUFFERSTREAM__
+

mozilla/cmd/macfe/central/CAppleEventHandler.h

@@ -0,0 +1,371 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// CAppleEventHandler.h
+
+#include "PascalString.h"
+#include "xp_mem.h"
+
+enum KioskEnum {KioskOff = 0, KioskOn = 1};
+	
+
+class CAppleEventHandler
+{
+public:
+	static CAppleEventHandler*	sAppleEventHandler;		// One and only instance of AEvents
+
+	// --- Standard Constructors and Destructors
+	
+						CAppleEventHandler();
+	virtual				~CAppleEventHandler();
+	// virtual void		Initialize();
+
+	
+	// --- Top Level Apple Event Handling
+	
+	virtual void 		HandleAppleEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	virtual void		GetAEProperty(DescType inProperty,
+									const AEDesc	&inRequestedType,
+									AEDesc			&outPropertyDesc) const;
+	virtual void		SetAEProperty(DescType inProperty,
+							const AEDesc	&inRequestedType,
+							AEDesc			&outPropertyDesc);
+
+	// ---  AEOM support
+	void				GetSubModelByUniqueID(DescType		inModelID,
+									const AEDesc	&inKeyData,
+									AEDesc			&outToken) const;
+
+	static KioskEnum 	GetKioskMode(){return sAppleEventHandler->fKioskMode;}
+
+
+protected:
+
+private:
+
+	KioskEnum			fKioskMode;
+	
+	void 				HandleOpenURLEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+// spy Apple Event suite
+// file/URL opening + misc
+	void 				HandleGetURLEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+									
+	void 				HandleGetWDEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+									
+	void 				HandleShowFile(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	void 				HandleParseAnchor(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+// Progress
+
+	void 				HandleCancelProgress(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+// Spy window events
+	void 				HandleSpyActivate(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	void 				HandleSpyListWindows(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	void 				HandleSpyGetWindowInfo(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	void 				HandleWindowRegistration(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+// Netscape suite
+	void				HandleOpenBookmarksEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	void				HandleReadHelpFileEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	void 				HandleGoEvent( const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);
+	void				HandleOpenAddressBookEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);								
+
+	void				HandleOpenComponentEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);								
+
+	void				HandleCommandEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);								
+
+	void 				HandleGetActiveProfileEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);		
+
+	void 				HandleGetProfileImportDataEvent(const AppleEvent	&inAppleEvent,
+									AppleEvent			&outAEReply,
+									AEDesc				&outResult,
+									long				inAENumber);		
+};
+
+
+/*-------------------------------------------------------------*/
+//	 class EudoraSuite
+//	Tools used to communicate with Eudora
+//	The only real use these have is if we are operating in
+//	Browser-only mode and the user wishes to use Eudora to
+//	handle mail functions.
+//
+/*-------------------------------------------------------------*/
+
+// --------------------------------------------------------------
+/*	Some Constants used by the Eudora Suite						 */
+// --------------------------------------------------------------
+
+#define attachDouble 0
+#define attachSingle 1
+#define attachBinHex 2
+#define attachUUencode 3
+
+#define EU_Norm_Priority 0
+#define EU_High_Priority 60
+#define EU_Highest_Priority 1
+#define EU_Low_Priority 160
+#define EU_Lowest_Priority 200
+
+class EudoraSuite
+{
+public:
+
+	// --------------------------------------------------------------
+	/*	This makes a Null AppleEvent descriptor.    
+				 */
+	// --------------------------------------------------------------
+	static void MakeNullDesc (AEDesc *theDesc);
+
+	// --------------------------------------------------------------
+	/*	This makes a string AppleEvent descriptor.   
+				 */
+	// --------------------------------------------------------------
+	static OSErr MakeStringDesc (Str255 theStr,AEDesc *theDesc);
+
+
+	// --------------------------------------------------------------
+	/*	This stuffs the required parameters into the AppleEvent. 
+				 */
+	// --------------------------------------------------------------
+
+
+	static OSErr CreateObjSpecifier (AEKeyword theClass,AEDesc theContainer,
+			AEKeyword theForm,AEDesc theData, Boolean disposeInputs,AEDesc *theSpec);
+
+	// --------------------------------------------------------------
+	/*	This creates an AEDesc for the current message.
+		(The current message index = 1)     
+
+		In:	Pointer to AEDesc to return
+		Out: AEDesc constructed. */
+	// --------------------------------------------------------------
+
+	static OSErr MakeCurrentMsgSpec (AEDesc *theSpec);
+
+
+	// --------------------------------------------------------------
+	/*	Send a given Apple Event.  Special case for Eudora, should
+		be rewritten, but it works for the moment.
+		In:	AppleEvent
+		Out: Event sent  */
+	// --------------------------------------------------------------
+	static OSErr SendEvent (AppleEvent *theEvent);
+
+	// --------------------------------------------------------------
+	/*	Create an Apple Event to be sent to Eudora
+		In:	Event Class
+			Event ID
+			Ptr to Apple Event
+		Out: Event constructed and returned.  */
+	// --------------------------------------------------------------
+	static OSErr MakeEvent (AEEventClass eventClass,AEEventID eventID,AppleEvent *theEvent);
+
+	// --------------------------------------------------------------
+	/*	This sets the data in a specified field. It operates on the frontmost message 
+		in Eudora. It is the equivalent of sending the following AppleScript:
+		set field "fieldname" of message 0 to "data"
+
+		Examples for setting up a complete mail message:
+			EudoraSuite::SendSetData("\pto",toRecipientPtr);
+			EudoraSuite::SendSetData("\pcc",ccRecipientPtr);
+			EudoraSuite::SendSetData("\pbcc",bccRecipientPtr);
+			EudoraSuite::SendSetData("\psubject",subjectPtr);
+			EudoraSuite::SendSetData("\p",bodyPtr);
+			
+		In:	Field to set the data in (Subject, Address, Content, etc)
+			Pointer to text data.
+			Size of pointer (allows us to work with XP_Ptrs.
+		Out: Apple Event sent to Eudora, setting a given field.  */
+	// --------------------------------------------------------------
+	static OSErr SendSetData(Str31 theFieldName, Ptr thePtr, long thePtrSize);
+	
+	// --------------------------------------------------------------
+	/*	Everything you need to tell Eudora to construct a new message
+		and send it.
+		In:	Pointer to the list of e mail addresses to send TO
+			Pointer to the list of e mail addresses to send CC
+			Pointer to the list of e mail addresses to send BCC
+			Pointer to the Subject text
+			Priority level of message.
+			XP_HUGE_CHAR_PTR to the contents of the mail
+			Pointer to an FSSpec (or null if none) for an enclosure.
+		Out: Apple Events sent to Eudora telling it to construct the
+			message and send it. */
+	// --------------------------------------------------------------
+
+	static OSErr  SendMessage(
+		Ptr		toRecipientPtr, 
+		Ptr		ccRecipientPtr,
+		Ptr		bccRecipientPtr,
+		Ptr		subjectPtr,
+		XP_HUGE_CHAR_PTR		bodyPtr,
+		long	thePriority,
+		FSSpec	*theEnclosurePtr);
+
+	static OSErr Set_Eudora_Priority(long thePriority);
+
+};
+
+
+/*-------------------------------------------------------------*/
+//	 class MoreExtractFromAEDesc
+//	Apple event helpers -- extension of UExtractFromAEDesc.h
+//	All the miscellaneous AppleEvent helper routines.
+/*-------------------------------------------------------------*/
+
+class MoreExtractFromAEDesc
+{
+public:
+
+	// --------------------------------------------------------------
+	/*	Given an AppleEvent, locate a string given a keyword and
+		return the string
+		In:	Event to search
+			AEKeyword assocaated with the string
+			C string ptr
+		Out: Pointer to a newly created C string returned */
+	// --------------------------------------------------------------
+	static void GetCString(const AppleEvent	&inAppleEvent, AEKeyword keyword, 
+			char * & s, Boolean inThrowIfError = true);
+
+	// --------------------------------------------------------------
+	/*	Given an AEDesc of type typeChar, return it's string.
+		In:	AEDesc containing a string
+			C string ptr
+		Out: Pointer to a newly created C string returned */
+	// --------------------------------------------------------------
+	static void TheCString(const AEDesc &inDesc, char * & outPtr);
+	
+	// --------------------------------------------------------------
+	/*	Add an error string and error code to an AppleEvent.
+		Typically used when constructing the return event when an
+		error occured
+		In:	Apple Event to append to
+			Error string
+			Error code
+		Out: keyErrorNum and keyErrorSting AEDescs are added to the Event. */
+	// --------------------------------------------------------------
+	static void MakeErrorReturn(AppleEvent &event, const CStr255& errorString, 
+			OSErr errorCode);
+
+	// --------------------------------------------------------------
+	/*	Display an error dialog if the given AppleEvent contains
+		a keyErrorNumber.  a keyErrorString is optional and will be
+		displayed if present
+		In:	Apple Event
+		Out: Error dialog displayed if error data present. */
+	// --------------------------------------------------------------
+	static Boolean DisplayErrorReply(AppleEvent &reply);
+
+	// --------------------------------------------------------------
+	/*	Return the process serial number of the sending process.
+		In:	Apple Event send by some app.
+		Out: ProcessSerialNumber of the sending app. */
+	// --------------------------------------------------------------
+	static ProcessSerialNumber ExtractAESender(const AppleEvent &inAppleEvent);
+
+	static void DispatchURLDirectly(const AppleEvent &inAppleEvent);
+}; // class MoreExtractFromAEDesc
+
+
+/*-------------------------------------------------------------*/
+//	class AEUtilities
+//	Some more simple Apple Event utility routines.
+/*-------------------------------------------------------------*/
+
+class AEUtilities
+{
+public:
+
+	// --------------------------------------------------------------
+	/*	CreateAppleEvent
+		Create a new Apple Event from scratch.
+		In:	Apple Event suite
+			Apple Event ID
+			Ptr to return Apple Event
+			ProcessSerialNumber of the target app to send event to.
+		Out:A new Apple Event is created.  More data may be added to
+			the event simply by calling AEPutParamDesc or AEPutParamPtr */
+	// --------------------------------------------------------------
+	static	OSErr CreateAppleEvent(OSType suite, OSType id, 
+		AppleEvent &event, ProcessSerialNumber targetPSN);
+
+	// --------------------------------------------------------------
+	/*	Check to see if there is an error in the given AEvent.
+		We simply return an OSError equiv to the error value
+		in the event.  If none exists (or an error took place
+		during access) we return 0.
+		In:	Apple Event to test
+		Out:Error value returned */
+	// --------------------------------------------------------------
+	static	OSErr EventHasErrorReply(AppleEvent & reply);
+
+};

mozilla/cmd/macfe/central/CBookmarksAttachment.cp

@@ -0,0 +1,389 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	Handle creating and maintaining the top-level bookmarks menu. It pulls the info
+//	out of the RDF container the user designates as their "quickfile menu" and listens
+//	to the messages from RDF to update it.
+
+#include "CBookmarksAttachment.h"
+
+#include "htrdf.h"
+#include "CNetscapeWindow.h"
+
+#include "net.h"
+#include "resgui.h"
+#include "uapp.h"
+#include "macutil.h"
+
+#include "UMenuUtils.h"
+
+#include <Icons.h>
+#include <Sound.h>
+
+#define PERM_BOOKMARK_ITEMS 4
+
+const CommandT cmd_BookmarkHierItem = BOOKMARKS_MENU_BASE_LAST;
+
+LMenu *CBookmarksAttachment::sMenu = NULL;
+Boolean CBookmarksAttachment::sInvalidMenu = true;
+LArray CBookmarksAttachment::sMenusList; // this will use the default constructor
+
+HT_View CBookmarksAttachment::sQuickfileView = NULL;
+
+
+
+//===========================================================
+// CBookmarksAttachment
+//===========================================================
+CBookmarksAttachment::CBookmarksAttachment()
+{
+	InitQuickfileView();
+}
+
+
+//
+// InitQuickfileView
+//
+// Called at startup to get a new view from the HT backend that represents the
+// bookmarks menu. This can be called multiple times without problems.
+//
+void
+CBookmarksAttachment :: InitQuickfileView ( )
+{
+	if ( ! sQuickfileView ) {
+		HT_Notification notifyStruct = CreateNotificationStruct();
+		HT_Pane quickfilePane = HT_NewQuickFilePane(notifyStruct);
+		
+		sQuickfileView = HT_GetSelectedView(quickfilePane);
+	}
+	
+} // InitQuickfileView
+
+
+void
+CBookmarksAttachment :: HandleNotification( HT_Notification /* notifyStruct*/,
+												HT_Resource node, HT_Event event)
+{
+	switch (event) {
+	
+		case HT_EVENT_NODE_ADDED:
+		case HT_EVENT_VIEW_REFRESH:
+			// only update menu if the quickfile view changes
+			if ( HT_GetView(node) == sQuickfileView ) {			
+				sInvalidMenu = true;
+				UpdateMenu();
+			}
+			break;
+			
+		case HT_EVENT_NODE_VPROP_CHANGED:
+			// optimization: only update when the name column changes
+			break;
+			
+		case HT_EVENT_NODE_DELETED_DATA:
+		case HT_EVENT_NODE_DELETED_NODATA:
+			// free FE data, but don't update the menu yet (HT not in good state)
+			break;
+			
+	} // case of which event
+
+} // HandleNotification
+
+
+// Processes:
+// 
+void CBookmarksAttachment::ExecuteSelf( MessageT inMessage, void* ioParam )
+{
+	mExecuteHost = FALSE;
+
+	switch ( inMessage )	
+	{
+		CNetscapeWindow *bookmarkableWindow = nil;
+		
+		case msg_CommandStatus:
+		{
+			SCommandStatus*		status = (SCommandStatus*)ioParam;
+				
+			switch ( status->command )
+			{
+
+				default:
+					if (CFrontApp::GetApplication()->HasBookmarksMenu())
+					{
+						if ( status->command >= BOOKMARKS_MENU_BASE && status->command <= BOOKMARKS_MENU_BASE_LAST )
+						{
+						 	*(status->enabled) = TRUE;
+						 	*(status->usesMark) = FALSE;
+							return;
+						}
+					}
+				break;
+			}
+		}
+		break;
+		
+		default:
+		{
+			if (CFrontApp::GetApplication()->HasBookmarksMenu())
+			{
+				if ( inMessage >= BOOKMARKS_MENU_BASE && inMessage <= BOOKMARKS_MENU_BASE_LAST )
+				{
+					Uint32 index = inMessage - BOOKMARKS_MENU_BASE;
+					char* url = HT_GetNodeURL( HT_GetNthItem(sQuickfileView, index) );
+					CFrontApp::DoGetURL ( url );
+
+					return;
+				}
+			}
+		}
+		break;			
+	}
+	mExecuteHost = TRUE;	// Let application handle it
+}
+
+
+void CBookmarksAttachment::AddToBookmarks( const char* url, const CStr255& title )
+{
+	HT_Resource topNode = HT_TopNode ( sQuickfileView );
+	HT_AddBookmark ( const_cast<char*>(url), title );
+}
+
+
+LMenu *CBookmarksAttachment::GetMenu()
+{
+	if (!sMenu)
+	{
+		sMenu = new LMenu(cBookmarksMenuID);
+
+		if (sMenu)
+		{
+			MenuHandle macMenu = sMenu->GetMacMenuH();
+			
+			if (macMenu)
+				UMenuUtils::ConvertToIconMenu(macMenu, 15312);
+		}
+	}
+	return sMenu;
+}
+
+void CBookmarksAttachment::UpdateMenu()
+{
+	if (CFrontApp::GetApplication()->HasBookmarksMenu())
+	{
+		if (!sInvalidMenu || !GetMenu() || !LMenuBar::GetCurrentMenuBar() )
+			return;
+		
+		int i;
+		
+		// ¥ delete all the dynamically created menus
+		// ¥Êdelete all the hierarchical menus we have added from the menubar
+		for ( i = 1; i <= sMenusList.GetCount(); i++ )
+		{
+			LMenu* m;
+			sMenusList.FetchItemAt( i, &m );
+			if ( m )
+				LMenuBar::GetCurrentMenuBar()->RemoveMenu( m );
+			delete m;
+		}
+
+		// ¥ delete all the menu items after the line in Bookmark menu
+		MenuHandle menu = sMenu->GetMacMenuH();
+		if ( menu )
+		{
+			int howMany = ::CountMItems( menu );
+			for ( i = howMany; i > PERM_BOOKMARK_ITEMS; i-- )
+				sMenu->RemoveItem( i );
+		}
+		sMenusList.RemoveItemsAt( sMenusList.GetCount(), 1 );
+
+		// ¥ walk through the list, and let the submenus be inserted recursively
+		int nextMenuID = cBookmarksFirstHierMenuID;
+		FillMenuFromList( HT_TopNode(sQuickfileView), sMenu, nextMenuID, PERM_BOOKMARK_ITEMS );
+		
+		sInvalidMenu = false;
+	}
+}
+
+// ¥Êrecursively create submenus, given a list ptr
+//		returns NULL if the menu cannot be created
+//		it creates submenus recursively
+void CBookmarksAttachment::FillMenuFromList(
+	HT_Resource top, 
+	LMenu* newMenu,
+	int& nextMenuID,		// next menu to create
+	int whichItem )			// id of the first item to insert
+{
+	if (CFrontApp::GetApplication()->HasBookmarksMenu())
+	{
+		Try_
+		{
+			ThrowIfNil_( newMenu );
+			MenuHandle mHand = newMenu->GetMacMenuH();
+		
+			ThrowIfNil_( mHand );
+			
+			// ¥Êremove all the extra items if they exist
+			long removeThese = ::CountMItems( mHand ) - whichItem;
+			for ( long i = 1; i < removeThese; i++ )
+				newMenu->RemoveItem( whichItem );
+		
+			MenuHandle theMacMenu = newMenu->GetMacMenuH();
+			
+			// Open up the container and get an iterator on its contents (we have to open it before
+			// we can see anything inside it). If the cursor is null, it is probably because the container
+			// is locked so just put up a leaf item (disabled, of course) and bail.
+			HT_SetOpenState ( top, PR_TRUE );
+			HT_Cursor cursor = HT_NewCursor( top );
+			if ( !cursor ) {
+				whichItem = UMenuUtils::InsertMenuItem(theMacMenu, "\pLocked", whichItem);
+				newMenu->SetCommand(whichItem, 0);
+				return;
+			}				
+			
+			HT_Resource currNode = HT_GetNextItem(cursor);
+			while ( currNode )
+			{
+				if ( HT_IsSeparator(currNode) )
+					newMenu->InsertCommand( "\p-", cmd_Nothing, whichItem++ );
+				else if ( ! HT_IsContainer(currNode) )
+				{
+				 	// ¥ should really convert this to menu chars
+					CStr255 urlName( HT_GetNodeName(currNode) );
+					CreateMenuString( urlName );
+
+					whichItem = UMenuUtils::InsertMenuItem(theMacMenu, urlName, whichItem); // returns actual insert loc
+					newMenu->SetCommand(whichItem, BOOKMARKS_MENU_BASE + HT_GetNodeIndex(sQuickfileView, currNode) );
+
+				}
+				else
+				{
+					CStr255 headerName( HT_GetNodeName(currNode) );
+					CreateMenuString( headerName );
+
+					whichItem = UMenuUtils::InsertMenuItem(theMacMenu, headerName, whichItem); // returns actual insert loc
+					newMenu->SetCommand(whichItem, cmd_BookmarkHierItem);
+					
+					// ¥Êdo we have space to create more?
+					if ( nextMenuID <= cBookmarksLastHierMenuID)
+					{
+						LMenu* subMenu = (LMenuBar::GetCurrentMenuBar())->FetchMenu( nextMenuID );
+						if ( !subMenu )
+						{
+							StringHandle menuStringH = GetString( NEW_RESID );
+							Assert_(menuStringH);
+							if (menuStringH)
+							{
+								StHandleLocker locker((Handle)menuStringH);
+								subMenu = new LMenu( nextMenuID,
+													(unsigned char *)*menuStringH );
+								LMenuBar::GetCurrentMenuBar()->InstallMenu( subMenu, hierMenu );
+							}
+						}
+						else
+							SysBeep( 1 );
+		
+						nextMenuID++;
+						
+						//	Skip the "Apple" menu or we're in deep donuts.
+						if (nextMenuID == MENU_Apple)
+							nextMenuID++;
+		
+						if ( subMenu )
+						{
+							sMenusList.InsertItemsAt( 1, LArray::index_Last,  &subMenu );
+							// ¥Êmake item hierarchical
+							::SetItemCmd( mHand, whichItem, hMenuCmd );
+							::SetItemMark( mHand, whichItem, subMenu->GetMenuID() );
+							if ( currNode )
+								FillMenuFromList( currNode, subMenu, nextMenuID, 0 );
+						}
+					}
+				}
+				
+				currNode = HT_GetNextItem ( cursor );
+				
+			} // while
+		}
+		Catch_( inErr )
+		{
+		}
+		EndCatch_
+	}
+}
+
+void CBookmarksAttachment::RemoveMenus()
+{
+	if (CFrontApp::GetApplication()->HasBookmarksMenu())
+	{
+		if (sMenu)
+		{
+			LMenuBar *currentMenuBar = LMenuBar::GetCurrentMenuBar();
+			
+			if (currentMenuBar)
+			{
+				currentMenuBar->RemoveMenu(sMenu);
+				
+				for (ArrayIndexT index = 1; index <= sMenusList.GetCount(); ++index)
+				{
+					LMenu *menu;
+					sMenusList.FetchItemAt(index, &menu);
+					
+					if (menu)
+						currentMenuBar->RemoveMenu(menu);
+				}
+			}
+		}
+	}
+}
+
+void CBookmarksAttachment::InstallMenus()
+{
+	if (CFrontApp::GetApplication()->HasBookmarksMenu())
+	{
+		if (GetMenu())
+		{
+			LMenuBar *currentMenuBar = LMenuBar::GetCurrentMenuBar();
+			
+			if (currentMenuBar)
+			{
+				for (ArrayIndexT index = sMenusList.GetCount(); index > 0; --index)
+				{
+					LMenu *menu;
+					sMenusList.FetchItemAt(index, &menu);
+					
+					if (menu)
+					{
+						StValueChanger<EDebugAction> okayToFail(gDebugThrow, debugAction_Nothing);
+						currentMenuBar->InstallMenu(menu, hierMenu);
+					}
+				}
+				StValueChanger<EDebugAction> okayToFail(gDebugThrow, debugAction_Nothing);
+				currentMenuBar->InstallMenu(sMenu, InstallMenu_AtEnd);
+				
+				LMenu *directoryMenu = currentMenuBar->FetchMenu(cDirectoryMenuID);
+				
+				if (directoryMenu)
+				{
+					CFrontApp::BuildConfigurableMenu( directoryMenu->GetMacMenuH(), "menu.places.item" );
+					
+					for (short index2 = CountMItems(directoryMenu->GetMacMenuH()); index2 > 0; --index2)
+						directoryMenu->SetCommand(index2, DIR_MENU_BASE + index2 - 1);
+				}
+			}
+		}
+	}
+}

mozilla/cmd/macfe/central/CBookmarksAttachment.h

@@ -0,0 +1,71 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	Handle creating and maintaining the top-level bookmarks menu. It pulls the info
+//	out of the RDF container the user designates as their "quickfile menu" and listens
+//	to the messages from RDF to update it.
+
+#pragma once
+
+#ifndef CBOOKMARKSATTACHMENT_H_
+#define CBOOKMARKSATTACHMENT_H_
+
+#include "CRDFNotificationHandler.h"
+
+#include "PascalString.h"
+#include <LAttachment.h>
+#include <LMenu.h>
+#include <LArray.h>
+
+/***********************************************************************************
+ * CBookmarksAttachment
+ * Processes bookmark menu commands -- should be attached to application
+ ***********************************************************************************/
+class CBookmarksAttachment: public LAttachment, public CRDFNotificationHandler
+{
+public:
+	// ¥¥ constructors
+						CBookmarksAttachment();
+	// ¥¥Êevents
+	virtual void		ExecuteSelf( MessageT inMessage, void* ioParam );
+
+//	static void			AddToBookmarks( BM_Entry* newBookmark );
+	static void			AddToBookmarks( const char* url, const CStr255& title );
+
+	static LMenu*		GetMenu();
+	static void			InvalidateMenu() { sInvalidMenu = true; }
+	static void			UpdateMenu();
+
+	static void			RemoveMenus();
+	static void			InstallMenus();
+	
+	void				InitQuickfileView ( ) ;
+
+protected:
+	static void			FillMenuFromList( HT_Resource top, LMenu* newMenu, int& nextMenuID, int whichItem );
+
+	virtual	void		HandleNotification( HT_Notification	notifyStruct, HT_Resource node, HT_Event event);
+
+	static LMenu*		sMenu;
+	static Boolean		sInvalidMenu;
+	static LArray		sMenusList;
+	static HT_View		sQuickfileView;		// called quickfile because of HT API
+
+};
+
+#endif

mozilla/cmd/macfe/central/CBrowserContext.h

@@ -0,0 +1,485 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// CBrowserContext.h
+
+#pragma once
+
+
+#include <LBroadcaster.h>
+#include <LSharable.h>
+
+#include "CNSContext.h"
+
+#include "structs.h"
+#include "ctxtfunc.h"
+#include "cstring.h"
+
+class CHTMLView;
+class CSharableCompositor;
+
+const MessageT msg_SecurityState = 'SECS';	// ESecurityState
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+class CBrowserContext : public CNSContext
+{
+	friend class CNSContextCallbacks;
+	friend class CPlainTextConversionContext;
+	
+	public:
+		// history navigation
+		// these are special indices for LoadHistoryEntry
+		enum {
+			index_Reload		=	-2,
+			index_GoBack		=	-1,
+			index_GoForward		= 	0
+		};
+			
+								CBrowserContext();
+								CBrowserContext(MWContextType inType);
+								CBrowserContext(const CBrowserContext& inOriginal);
+								
+		virtual 				~CBrowserContext();
+
+		virtual void				NoMoreUsers(void);
+
+		operator MWContext*();
+		operator MWContext&();
+
+		virtual	void				SetCurrentView(CHTMLView* inView);
+
+		virtual	CBrowserContext*	GetTopContext();
+		
+		virtual	Boolean				HasColorSpace(void) const;
+		virtual	Boolean				HasGridParent(void) const;
+		virtual	Boolean				HasFullPagePlugin(void) const;
+		
+		virtual	void				SetLoadImagesOverride(Boolean inOverride);
+		virtual Boolean				IsLoadImagesOverride(void) const;
+
+		virtual void				SetDelayImages(Boolean inDelay);
+		virtual	Boolean				IsImageLoadingDelayed(void) const;
+
+		virtual Boolean				IsRestrictedTarget(void) const;
+		virtual void				SetRestrictedTarget(Boolean inIsRestricted);
+		
+		virtual Boolean				IsRootDocInfoContext();
+		virtual Boolean				IsViewSourceContext();
+		
+		virtual Boolean				IsSpecialBrowserContext();
+		
+		virtual Boolean				SupportsPageServices();
+		
+// FIX ME!!! ACCESSOR for unique ID
+
+			// LAYERS / COMPOSITOR
+
+		virtual Boolean				HasCompositor(void) const;
+	
+		virtual CL_Compositor*		GetCompositor(void) const;
+	
+		virtual	void				SetCompositor(
+											CSharableCompositor*	inCompositor);
+
+		virtual	PRBool				HandleLayerEvent(	
+											CL_Layer*				inLayer, 
+											CL_Event*				inEvent);
+											
+		virtual PRBool				HandleEmbedEvent(	
+											LO_EmbedStruct*			inEmbed, 
+											CL_Event*				inEvent);
+														
+			// HISTORY
+		virtual	void				RememberHistoryPosition(
+											Int32					inX,
+											Int32					inY);
+	
+		virtual void 				InitHistoryFromContext( CBrowserContext *parentContext);
+
+
+			// Image Observer
+			
+		virtual Boolean				IsContextLooping();
+		Boolean						IsMochaLoadingImages() { return mMochaImagesLoading; }
+
+		void						SetImagesLoading(Boolean inValue);
+		void						SetImagesLooping(Boolean inValue);
+	    void						SetImagesDelayed(Boolean inValue);
+		void						SetMochaImagesLoading(Boolean inValue);
+		void						SetMochaImagesLooping(Boolean inValue);
+	    void						SetMochaImagesDelayed(Boolean inValue);
+
+	protected:
+		// we don't need to expose these
+		virtual History_entry*		GetNextHistoryEntry(void);
+		virtual History_entry*		GetPreviousHistoryEntry(void);
+		virtual Boolean				IsContextLoopingRecurse();
+	
+	public:
+		virtual Boolean				CanGoForward(void);
+		virtual Boolean				CanGoBack(void);
+
+		virtual Boolean				HasGridChildren(void);
+		virtual Boolean				IsGridChild(void);
+		virtual Boolean				IsGridCell();
+
+		virtual void				GoForwardOneHost();
+		virtual void				GoBackOneHost();
+
+		virtual void				GoForward(void);
+		virtual void				GoBack(void);
+		virtual void				LoadHistoryEntry(	// one-based
+											Int32 					inIndex,
+											Boolean					inSuperReload = false);
+		virtual Boolean				GoForwardInGrid(void);
+		virtual Boolean				GoBackInGrid(void);		
+		
+/*
+			// URL MANIPULATION
+		virtual	cstring				GetCurrentURL(void);
+		
+		virtual	void				SwitchLoadURL(
+											URL_Struct*				inURL,
+											FO_Present_Types		inOutputFormat);
+											
+		virtual	void				ImmediateLoadURL(
+											URL_Struct*				inURL,
+											FO_Present_Types		inOutputFormat);
+*/
+			// REPAGINTAION
+
+		virtual	void 				Repaginate(NET_ReloadMethod repage = NET_RESIZE_RELOAD);
+		virtual	Boolean				IsRepaginating(void) const;
+		virtual	Boolean				IsRepagintaitonPending(void) const;
+
+			// FRAME MANAGEMENT
+
+		virtual	MWContext* 			CreateGridContext(
+											void* 					inHistList,
+											void* 					inHistEntry,
+											Int32					inX,
+											Int32 					inY,
+											Int32					inWidth,
+											Int32					inHeight,
+											char* 					inURLString,
+											char* 					inWindowTarget,
+											Int8					inScrollMode,
+											NET_ReloadMethod 		inForceReload,
+											Bool 					inNoEdge);
+											
+		virtual void*				DisposeGridContext(
+											XP_Bool					inSaveHistory);
+											
+		virtual	void				DisposeGridChild(
+											CBrowserContext*				inChildContext);
+											
+		virtual	void				RestructureGridContext(
+											Int32					inX,
+											Int32 					inY,
+											Int32					inWidth,
+											Int32					inHeight);
+
+		virtual	void				GetFullGridSize(
+											Int32&					outWidth,
+											Int32&					outHeight);
+
+		virtual	void				ReloadGridFromHistory(
+											void* 					inHistEntry,
+											NET_ReloadMethod 		inReload);
+
+
+		virtual	Int32				CountGridChildren(void) const;
+
+		// save dialog for editor--Paul will fix some time
+		virtual CSaveProgress*		GetSaveDialog() { return fSaveDialog; };
+		virtual void				SetSaveDialog( CSaveProgress* theDialog ) { fSaveDialog = theDialog; };
+
+		// override for JavaScript foolishness
+		virtual	void 				Alert(
+											const char*				inAlertText);
+
+		virtual	XP_Bool				Confirm(
+											const char* 			inMessage);
+	protected:
+		CSaveProgress*				fSaveDialog;
+
+		void						ConstructJSDialogTitle(LStr255& outTitle);
+
+
+			// CALLBACK IMPLEMENTATION
+
+// FIX ME!!! this needs to become an apple event
+//		virtual	MWContext* 			CreateNewDocWindow(
+//											URL_Struct*				inURL);
+
+		virtual	void 				LayoutNewDocument(
+											URL_Struct*				inURL,
+											Int32*					inWidth,
+											Int32*					inHeight,
+											Int32*					inMarginWidth,
+											Int32*					inMarginHeight);
+
+		virtual	void 				SetDocTitle(
+											char* 					inTitle);
+											
+		virtual	void 				FinishedLayout(void);
+											
+		virtual	int 				GetTextInfo(
+											LO_TextStruct*			inText,
+											LO_TextInfo*			inTextInfo);
+											
+		virtual	int 				MeasureText(
+											LO_TextStruct*			inText,
+											short*					outCharLocs);
+											
+		virtual	void 				GetEmbedSize(
+											LO_EmbedStruct*			inEmbedStruct,
+											NET_ReloadMethod		inReloadMethod);
+											
+		virtual	void 				GetJavaAppSize(
+											LO_JavaAppStruct*		inJavaAppStruct,
+											NET_ReloadMethod		inReloadMethod);
+											
+		virtual	void 				GetFormElementInfo(
+											LO_FormElementStruct* 	inElement);
+
+		virtual	void 				GetFormElementValue(
+											LO_FormElementStruct* 	inElement,
+											XP_Bool 				inHide);
+
+		virtual	void 				ResetFormElement(
+											LO_FormElementStruct* 	inElement);
+
+		virtual	void 				SetFormElementToggle(
+											LO_FormElementStruct* 	inElement,
+											XP_Bool 				inToggle);
+
+		virtual	void 				FreeEmbedElement(
+											LO_EmbedStruct*			inEmbedStruct);
+
+		virtual	void 				CreateEmbedWindow(
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		virtual	void 				SaveEmbedWindow(
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		virtual	void 				RestoreEmbedWindow(
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		virtual	void 				DestroyEmbedWindow(
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		virtual	void 				FreeJavaAppElement(
+											LJAppletData*			inAppletData);
+
+		virtual	void 				HideJavaAppElement(
+											LJAppletData*				inAppletData);
+
+		virtual	void 				FreeEdgeElement(
+											LO_EdgeStruct*			inEdgeStruct);
+
+		virtual	void 				FormTextIsSubmit(
+											LO_FormElementStruct* 	inElement);
+
+		virtual	void 				DisplaySubtext(
+											int 					inLocation,
+											LO_TextStruct*			inText,
+											Int32 					inStartPos,
+											Int32					inEndPos,
+											XP_Bool 				inNeedBG);
+
+		virtual	void 				DisplayText(
+											int 					inLocation,
+											LO_TextStruct*			inText,
+											XP_Bool 				inNeedBG);
+
+		virtual	void 				DisplayEmbed(
+											int 					inLocation,
+											LO_EmbedStruct*			inEmbedStruct);
+
+		virtual	void 				DisplayJavaApp(
+											int 					inLocation,
+											LO_JavaAppStruct*		inJavaAppStruct);
+
+		virtual	void 				DisplayEdge (
+											int 					inLocation,
+											LO_EdgeStruct*			inEdgeStruct);
+
+		virtual	void 				DisplayTable(
+											int 					inLocation,
+											LO_TableStruct*			inTableStruct);
+
+		virtual	void 				DisplayCell(
+											int 					inLocation,
+											LO_CellStruct*			inCellStruct);
+
+		virtual	void 				InvalidateEntireTableOrCell(
+											LO_Element*				inElement);
+
+		virtual	void 				DisplayAddRowOrColBorder(
+											XP_Rect*				inRect,
+											XP_Bool					inDoErase);
+
+		virtual	void 				DisplaySubDoc(
+											int 					inLocation,
+											LO_SubDocStruct*		inSubdocStruct);
+
+		virtual	void 				DisplayLineFeed(
+											int 					inLocation,
+											LO_LinefeedStruct*		inLinefeedStruct,
+											XP_Bool 				inNeedBG);
+
+		virtual	void 				DisplayHR(
+											int 					inLocation,
+											LO_HorizRuleStruct*		inRuleStruct);
+
+		virtual	void 				DisplayBullet(
+											int 					inLocation,
+											LO_BullettStruct*		inBullettStruct);
+
+		virtual	void 				DisplayFormElement(
+											int 					inLocation,
+											LO_FormElementStruct* 	inFormElement);
+
+		virtual	void 				DisplayBorder(
+											int 					inLocation,
+											int						inX,
+											int						inY,
+											int						inWidth,
+											int						inHeight,
+											int						inBW,
+											LO_Color*	 			inColor,
+											LO_LineStyle			inStyle);
+
+		virtual void				UpdateEnableStates();
+		
+		virtual void				DisplayFeedback(
+											int 					inLocation,
+											LO_Element_struct		*inElement);
+
+		virtual	void 				ClearView(
+											int 					inWhich);
+
+		virtual	void 				SetDocDimension(
+											int 					inLocation,
+											Int32 					inWidth,
+											Int32 					inLength);
+
+		virtual	void 				SetDocPosition(
+											int 					inLocation,
+											Int32 					inX,
+											Int32 					inY);
+
+		virtual	void 				GetDocPosition(
+											int 					inLocation,
+											Int32*					outX,
+											Int32*					outY);
+
+		virtual	void 				SetBackgroundColor(
+											Uint8 					inRed,
+											Uint8					inGreen,
+											Uint8 					inBlue);
+
+		virtual	void 				AllConnectionsComplete(void);
+
+		virtual	void 				EraseBackground(
+											int						inLocation,
+											Int32					inX,
+											Int32					inY,
+											Uint32					inWidth,
+											Uint32					inHieght,
+											LO_Color*				inColor);
+
+		virtual	void 				SetDrawable(
+											CL_Drawable*			inDrawable);
+
+		virtual	void 				GetTextFrame(
+											LO_TextStruct*			inTextStruct,
+											Int32					inStartPos,
+											Int32					inEndPos,
+											XP_Rect*				outFrame);
+
+		virtual	void 				GetDefaultBackgroundColor(
+											LO_Color*				outColor) const;
+
+		virtual	void 				DrawJavaApp(
+											int 					inLocation,
+											LO_JavaAppStruct*		inJavaAppStruct);
+											
+		virtual	void 				HandleClippingView(
+											struct LJAppletData 	*appletD, 
+											int 					x, 
+											int 					y, 
+											int 					width, 
+											int 					height);
+
+		virtual	char* 				Prompt(
+											const char* 			inMessage,
+											const char*				inDefaultText);
+
+#if 0
+		Int32			GetTransactionID() { return fProgressID; }
+		Int32			GetContextUniqueID() { return fWindowID; }
+		// Window ID. Used to identify the context
+		static	Int32	sWindowID;		// Unique ID, incremented for each context
+		Int32			fWindowID;		// ID of this window
+
+
+	private:
+#endif
+
+		Boolean					mIsRepaginating;
+		Boolean					mIsRepaginationPending;
+
+		Boolean					mLoadImagesOverride;		
+		Boolean					mDelayImages;
+		CSharableCompositor*	mCompositor;
+
+		IL_GroupContext*		mImageGroupContext;
+		
+		Boolean					mImagesLoading;
+		Boolean					mImagesLooping;
+	    Boolean					mImagesDelayed;
+		Boolean					mMochaImagesLoading;
+		Boolean					mMochaImagesLooping;
+	    Boolean					mMochaImagesDelayed;
+	    
+	    Boolean					mInNoMoreUsers;
+
+}; // class CBrowserContext
+
+inline CBrowserContext::operator MWContext*()
+	{	return &mContext;		};
+inline CBrowserContext::operator MWContext&()
+	{	return mContext;		};
+	
+inline CBrowserContext* ExtractBrowserContext(MWContext* inContext)
+	{	return dynamic_cast<CBrowserContext*>(inContext->fe.newContext);		}
+
+class CSharableCompositor : public LSharable
+{
+public:
+	CSharableCompositor(CL_Compositor* c = nil) : mCompositor(c) {}
+	void SetCompositor(CL_Compositor* c) { mCompositor = c; }
+	virtual ~CSharableCompositor();
+	operator CL_Compositor*() { return mCompositor; }
+	CL_Compositor* mCompositor;
+}; // class CSharableCompositor

mozilla/cmd/macfe/central/CBrowserDragTask.cp

@@ -0,0 +1,153 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CBrowserDragTask.cp
+
+
+
+#include "CBrowserDragTask.h"
+
+#include "resgui.h"
+
+// ---------------------------------------------------------------------------
+//		¥ CBrowserDragTask
+// ---------------------------------------------------------------------------
+
+CBrowserDragTask::CBrowserDragTask(
+	const EventRecord&		inEventRecord)
+	:	super(inEventRecord)
+{
+}	
+
+// ---------------------------------------------------------------------------
+//		¥ ~CBrowserDragTask
+// ---------------------------------------------------------------------------
+											
+CBrowserDragTask::~CBrowserDragTask()
+{
+}	
+
+
+//
+// AddFlavorBookmark
+//
+// This flavor is currently used to shuttle around url/title information, and is
+// used by external applications (like DragThing) to get info about bookmarks/etc.
+// The data format is plain text in the form of URL<cr>Title.
+//
+// This flavor may or may not contain data. The proxy icon, for example, would want to 
+// include the data so that if it is dropped in the NavCenter, the NC could 
+// determine if the drop was allowable based on the URL.
+//
+void
+CBrowserDragTask::AddFlavorBookmark(ItemReference inItemRef, const char* inData)
+{
+	OSErr theErr = ::AddDragItemFlavor(
+									mDragRef,
+									inItemRef,
+									emBookmarkDrag,
+									inData,			
+									inData ? strlen(inData) + 1 : 0,
+									flavorSenderTranslated );
+	ThrowIfOSErr_(theErr);
+}							
+
+
+//
+// AddFlavorBookmarkFile
+//
+// This flavor is used for creating a bookmark file in the Finder instead of a clipping when
+// icons are dragged to the desktop.
+//
+// The data will be fulfilled in a DoSendData proc.
+// 
+void
+CBrowserDragTask::AddFlavorBookmarkFile(ItemReference inItemRef)
+{	
+	// Promise a file of type emBookmarkFile
+	
+	PromiseHFSFlavor promise;
+	
+	promise.fileType 		= emBookmarkFile;
+	promise.fileCreator 	= emSignature;
+	promise.fdFlags 		= 0;
+	promise.promisedFlavor	= emBookmarkFileDrag;
+
+	// Promise to create a file for the emBookmark flavor, where the actual
+	// FSSpec is promised in the emBookmark flavor below
+	
+	OSErr theErr = ::AddDragItemFlavor(
+									mDragRef,
+									inItemRef,
+									flavorTypePromiseHFS,
+									&promise,
+									sizeof(PromiseHFSFlavor),
+									0);
+	ThrowIfOSErr_(theErr);
+	
+	theErr = ::AddDragItemFlavor(
+									mDragRef,
+									inItemRef,
+									emBookmarkFileDrag,
+									nil,
+									0,
+									flavorNotSaved | flavorSenderTranslated);
+	ThrowIfOSErr_(theErr);
+}	
+
+
+//
+// AddFlavorURL
+//
+// This flavor is used to communicate the current URL with other applications, such
+// as text editors, etc. It is basically the 'TEXT' flavor.
+//
+// No data is sent with this flavor, relying on a DoDragSendData() to get it out later.
+// This prevents us from running into an odd problem where the CTheadView class wants to
+// interpret the data as something that it isn't. This won't happen when no data is sent.
+//
+void
+CBrowserDragTask::AddFlavorURL(ItemReference inItemRef)
+{
+	// TEXT flavor (drag an URL within Netscape). Set flavorSenderTranslated
+	// so that the Finder *won't* try to put this in a clipping file.
+	// We'd rather save the file itself.
+
+	OSErr theErr = ::AddDragItemFlavor(
+									mDragRef,
+									inItemRef,
+									'TEXT',
+									nil,
+									0,
+									flavorSenderTranslated);
+	ThrowIfOSErr_(theErr);
+}	
+
+// ---------------------------------------------------------------------------
+//		¥ AddFlavors
+// ---------------------------------------------------------------------------
+
+void
+CBrowserDragTask::AddFlavors( DragReference inDragRef )
+{		
+// NOTE: I'm passing |this| as the item ref because that's the way it was in the past
+//			and i don't want to break anything.
+	AddFlavorBookmark(static_cast<ItemReference>(this));
+	AddFlavorBookmarkFile(static_cast<ItemReference>(this));
+	AddFlavorURL(static_cast<ItemReference>(this));
+}

mozilla/cmd/macfe/central/CBrowserDragTask.h

@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CBrowserDragTask.h
+
+
+#ifndef CBrowserDragTask_H
+#define CBrowserDragTask_H
+#pragma once
+
+// Includes
+
+#include <LDragTask.h>
+
+// Class declaration
+
+class CBrowserDragTask : public LDragTask
+{
+public:
+	typedef LDragTask super;
+	
+							CBrowserDragTask( const EventRecord& inEventRecord );
+	virtual	 				~CBrowserDragTask();
+						
+protected:
+	void					AddFlavorBookmark(ItemReference inItemRef, const char* inData = nil);
+	void					AddFlavorBookmarkFile(ItemReference inItemRef);
+	void					AddFlavorURL(ItemReference inItemRef);
+
+	virtual void			AddFlavors(DragReference inDragRef);
+};
+
+
+#endif

mozilla/cmd/macfe/central/CExpandoDivider.cp

@@ -0,0 +1,351 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "CExpandoDivider.h"
+
+#include "prtypes.h"
+#include "macutil.h"
+#include "CDragBarDockControl.h"
+
+#define kTwistieID 'Twst'
+#define kCaptionID 'TwCp'
+
+const Int16 kTwistiePixelDifference = 3; // difference in height (collapsed minus expanded).
+
+//======================================
+// CExpandoListener
+//======================================
+
+//-----------------------------------
+void CExpandoListener::ListenToMessage(MessageT inMessage, void *ioParam)
+//-----------------------------------
+{
+	switch (inMessage)
+	{
+	case msg_TwistieMessage:
+		{
+		Int32 value = *(Int32*)ioParam;
+		SetExpandState((ExpandStateT)value);
+		break;
+		}
+	}
+} // CExpandoListener::ListenToMessage
+
+//======================================
+// CExpandable
+//======================================
+
+//-----------------------------------
+CExpandable::CExpandable(CExpansionData* closedState, CExpansionData* openState)
+//-----------------------------------
+:	mExpandState(closed_state)
+{
+	mStates[0] = closedState;
+	mStates[1] = openState;
+}
+
+//-----------------------------------
+void CExpandable::StoreCurrentDimensions()
+//-----------------------------------
+{
+	StoreDimensions(*(mStates[GetExpandState()]));
+}
+
+//-----------------------------------
+void CExpandable::RecallCurrentDimensions()
+//-----------------------------------
+{
+	RecallDimensions(*(mStates[GetExpandState()]));
+}
+
+//-----------------------------------
+void CExpandable::RecallOtherDimensions()
+//-----------------------------------
+{
+	RecallDimensions(*mStates[1 - GetExpandState()]);
+}
+
+//-----------------------------------
+void CExpandable::ReadStatus(LStream* inStream)
+//-----------------------------------
+{
+	if (!inStream) return;
+	*inStream >> mExpandState;
+	mStates[0]->ReadStatus(inStream);
+	mStates[1]->ReadStatus(inStream);
+	// Don't do anything with them here.
+} // CExpandable::ReadStatus
+
+//-----------------------------------
+void CExpandable::WriteStatus(LStream* inStream)
+//-----------------------------------
+{
+	StoreCurrentDimensions();
+	if (!inStream) return;
+	*inStream << mExpandState;
+	mStates[0]->WriteStatus(inStream);
+	mStates[1]->WriteStatus(inStream);
+} // CExpandable::ReadStatus
+
+const Int16 kDefaultTopFrameHeight = 110;
+	// FIXME.  A preference?  This value shows 5 full message lines in geneva 9.
+
+//-----------------------------------
+inline CDividerData::CDividerData()
+//-----------------------------------
+:	mDividerPosition(kDefaultTopFrameHeight)
+{
+} // CDividerData::CDividerData
+
+//-----------------------------------
+void CDividerData::ReadStatus(LStream* inStream)
+//-----------------------------------
+{
+	if (!inStream) return;
+	*inStream >> mDividerPosition;
+} // CDividerData::ReadStatus
+
+//-----------------------------------
+void CDividerData::WriteStatus(LStream* inStream)
+//-----------------------------------
+{
+	if (!inStream) return;
+	*inStream << mDividerPosition;
+} // CDividerData::WriteStatus
+
+//======================================
+// CExpandoDivider
+//======================================
+
+//-----------------------------------
+CExpandoDivider::CExpandoDivider(LStream* inStream)
+//-----------------------------------
+:	Inherited( inStream )
+,	CExpandable(&mClosedData, &mOpenData)
+{
+} // CExpandoDivider::CExpandoDivider
+
+//-----------------------------------
+CExpandoDivider::~CExpandoDivider()
+//-----------------------------------
+{
+}
+
+//-----------------------------------
+void CExpandoDivider::FinishCreateSelf()
+//-----------------------------------
+{
+	Inherited::FinishCreateSelf();
+	mTwistie = FindPaneByID(kTwistieID);
+	mCaption = FindPaneByID(kCaptionID);
+//	CExpandable::InitializeStates();
+	StoreCurrentDimensions(); // get the closed state from PPOb
+	// Base class calls SyncFrameBinding which sets the "open" behavior. Undo this, then.
+	SetStickToBottom(true);
+
+	// Record the height of the status bar, so that we can preserve it on expansion.
+	LWindow* window = LWindow::FetchWindowObject(GetMacPort());
+	Rect windowRect;
+	window->CalcPortFrameRect(windowRect); // relative is fine
+	Rect expandoRect;
+	this->CalcPortFrameRect(expandoRect);
+	mDistanceFromWindowBottom = windowRect.bottom - expandoRect.bottom;
+	Assert_(mDistanceFromWindowBottom >= 0);
+	mDividerDistanceFromWindowBottom
+		= windowRect.bottom - (expandoRect.top + GetDividerPosition());
+} // CExpandoDivider::FinishCreateSelf
+
+//-----------------------------------
+void CExpandoDivider::StoreDimensions(CExpansionData& outState)
+//-----------------------------------
+{
+	((CDividerData&)outState).mDividerPosition = GetDividerPosition();
+} // CExpandoDivider::StoreDimensions
+
+//-----------------------------------
+void CExpandoDivider::RecallDimensions(const CExpansionData& inState)
+//-----------------------------------
+{
+	SInt32 dividerPosition = GetDividerPosition();
+	Int16 dividerDelta = ((CDividerData&)inState).mDividerPosition - dividerPosition;
+	this->ChangeDividerPosition(dividerDelta);
+} // CExpandoDivider::RecallDimensions
+
+//-----------------------------------
+void CExpandoDivider::SetStickToBottom(LPane* inPane, Boolean inStick)
+//-----------------------------------
+{
+	SBooleanRect bindings;
+	inPane->GetFrameBinding(bindings);
+	bindings.bottom = inStick;
+	inPane->SetFrameBinding(bindings);
+} // CExpandoDivider::SetStickToBottom
+
+//-----------------------------------
+void CExpandoDivider::SetStickToBottom(Boolean inStick)
+//-----------------------------------
+{
+	SetStickToBottom(mTwistie, inStick);
+	SetStickToBottom(mCaption, inStick);
+	SetStickToBottom(fFirstView, inStick);
+	SetStickToBottom(fSecondView, true);
+} // CExpandoDivider::SetStickToBottom
+
+//-----------------------------------
+void CExpandoDivider::ClickSelf(const SMouseDownEvent& inMouseDown)
+//-----------------------------------
+{
+	if (GetExpandState() == open_state) Inherited::ClickSelf(inMouseDown);
+}
+
+//-----------------------------------
+void CExpandoDivider::AdjustCursorSelf(Point inPortPt, const EventRecord& inMacEvent)
+//-----------------------------------
+{
+	if (GetExpandState() == open_state) Inherited::AdjustCursorSelf(inPortPt, inMacEvent);
+}
+
+//-----------------------------------
+void CExpandoDivider::ChangeTwistiePosition(Int16 delta)
+// Move the twistie and caption
+//-----------------------------------
+{
+	mTwistie->MoveBy(0, delta, FALSE);
+	mCaption->MoveBy(0, delta, FALSE);
+} // CExpandoDivider::ChangeTwistiePosition
+
+//-----------------------------------
+void CExpandoDivider::ChangeDividerPosition(Int16 delta)
+//-----------------------------------
+{
+	if (mExpandState == open_state && delta > 0)
+	{
+		// If the user drags the divider to the bottom, it should close the twistie.
+		Int32 dividerPos = this->GetDividerPosition();
+		Int32 newPos = dividerPos + delta;
+		Rect secondFrame;
+		GetSubpaneRect(this, fSecondView, secondFrame);
+		if (newPos > secondFrame.bottom - 50)
+		{
+			mTwistie->SetValue(closed_state);
+			return;
+		}
+	}
+	Inherited::ChangeDividerPosition(delta);
+	ChangeTwistiePosition(delta);
+} // CExpandoDivider::ChangeDividerPosition
+
+//-----------------------------------
+void CExpandoDivider::ResizeFrameBy(
+	Int16		inWidthDelta,
+	Int16		inHeightDelta,
+	Boolean		inRefresh)
+//-----------------------------------
+{
+	Inherited::ResizeFrameBy(inWidthDelta, inHeightDelta, inRefresh);
+	// Unless we do this, there's no way to enforce the rule that the second pane's TOP
+	// sticks to the bottom when in the collapsed state.
+	if (mExpandState == closed_state && fFirstView && fSecondView)
+	{
+		SPoint32 loc1, loc2;
+		SDimension16 siz1, siz2;
+		fFirstView->GetFrameLocation(loc1);
+		fFirstView->GetFrameSize(siz1);
+		fSecondView->GetFrameLocation(loc2);
+		fSecondView->GetFrameSize(siz2);
+		Int32 secondViewOffset = siz1.height + loc1.v + mDivSize - loc2.v;
+		if (secondViewOffset)
+		{
+			fSecondView->MoveBy(0, secondViewOffset, false);
+			fSecondView->ResizeFrameBy(0, -secondViewOffset, false);
+		}
+	}
+} // CExpandoDivider::ResizeFrameBy
+
+//-----------------------------------
+void CExpandoDivider::SetExpandState(ExpandStateT inExpanded)
+//-----------------------------------
+{
+#if 0
+	// We now assume that the my view's bottom is flush with the bottom of the
+	// second subview.
+	SPoint32 locMe, loc2;
+	SDimension16 sizMe, siz2;
+	GetFrameSize(sizMe);
+	GetFrameLocation(locMe);
+	fSecondView->GetFrameLocation(loc2);
+	fSecondView->GetFrameSize(siz2);
+	Assert_(loc2.v + siz2.height == locMe.v + sizMe.height);
+#endif // DEBUG
+
+	LWindow* win = LWindow::FetchWindowObject(GetMacPort());
+	Rect winRect;
+	win->CalcPortFrameRect(winRect); // relative is fine
+	const Int16 statusBarHeight = this->GetCorrectDistanceFromBottom();
+	const Int16 dividerDistanceFromBottom
+		= this->GetCorrectDividerDistanceFromBottom();
+	Rect expandoRect;
+	this->CalcPortFrameRect(expandoRect);
+
+	if (mExpandState != inExpanded)
+		StoreCurrentDimensions();
+	mExpandState = inExpanded;
+	if (inExpanded)
+	{
+		// When expanded, topview, twistie and caption do not stick to the bottom.
+		mCaption->Hide();
+		SetStickToBottom(false);
+		SyncFrameBindings();
+		
+		
+		// The expanded twistie is not as high as the collapsed one, and the following
+		// adjustment allows us to have a narrower divider bar.
+		ChangeTwistiePosition(- kTwistiePixelDifference);
+		
+		// Now expand.  The divider will pull the frame up.
+		RecallCurrentDimensions();
+
+		fSecondView->Show();
+	}
+	else
+	{
+		ChangeTwistiePosition(+ kTwistiePixelDifference);
+		fSecondView->Hide();
+		mCaption->Show();
+		RecallCurrentDimensions();
+
+	}
+	// The following is a kludge to fix cases where the bottom of Message view
+	// can disappear under the bottom of the window, or where the divider containing
+	// the twistie icon can be a one-inch thick grey area just over the bottom of the window.
+	short vertError = (winRect.bottom - statusBarHeight) - expandoRect.bottom;
+	if (vertError != 0)
+	{
+		this->ResizeFrameBy(0, vertError, false);
+	}
+	if (!inExpanded)
+	{
+		vertError = (winRect.bottom - (expandoRect.top + dividerDistanceFromBottom))
+									- this->GetDividerPosition();
+		if (vertError != 0)
+			this->ChangeDividerPosition(vertError);
+		// When collapsed, topview, twistie and caption stick to the bottom.
+		SetStickToBottom(true); //¥¥¥ this line is not part of the kludge
+	}
+} // CExpandoDivider::SetExpandedState
+

mozilla/cmd/macfe/central/CExpandoDivider.h

@@ -0,0 +1,136 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#include "divview.h"
+
+//-----------------------------------
+class CExpansionData
+// persistent data about both states of a CExpandable.
+//-----------------------------------
+{
+public:
+	virtual void	ReadStatus(LStream* inStream) = 0;
+	virtual void	WriteStatus(LStream* inStream) = 0;
+}; //  class CExpansionData
+
+enum { closed_state = false, open_state = true };
+typedef Boolean ExpandStateT;
+
+//======================================
+class CExpandable
+//======================================
+{
+public:
+	virtual void	ReadStatus(LStream* inStream);
+	virtual void	WriteStatus(LStream* inStream);
+	ExpandStateT	GetExpandState() const { return mExpandState; }
+	void			NoteExpandState(ExpandStateT inExpanded) { mExpandState = inExpanded; }
+protected:
+	virtual void	SetExpandState(ExpandStateT inExpanded) = 0;
+private:
+	virtual void	StoreDimensions(CExpansionData& outState) = 0;
+	virtual void	RecallDimensions(const CExpansionData& inState) = 0;	
+protected:
+					CExpandable(CExpansionData* closedState, CExpansionData* openState);
+						// clients that mix this class in should have two members that are
+						// CExpansionData, and pass the references in here.
+protected:
+	void			StoreCurrentDimensions();
+	void			RecallCurrentDimensions();
+	void			RecallOtherDimensions();
+protected:
+	ExpandStateT	mExpandState;
+	CExpansionData*	mStates[2];
+}; // class CExpandable
+
+//======================================
+class CExpandoListener : public LListener, public CExpandable
+//======================================
+{
+public:
+	enum			{ msg_TwistieMessage = 'Twst' }; // Broadcast by twistie control
+					CExpandoListener(
+						CExpansionData* closedState, CExpansionData* openState)
+						:	CExpandable(closedState, openState) {}
+	virtual void	ListenToMessage(MessageT inMessage, void *ioParam);
+		// Listen to the twistie
+}; // class CExpandoListener
+
+//======================================
+class CDividerData : public CExpansionData
+//======================================
+{
+public:
+	CDividerData();
+		// default is set for the open state, because the closed state is in the PPOb.
+// Overrides
+	virtual void	ReadStatus(LStream* inStream);
+	virtual void	WriteStatus(LStream* inStream);
+// Data
+	SInt32			mDividerPosition;
+}; // class CDividerData
+
+//======================================
+class CExpandoDivider : public LDividedView, public CExpandable
+// This class acts like a divider between two panes, one above the other.
+// In addition to the LDividedView behavior, it also has an "expando" twistie, that
+// hides/shows the bottom pane.
+//======================================
+{
+private:
+	typedef LDividedView Inherited;
+public:
+	enum			{ class_ID = 'Expo' };
+					CExpandoDivider(LStream* inStream);
+	virtual			~CExpandoDivider();
+
+// PowerPlant overrides
+protected:	
+	virtual void	FinishCreateSelf();
+	virtual	void	ClickSelf(const SMouseDownEvent& inMouseDown);
+	virtual	void	AdjustCursorSelf(Point inPortPt, const EventRecord& inMacEvent);
+public:
+	virtual void	ResizeFrameBy(
+						Int16		inWidthDelta,
+						Int16		inHeightDelta,
+						Boolean		inRefresh);
+// CExpandable overrides
+public:
+	virtual void	SetExpandState(ExpandStateT inExpanded);
+	virtual void	StoreDimensions(CExpansionData& outState);
+	virtual void	RecallDimensions(const CExpansionData& inState);
+// Special interfaces
+public:
+	Int16			GetCorrectDistanceFromBottom() const { return mDistanceFromWindowBottom; }
+	Int16			GetCorrectDividerDistanceFromBottom() const
+						{ return mDividerDistanceFromWindowBottom; }
+// Down to business:
+protected:
+	virtual void	ChangeDividerPosition(Int16 delta); // also changes the twistie+caption
+	virtual void	ChangeTwistiePosition(Int16 delta); // only changes the twistie+caption
+	void			SetStickToBottom(LPane* inPane, Boolean inStick);
+	void			SetStickToBottom(Boolean inStick);
+// Data:
+protected:
+	Int16			mDistanceFromWindowBottom;
+	Int16			mDividerDistanceFromWindowBottom;
+	LPane			*mTwistie, *mCaption;
+	CDividerData	mClosedData, mOpenData;
+}; // class CExpandoDivider

mozilla/cmd/macfe/central/CMochaHacks.cp

@@ -0,0 +1,336 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * macmocha.cp
+ * MacFE mocha hacks
+ *
+ */
+
+#include "CMochaHacks.h"
+#include "lo_ele.h"
+#include "fe_proto.h" // for FE_DestroyWindow
+#include "proto.h" // 1997-03-02 mjc
+#include "layers.h"
+#include "macutil.h"
+
+LO_Element* CMochaHacks::sMouseOverElement = NULL;	// layout element the cursor is over
+MWContext* CMochaHacks::sMouseOverElementContext = NULL;	// context associated with sMouseOverElement
+LO_AnchorData* CMochaHacks::sMouseOverMapArea = NULL;	// AREA tag the cursor is over
+
+// <where> is document-relative
+void 
+CMochaHacks::SendOutOfElementEvent(MWContext * winContext, CL_Layer* layer, SPoint32 where) // add layer param 1997-03-02 mjc
+{
+	Assert_(winContext);
+	
+	try
+	{
+		if ( sMouseOverElement )
+		{
+			// ET_SendEvent now takes a JSEvent struct instead of an int type
+			JSEvent* event = XP_NEW_ZAP(JSEvent);
+			if (event)
+			{
+				// 97-06-21 pkc -- If we have an sMouseOverElementContext then use it
+				// instead of winContext
+				MWContext* theContext = sMouseOverElementContext ? sMouseOverElementContext : winContext;
+				event->type = EVENT_MOUSEOUT;
+				event->x = where.h;
+				event->y = where.v;
+				event->docx = event->x + CL_GetLayerXOrigin(layer);
+				event->docy = event->y + CL_GetLayerYOrigin(layer);
+				
+				int32 x_offset, y_offset;
+				FE_GetWindowOffset(theContext, &x_offset, &y_offset);
+				event->screenx = event->docx + x_offset;
+				event->screeny = event->docy + y_offset;
+				event->layer_id = LO_GetIdFromLayer(theContext, layer);
+				ET_SendEvent( theContext, sMouseOverElement, event, NULL, NULL );
+				sMouseOverElement = NULL;
+				sMouseOverElementContext = NULL;
+			}
+		}
+			
+	}
+	catch(...)
+	{
+	}
+}
+
+void 
+CMochaHacks::SendOutOfMapAreaEvent(MWContext * winContext, CL_Layer* layer, SPoint32 where) // add layer param 1997-03-02 mjc
+{
+	Assert_(winContext);
+	
+	try
+	{
+		if ( sMouseOverMapArea )
+		{
+			CMochaEventCallback * cb = new CMochaEventCallback;	// Need it because of LO_AnchorData
+			cb->SendEvent( winContext, sMouseOverMapArea, EVENT_MOUSEOUT, layer, where );
+			sMouseOverMapArea = NULL;
+		}
+	}
+	catch(...)
+	{
+	}
+}
+
+//
+// CMochaEventCallback
+//
+void
+CMochaHacks::ResetMochaMouse()
+{
+	sMouseOverElement = NULL;
+	sMouseOverMapArea = NULL;
+}
+
+// Returns mocha modifier bitset given mac modifiers.
+uint32 
+CMochaHacks::MochaModifiers(const UInt16 inModifiers)
+{
+	return ((inModifiers & shiftKey) ? EVENT_SHIFT_MASK : 0) |
+			((inModifiers & controlKey) ? EVENT_CONTROL_MASK : 0) |
+			((inModifiers & optionKey) ? EVENT_ALT_MASK : 0) |
+			((inModifiers & cmdKey) ? EVENT_META_MASK : 0);
+}
+
+// Returns mocha modifiers by reading the keyboard.
+uint32 
+CMochaHacks::MochaModifiersFromKeyboard(void)
+{
+	union
+	{
+		KeyMap asMap;
+		Byte asBytes[16];
+	};
+
+	::GetKeys(asMap);
+	return ((asBytes[kShiftKey >> 3] & (1 << (kShiftKey & 0x07))) ? EVENT_SHIFT_MASK : 0) |
+			((asBytes[kCtlKey >> 3] & (1 << (kCtlKey & 0x07))) ? EVENT_CONTROL_MASK : 0) |
+			((asBytes[kOptionKey >> 3] & (1 << (kOptionKey & 0x07))) ? EVENT_ALT_MASK : 0) |
+			((asBytes[kCommandKey >> 3] & (1 << (kCommandKey & 0x07))) ? EVENT_META_MASK : 0);
+}
+	
+
+// Returns true if the window is a dependent of another.
+// Parameters:
+// 	inContext: the context for this window.
+Boolean 	
+CMochaHacks::IsDependent(MWContext* inContext)
+{
+	return (inContext->js_parent != nil);
+}
+
+// Add a window as a dependent of another.
+// Called in FE_MakeNewWindow.
+// Parameters:
+//		inParent: the parent context.
+//		inChild: the context for this window which will be made a dependent of the parent.
+void 
+CMochaHacks::AddDependent(MWContext* inParent, MWContext* inChild)
+{
+	// inParent could be a grid context, but dependencies are between windows so find root context.
+	MWContext* theParentRoot = XP_GetNonGridContext(inParent);
+	if (theParentRoot != nil && inChild != nil)
+	{
+		if (theParentRoot->js_dependent_list == NULL)
+			theParentRoot->js_dependent_list = XP_ListNew();
+		if (theParentRoot->js_dependent_list != NULL)
+		{
+			XP_ListAddObject(theParentRoot->js_dependent_list, inChild);
+			inChild->js_parent = theParentRoot;
+		}
+	}
+
+}
+
+// Remove dependents of the window.
+// Called in destructor for window.
+// Parameters:
+// 	inContext: the context for this window.
+void 
+CMochaHacks::RemoveDependents(MWContext* inContext)
+{
+	// FE_DestroyWindow makes this recursive; keep track of how many levels deep we are.
+	static int recursionLevel = 0;
+	++recursionLevel;
+	if (inContext->js_dependent_list)
+	{
+		MWContext *depContext;
+		// destroy windows which are dependent on this window
+		for (int i = 1; i <= XP_ListCount(inContext->js_dependent_list); i++)
+		{
+			depContext = (MWContext *)XP_ListGetObjectNum(inContext->js_dependent_list, i);
+			FE_DestroyWindow(depContext);
+		}
+		XP_ListDestroy(inContext->js_dependent_list);
+		inContext->js_dependent_list = NULL;
+	}
+	--recursionLevel;
+	// remove self from parent's dependent list but only if we're the window
+	// at the top of the chain (don't alter lists we're iterating over).
+	if (recursionLevel == 0 && inContext->js_parent != nil)
+	{
+		if (XP_ListCount(inContext->js_parent->js_dependent_list) == 1)
+		{
+			// if the last element in the list, destroy the list.
+			XP_ListDestroy(inContext->js_parent->js_dependent_list);
+			inContext->js_parent->js_dependent_list = NULL;
+		}
+		else XP_ListRemoveObject(inContext->js_parent->js_dependent_list, inContext);
+	}
+}
+
+// Send move event to mocha every time a window or pane is moved.
+void 
+CMochaHacks::SendMoveEvent(MWContext* inContext, int32 inX, int32 inY)
+{
+	JSEvent *event;
+	
+	event = XP_NEW_ZAP(JSEvent);
+	if (event)
+	{
+		event->type = EVENT_MOVE;
+		event->x = inX;
+		event->y = inY;
+	}
+	ET_SendEvent(inContext, 0, event, 0, 0);
+}
+
+// Send the event specified, with no callback.
+void
+CMochaHacks::SendEvent(MWContext* inContext, int32 inType, LO_Element* inElement)
+{
+	JSEvent *event;
+	event = XP_NEW_ZAP(JSEvent);
+	if (event)
+	{
+		event->type = inType;
+		ET_SendEvent(inContext, inElement, event, 0, 0);
+	}
+}
+
+//
+// CMochaEventCallback
+//
+
+#ifdef DEBUG
+static int sCallbackCount = 0;
+#endif
+
+CMochaEventCallback::CMochaEventCallback()
+{
+#ifdef DEBUG
+	sCallbackCount++;
+#endif
+	fDummyElement = NULL;
+}
+
+CMochaEventCallback::~CMochaEventCallback()
+{
+#ifdef DEBUG
+	sCallbackCount--;
+#endif
+	if (fDummyElement != NULL)
+		XP_FREE( fDummyElement );
+}
+
+//
+// Plain SendEvent
+//
+void
+CMochaEventCallback::SendEvent(MWContext * context, LO_Element * element, int32 type, CL_Layer* layer, SPoint32 where)
+{
+	// ET_SendEvent now takes a JSEvent struct instead of an int type
+	JSEvent* event = XP_NEW_ZAP(JSEvent);
+	if (event)
+	{
+		event->type = type;
+		event->x = where.h;
+		event->y = where.v;
+		event->docx = event->x + CL_GetLayerXOrigin(layer);
+		event->docy = event->y + CL_GetLayerYOrigin(layer);
+		
+		int32 x_offset, y_offset;
+		FE_GetWindowOffset(context, &x_offset, &y_offset);
+		event->screenx = event->docx + x_offset;
+		event->screeny = event->docy + y_offset;
+		event->layer_id = LO_GetIdFromLayer(context, layer);
+		ET_SendEvent( context, element, event, MochaCallback, this);
+		// PR_Yield();	To speed up processing?
+	}
+}
+
+// 
+// LO_AnchorData SendEvent
+//
+void
+CMochaEventCallback::SendEvent(MWContext * context, LO_AnchorData * data, int32 type, CL_Layer* layer, SPoint32 where)
+{
+	// Create fake layout element
+	fDummyElement = XP_NEW_ZAP(LO_Element);
+	if (fDummyElement)
+	{
+		fDummyElement->type = LO_TEXT;
+		fDummyElement->lo_text.anchor_href = data;
+		fDummyElement->lo_text.text = data->anchor;
+		
+		// ET_SendEvent now takes a JSEvent struct instead of an int type
+		JSEvent* event = XP_NEW_ZAP(JSEvent);
+		if (event)
+		{
+			event->type = type;
+			event->x = where.h;
+			event->y = where.v;
+			event->docx = event->x + CL_GetLayerXOrigin(layer);
+			event->docy = event->y + CL_GetLayerYOrigin(layer);
+			
+			int32 x_offset, y_offset;
+			FE_GetWindowOffset(context, &x_offset, &y_offset);
+			event->screenx = event->docx + x_offset;
+			event->screeny = event->docy + y_offset;
+			event->layer_id = LO_GetIdFromLayer(context, layer);
+			ET_SendEvent( context, fDummyElement, event, MochaCallback, this);
+		}
+	}
+}
+
+// 
+// EventComplete, does nothing
+//
+void
+CMochaEventCallback::Complete(MWContext * /*context*/, LO_Element * /*element*/, 
+										int32 /*type*/, ETEventStatus /*status*/)
+{
+// EVENT_OK means we should handle the event/
+// EVENT_CANCEL, EVENT_PANIC, means mocha has cancelled the click
+}
+
+//
+// MochaCallback, called by mocha after event is processed
+//
+void CMochaEventCallback::MochaCallback(MWContext * context, LO_Element * element, 
+                 int32 type, void * inCallback, ETEventStatus status)
+{
+	CMochaEventCallback * callback = (CMochaEventCallback *) inCallback;
+	callback->Complete( context, element, type, status );
+	delete callback;
+}

mozilla/cmd/macfe/central/CMochaHacks.h

@@ -0,0 +1,125 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+ * macmocha.h
+ * MacFE mocha hacks
+ *
+ */
+
+#include "structs.h" // mjc
+#include "libevent.h"
+
+/*
+ * static class that encapsulates most of the Macha hacks
+ */
+class CMochaHacks
+{
+private:
+	static LO_Element*		sMouseOverElement;		// layout element the cursor is over
+	static MWContext*		sMouseOverElementContext;	// context associated with sMouseOverElement
+	static LO_AnchorData*	sMouseOverMapArea;		// AREA tag the cursor is over
+
+public:
+	static void ClearSelectionForContext( MWContext* context )
+	{
+		if (context == sMouseOverElementContext)
+		{
+			sMouseOverElement = NULL;
+			sMouseOverElementContext = NULL;
+			sMouseOverMapArea = NULL;
+		}
+	}
+	static void SendOutOfElementEvent(MWContext * winContext, CL_Layer* layer, SPoint32 where); // add layer param 1997-03-02 mjc
+	static void SendOutOfMapAreaEvent(MWContext * winContext, CL_Layer* layer, SPoint32 where); // add layer param 1997-03-02 mjc
+	static void	ResetMochaMouse();
+
+	static Boolean	IsMouseOverElement(LO_Element* inElement)
+					{	return inElement == sMouseOverElement;	}
+	static Boolean	IsMouseOverMapArea(LO_AnchorData* inAnchorData)
+					{	return inAnchorData == sMouseOverMapArea;	}
+
+	static void	SetMouseOverElement(LO_Element* inElement, MWContext* inElementContext = NULL)
+				{
+					sMouseOverElement = inElement;
+					sMouseOverElementContext = inElementContext;
+				}
+	static void RemoveReferenceToMouseOverElementContext(MWContext *context)
+	{
+		if (sMouseOverElementContext == context)
+			sMouseOverElementContext = NULL;
+	}
+	static void	SetMouseOverMapArea(LO_AnchorData* inAnchorData)
+				{	sMouseOverMapArea = inAnchorData;	}
+
+	static LO_Element*	GetMouseOverElement()
+						{	return sMouseOverElement;	}
+	static LO_AnchorData*	GetMouseOverMapArea()
+							{	return sMouseOverMapArea;	}
+
+	static uint32 MochaModifiers(const UInt16 inModifiers);
+	static uint32 MochaModifiersFromKeyboard(void);
+					
+	// manage windows declared as dependent in javascript
+	static Boolean 	IsDependent(MWContext* inContext);
+	static void 	AddDependent(MWContext* inParent, MWContext* inChild);
+	static void 	RemoveDependents(MWContext* inContext);
+	
+	// Whenever a window or frame moves or resizes send an event to javascript
+	static void		SendMoveEvent(MWContext* inContext, int32 inX, int32 inY);
+	
+	static void		SendEvent(MWContext* inContext, int32 inType, LO_Element* inElement = nil);
+	
+	// Send navigation events - currently not cancellable
+	static void		SendBackEvent(MWContext* inContext)
+					{ SendEvent(inContext, EVENT_BACK); }
+					
+	static void		SendForwardEvent(MWContext* inContext)
+					{ SendEvent(inContext, EVENT_FORWARD); }
+};
+
+/*
+ * CMochaEventCallback
+ * class that encapsulates sending of mocha events
+ * Subclasses should override EventComplete
+ */
+
+class CMochaEventCallback	{
+public:
+
+// Constructors
+					CMochaEventCallback();
+	virtual 		~CMochaEventCallback();
+
+// Mocha interface
+	void 			SendEvent(MWContext * context, LO_Element * element, int32 type, CL_Layer* layer, SPoint32 where);
+	void 			SendEvent(MWContext * context, LO_AnchorData * data, int32 type, CL_Layer* layer, SPoint32 where);
+
+	// MochaCallback calls EventComplete. You'll be deleted after this call
+	virtual void	Complete(MWContext * context, LO_Element * element, 
+                 int32 type, ETEventStatus status);
+
+	static void MochaCallback(MWContext * context, LO_Element * element, 
+                 int32 type, void * inCallback, ETEventStatus status);
+
+private:
+// Old Mocha calls used to accept either LO_Element, or LO_AnchorData
+// New ones only accept LO_Element, so sometimes we need to create/dispose
+// dummy layout elements. This is encapsulated in this class
+	LO_Element		* fDummyElement;
+};

mozilla/cmd/macfe/central/CNSContext.h

@@ -0,0 +1,526 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// CNSContext.h
+
+
+#pragma once
+
+
+#include <LBroadcaster.h>
+#include <LSharable.h>
+
+#include "structs.h"
+#include "cstring.h"
+
+class CHTMLView;
+class CNSContext;
+
+
+inline CNSContext* ExtractNSContext(MWContext* inContext)
+	{	return inContext->fe.newContext;		}
+
+inline const CNSContext* ExtractConstNSContext(const MWContext* inContext)
+	{	return inContext->fe.newContext;		}
+
+inline CHTMLView* ExtractHyperView(const MWContext* inContext)
+	{	return inContext->fe.newView;				}
+
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	This enumeration contains all of the possible broadcast messages that
+//	a CNSContext can give.
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+enum {
+		// These messages notify thge clients about the layout state.		
+	msg_NSCDocTitleChanged				=	'DTCG',					// cstring* theNewTitle
+	msg_NSCLayoutNewDocument			=	'LOND',					// URL_Struct* theURL
+	msg_NSCFinishedLayout				=	'FNLO',					// < none >
+
+		// These messages notify thge clients about the repagination state.		
+	msg_NSCPEmptyRepagination			=	'NLPG',					// < none >
+	msg_NSCPAboutToRepaginate			=	'ABPG',					// < none >
+	msg_NSCPEditorRepaginate			=	'EDPG',					// < none >
+
+		// These messages are key to the whole process of loading a URL.
+		// The start loading and all connections complete notifications are
+		// guaranteed to be symmetrical.
+	msg_NSCStartLoadURL					=	'SLUB',					// URL_Struct* theURL
+	msg_NSCConfirmLoadNewURL			=	'CLNU',					// Boolean*
+	msg_NSCAllConnectionsComplete		=	'ACCP',					// < none >
+
+		// A message to all context clients that this grid context is about to die.
+		// Clients should clean up and remove their shared references to the context
+		// upon receiving this message.
+	msg_NSCGridContextPreDispose		=	'GCPD',					// Boolean* isSavingHistory
+	
+		// A message to all context clients that a child grid context has been
+		// created or disposed.  Clients will want to know if a grid is created
+		// so that they can add themselves as a listener or add a shared reference
+		// to the new context.
+	msg_NSCGridContextCreated			=	'GCCR',					// CNSContext* new grid
+	msg_NSCGridContextDisposed			=	'GCDP',					// < none >
+	
+		// Progress notifications, like the url loading notifications are
+		// guaranteed to be symmetric.  There will always be one begin,
+		// n updates, and one end notification.	
+	msg_NSCProgressBegin				=	'PGST',					// CContextProgress*
+	msg_NSCProgressUpdate				=	'PGUP',					// CContextProgress*
+	msg_NSCProgressEnd					=	'PGED',					// CContextProgress*
+
+		// These are progress messages that are not guaranteed to be sent
+		// between bind and end progress notifications.
+//	msg_NSCProgressMessageChanged		=	'PGMC',					// cstring* theNewMessage
+	msg_NSCProgressMessageChanged		=	'PGMC',					// const char* theNewMessage
+	msg_NSCProgressPercentChanged		=	'PGPC'					// Int32* theNewPercent
+};
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//  The progress of a particular url loading operation is encapsulated in the
+//	following object.  Accessors are provided in the context to support this.
+//	This object is only instantiated during the actual load itself, begining
+//	with msg_NSCStartLoadURL notification and ending with the
+//	msg_NSCAllConnectionsComplete notification.  At all other (inactive) times
+//	the accessors for this object will return NULL.  See the accessor comments
+//	for further information.
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+class CContextProgress : public LSharable
+{
+	public:
+						CContextProgress();
+		
+		Int32			mTotal;			// Total bytes tracked
+		Int32			mRead;			// How many have been read
+		Int32			mUnknownCount;	// How many connections of the unknown length do we have
+		Int32			mPercent;		// Percent complete
+		Int32			mInitCount;
+		Uint32			mStartTime;
+		
+		cstring			mAction;
+		cstring			mMessage;
+		cstring			mComment;
+};
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+class CNSContext : public LBroadcaster, public LSharable
+{
+	friend class CNSContextCallbacks;
+	friend class CPlainTextConversionContext;
+	
+	public:
+								CNSContext(MWContextType inType);
+								CNSContext(const CNSContext& inOriginal);
+								
+		virtual 				~CNSContext();
+
+		virtual	void			NoMoreUsers();
+		
+		operator MWContext*();
+		operator const MWContext*() const;
+		operator MWContext&();
+		operator const MWContext&() const;
+
+		virtual	CContextProgress* 	GetContextProgress();
+
+	protected:
+		virtual	void			 	SetContextProgress(CContextProgress* inProgress);
+	public:
+		void						EnsureContextProgress();
+
+		virtual cstring				GetDescriptor() const;
+		virtual void				SetDescriptor(const char* inDescriptor);
+	
+		virtual	Boolean				IsCloneRequired() const;
+		virtual	void				SetRequiresClone(Boolean inClone);
+	
+		virtual	CContextProgress*	GetCurrentProgressStats();
+		virtual	void				UpdateCurrentProgressStats();
+
+		virtual void				WaitWhileBusy();
+
+// FIX ME!!! ACCESSOR for unique ID
+
+			// CHARACTER SET ACCESSORS
+			
+		void						InitDefaultCSID();
+		virtual	void				SetDefaultCSID(Int16 inDefaultCSID);
+		virtual	Int16				GetDefaultCSID() const;
+		virtual	void				SetDocCSID(Int16 inDocCSID);
+		virtual	Int16				GetDocCSID() const;
+		virtual	void				SetWinCSID(Int16 inWinCSID);
+		virtual	Int16				GetWinCSID() const;
+		virtual	Int16				GetWCSIDFromDocCSID(
+											Int16					inDocCSID);
+
+
+		class IndexOutOfRangeException { };
+		virtual History_entry*		GetCurrentHistoryEntry();
+		virtual Int32				GetHistoryListCount();
+		virtual cstring*			GetHistoryEntryTitleByIndex(Int32 inIndex); // one-based index
+		virtual Int32				GetIndexOfCurrentHistoryEntry();
+		virtual void				GetHistoryURLByIndex(cstring& outURL, Int32 inIndex);	// one-based index
+
+			// URL MANIPULATION
+		// 97-10-29 pchen -- Fix bug #90892, prefer origin_url in history entry to address
+		virtual cstring				GetURLForReferral();
+		
+		virtual	cstring				GetCurrentURL();
+		
+		virtual	void				SwitchLoadURL(
+											URL_Struct*				inURL,
+											FO_Present_Types		inOutputFormat);
+											
+		virtual	void				ImmediateLoadURL(
+											URL_Struct*				inURL,
+											FO_Present_Types		inOutputFormat);
+
+		// Need to make Alert public because we need to be able to call it from FE_Alert
+		virtual	void 				Alert(
+											const char*				inAlertText);
+		
+			// STATUS		
+
+		virtual const char*			GetDefaultStatus() const;
+		virtual void				ClearDefaultStatus();
+		virtual void				SetStatus(const char* inStatus);
+
+			// STUFF
+		virtual void 				CompleteLoad(URL_Struct* inURL, int inStatus);
+		virtual void				ClearMWContextViewPtr();
+
+		virtual void				CopyListenersToContext(CNSContext* aSubContext);		// used when spawning grid contexts
+
+	protected:
+
+
+			// CALLBACK IMPLEMENTATION
+
+		virtual	MWContext* 			CreateNewDocWindow(
+											URL_Struct*				inURL);
+
+		virtual	void 				LayoutNewDocument(
+											URL_Struct*				inURL,
+											Int32*					inWidth,
+											Int32*					inHeight,
+											Int32*					inMarginWidth,
+											Int32*					inMarginHeight);
+
+		virtual	void 				SetDocTitle(
+											char* 					inTitle);
+											
+		virtual	void 				FinishedLayout();
+											
+		virtual	char* 				TranslateISOText(
+											int 					inCharset,
+											char*					inISOText);
+											
+		virtual	int 				GetTextInfo(
+											LO_TextStruct*			inText,
+											LO_TextInfo*			inTextInfo);
+											
+		virtual	int 				MeasureText(
+											LO_TextStruct*			inText,
+											short*					outCharLocs);
+											
+		virtual	void 				GetEmbedSize(
+											LO_EmbedStruct*			inEmbedStruct,
+											NET_ReloadMethod		inReloadMethod);
+											
+		virtual	void 				GetJavaAppSize(
+											LO_JavaAppStruct*		inJavaAppStruct,
+											NET_ReloadMethod		inReloadMethod);
+											
+		virtual	void 				GetFormElementInfo(
+											LO_FormElementStruct* 	inElement);
+
+		virtual	void 				GetFormElementValue(
+											LO_FormElementStruct* 	inElement,
+											XP_Bool 				inHide);
+
+		virtual	void 				ResetFormElement(
+											LO_FormElementStruct* 	inElement);
+
+		virtual	void 				SetFormElementToggle(
+											LO_FormElementStruct* 	inElement,
+											XP_Bool 				inToggle);
+
+		virtual	void 				FreeEmbedElement(
+											LO_EmbedStruct*			inEmbedStruct);
+											
+		virtual void				CreateEmbedWindow(
+											NPEmbeddedApp*			inEmbeddedApp);
+											
+		virtual void				SaveEmbedWindow(
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		virtual void				RestoreEmbedWindow(
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		virtual void				DestroyEmbedWindow(
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		virtual	void 				FreeJavaAppElement(
+											LJAppletData*			inAppletData);
+
+		virtual	void 				HideJavaAppElement(
+											LJAppletData*				inAppletData);
+
+		virtual	void 				FreeEdgeElement(
+											LO_EdgeStruct*			inEdgeStruct);
+
+		virtual	void 				FormTextIsSubmit(
+											LO_FormElementStruct* 	inElement);
+
+		virtual	void 				DisplaySubtext(
+											int 					inLocation,
+											LO_TextStruct*			inText,
+											Int32 					inStartPos,
+											Int32					inEndPos,
+											XP_Bool 				inNeedBG);
+
+		virtual	void 				DisplayText(
+											int 					inLocation,
+											LO_TextStruct*			inText,
+											XP_Bool 				inNeedBG);
+
+		virtual	void 				DisplayEmbed(
+											int 					inLocation,
+											LO_EmbedStruct*			inEmbedStruct);
+
+		virtual	void 				DisplayJavaApp(
+											int 					inLocation,
+											LO_JavaAppStruct*		inJavaAppStruct);
+
+		virtual	void 				DisplayEdge (
+											int 					inLocation,
+											LO_EdgeStruct*			inEdgeStruct);
+
+		virtual	void 				DisplayTable(
+											int 					inLocation,
+											LO_TableStruct*			inTableStruct);
+
+		virtual	void 				DisplayCell(
+											int 					inLocation,
+											LO_CellStruct*			inCellStruct);
+
+		virtual	void 				InvalidateEntireTableOrCell(
+											LO_Element*				inElement);
+
+		virtual	void 				DisplayAddRowOrColBorder(
+											XP_Rect*				inRect,
+											XP_Bool					inDoErase);
+
+		virtual	void 				DisplaySubDoc(
+											int 					inLocation,
+											LO_SubDocStruct*		inSubdocStruct);
+
+		virtual	void 				DisplayLineFeed(
+											int 					inLocation,
+											LO_LinefeedStruct*		inLinefeedStruct,
+											XP_Bool 				inNeedBG);
+
+		virtual	void 				DisplayHR(
+											int 					inLocation,
+											LO_HorizRuleStruct*		inRuleStruct);
+
+		virtual	void 				DisplayBullet(
+											int 					inLocation,
+											LO_BullettStruct*		inBullettStruct);
+
+		virtual	void 				DisplayFormElement(
+											int 					inLocation,
+											LO_FormElementStruct* 	inFormElement);
+
+		virtual	void 				DisplayBorder(
+											int 					inLocation,
+											int						inX,
+											int						inY,
+											int						inWidth,
+											int						inHeight,
+											int						inBW,
+											LO_Color*	 			inColor,
+											LO_LineStyle			inStyle);
+
+		virtual void 				UpdateEnableStates();
+		
+		virtual void 				DisplayFeedback(
+											int 					inLocation,
+											LO_Element* 			inElement);
+
+		virtual	void 				ClearView(
+											int 					inWhich);
+
+		virtual	void 				SetDocDimension(
+											int 					inLocation,
+											Int32 					inWidth,
+											Int32 					inLength);
+
+		virtual	void 				SetDocPosition(
+											int 					inLocation,
+											Int32 					inX,
+											Int32 					inY);
+
+		virtual	void 				GetDocPosition(
+											int 					inLocation,
+											Int32*					outX,
+											Int32*					outY);
+
+		virtual	void 				BeginPreSection();
+
+		virtual	void 				EndPreSection();
+
+		virtual	void 				SetProgressBarPercent(
+											Int32 					inPercent);
+
+		virtual	void 				SetBackgroundColor(
+											Uint8 					inRed,
+											Uint8					inGreen,
+											Uint8 					inBlue);
+
+public:
+		virtual	void 				Progress(
+											const char*				inMessageText);
+protected:
+		virtual	void 				SetCallNetlibAllTheTime();
+
+		virtual	void 				ClearCallNetlibAllTheTime();
+
+		virtual	void 				GraphProgressInit(
+											URL_Struct*				inURL,
+											Int32 					inContentLength);
+
+		virtual	void 				GraphProgressDestroy(
+											URL_Struct*				inURL,
+											Int32 					inContentLength,
+											Int32 					inTotalRead);
+
+		virtual	void 				GraphProgress(
+											URL_Struct*				inURL,
+											Int32 					inBytesReceived,
+											Int32 					inBytesSinceLast,
+											Int32 					inContentLength);
+
+		virtual	XP_Bool 			UseFancyFTP();
+
+		virtual	XP_Bool 			UseFancyNewsgroupListing();
+
+		virtual	int 				FileSortMethod();
+
+		virtual	XP_Bool 			ShowAllNewsArticles();
+
+		virtual	XP_Bool				Confirm(
+											const char* 			inMessage);
+
+		virtual	char* 				Prompt(
+											const char* 			inMessage,
+											const char*				inDefaultText);
+
+		virtual	char* 				PromptWithCaption(
+											const char*				inCaption,
+											const char* 			inMessage,
+											const char*				inDefaultText);
+
+		virtual	XP_Bool 			PromptUsernameAndPassword(
+											const char*				inMessage,
+											char**					outUserName,
+											char**					outPassword);
+
+		virtual	char* 				PromptPassword(
+											const char* 			inMessage);
+
+		virtual	void 				EnableClicking();
+
+		virtual	void 				AllConnectionsComplete();
+
+		virtual	void 				EraseBackground(
+											int						inLocation,
+											Int32					inX,
+											Int32					inY,
+											Uint32					inWidth,
+											Uint32					inHieght,
+											LO_Color*				inColor);
+
+		virtual	void 				SetDrawable(
+											CL_Drawable*			inDrawable);
+
+		virtual	void 				GetTextFrame(
+											LO_TextStruct*			inTextStruct,
+											Int32					inStartPos,
+											Int32					inEndPos,
+											XP_Rect*				outFrame);
+
+		virtual	void 				GetDefaultBackgroundColor(
+											LO_Color*				outColor) const;
+
+		virtual	void 				DrawJavaApp(
+											int 					inLocation,
+											LO_JavaAppStruct*		inJavaAppStruct);
+											
+		virtual	void 				HandleClippingView(
+											struct LJAppletData 	*appletD, 
+											int 					x, 
+											int 					y, 
+											int 					width, 
+											int 					height);
+
+public:
+
+		static	UInt32	sNSCWindowID;		// Unique ID, incremented for each context
+		UInt32			fNSCWindowID;		// ID of this window
+		Int32			fNSCProgressID;	// 
+
+		Int32			GetTransactionID() { return fNSCProgressID; }
+		Int32			GetContextUniqueID() { return fNSCWindowID; }
+		CommandT		GetCurrentCommand() const { return mCurrentCommand; }
+		void			SetCurrentCommand(CommandT inCommand) { mCurrentCommand = inCommand; }
+		// Window ID. Used to identify the context
+
+
+		// There are listeners that listen to several contexts (eg, in mail windows).
+		// This works by reference counting, and such listeners assume calls to
+		// SwitchLoadURL and AllConnectionsComplete are balanced.  Each context must
+		// therefore ensure that they are, even if it is done artificially.
+		Int32						mLoadRefCount;
+
+
+protected:
+
+
+		MWContext				mContext;
+
+		Int16 					mDefaultCSID;
+		Boolean					mRequiresClone;		
+		CContextProgress*		mProgress;
+		CommandT				mCurrentCommand; // command being executed
+};
+
+
+inline CNSContext::operator MWContext*()
+	{	return &mContext;		};
+inline CNSContext::operator const MWContext*() const
+	{	return &mContext;		};
+inline CNSContext::operator MWContext&()
+	{	return mContext;		};
+inline CNSContext::operator const MWContext&() const
+	{	return mContext;		};
+	

mozilla/cmd/macfe/central/CNSContextCallbacks.cp

@@ -0,0 +1,745 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CNSContextCallbacks.cp
+
+
+#include "CNSContextCallbacks.h"
+#include "CNSContext.h"
+
+CNSContextCallbacks* CNSContextCallbacks::sContextCallbacks = NULL;		// singleton class
+
+CNSContextCallbacks::CNSContextCallbacks()
+{
+	#define MAKE_FE_FUNCS_PREFIX(f) 	CNSContextCallbacks::##f
+	#define MAKE_FE_FUNCS_ASSIGN 		mCallbacks.
+	#include "mk_cx_fn.h"
+
+	Assert_(sContextCallbacks == NULL);
+	sContextCallbacks = this;
+}
+
+CNSContextCallbacks::~CNSContextCallbacks()
+{
+	sContextCallbacks = NULL;
+}
+
+MWContext* CNSContextCallbacks::CreateNewDocWindow(
+	MWContext* 			inContext,
+	URL_Struct*			inURL)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	
+	return theNSContext->CreateNewDocWindow(inURL);
+}
+
+void CNSContextCallbacks::LayoutNewDocument(
+	MWContext*			inContext,
+	URL_Struct*			inURL,
+	int32*				inWidth,
+	int32*				inHeight,
+	int32*				inMarginWidth,
+	int32*				inMarginHeight)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->LayoutNewDocument(inURL, inWidth, inHeight, inMarginWidth, inMarginHeight);
+}
+	
+void CNSContextCallbacks::SetDocTitle(
+	MWContext* 				inContext,
+	char* 					inTitle)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->SetDocTitle(inTitle);
+}
+
+void CNSContextCallbacks::FinishedLayout(MWContext* inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->FinishedLayout();
+}
+
+char* CNSContextCallbacks::TranslateISOText(											
+	MWContext* 				inContext,
+	int 					inCharset,
+	char*					inISOText)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->TranslateISOText(inCharset, inISOText);
+}
+
+int CNSContextCallbacks::GetTextInfo(
+	MWContext* 				inContext,
+	LO_TextStruct*			inText,
+	LO_TextInfo*			inTextInfo)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->GetTextInfo(inText, inTextInfo);
+}
+
+int CNSContextCallbacks::MeasureText(
+	MWContext* 				inContext,
+	LO_TextStruct*			inText,
+	short*					outCharLocs)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->MeasureText(inText, outCharLocs);
+}
+
+void CNSContextCallbacks::GetEmbedSize(
+	MWContext* 				inContext,
+	LO_EmbedStruct*			inEmbedStruct,
+	NET_ReloadMethod		inReloadMethod)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GetEmbedSize(inEmbedStruct, inReloadMethod);
+}
+
+void CNSContextCallbacks::GetJavaAppSize(
+	MWContext* 				inContext,
+	LO_JavaAppStruct*		inJavaAppStruct,
+	NET_ReloadMethod		inReloadMethod)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GetJavaAppSize(inJavaAppStruct, inReloadMethod);
+}
+
+void CNSContextCallbacks::GetFormElementInfo(
+	MWContext* 				inContext,
+	LO_FormElementStruct* 	inElement)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GetFormElementInfo(inElement);
+}
+
+void CNSContextCallbacks::GetFormElementValue(
+	MWContext* 				inContext,
+	LO_FormElementStruct* 	inElement,
+	XP_Bool 				inHide)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GetFormElementValue(inElement, inHide);
+}
+
+void CNSContextCallbacks::ResetFormElement(
+	MWContext* 				inContext,
+	LO_FormElementStruct* 	inElement)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->ResetFormElement(inElement);
+}
+
+void CNSContextCallbacks::SetFormElementToggle(
+	MWContext* 				inContext,
+	LO_FormElementStruct* 	inElement,
+	XP_Bool 				inToggle)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->SetFormElementToggle(inElement, inToggle);
+}
+
+void CNSContextCallbacks::FreeEmbedElement(
+	MWContext* 				inContext,
+	LO_EmbedStruct*			inEmbedStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->FreeEmbedElement(inEmbedStruct);
+
+}
+
+void CNSContextCallbacks::CreateEmbedWindow(
+	MWContext*				inContext,
+	NPEmbeddedApp*			inEmbeddedApp)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->CreateEmbedWindow(inEmbeddedApp);
+}
+
+void CNSContextCallbacks::SaveEmbedWindow(
+	MWContext*				inContext,
+	NPEmbeddedApp*			inEmbeddedApp)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->SaveEmbedWindow(inEmbeddedApp);
+}
+
+void CNSContextCallbacks::RestoreEmbedWindow(
+	MWContext*				inContext,
+	NPEmbeddedApp*			inEmbeddedApp)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->RestoreEmbedWindow(inEmbeddedApp);
+}
+
+void CNSContextCallbacks::DestroyEmbedWindow(
+	MWContext*				inContext,
+	NPEmbeddedApp*			inEmbeddedApp)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DestroyEmbedWindow(inEmbeddedApp);
+}
+
+void CNSContextCallbacks::FreeJavaAppElement(
+	MWContext* 				inContext,
+	LJAppletData*			inAppletData)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->FreeJavaAppElement(inAppletData);
+}
+
+void CNSContextCallbacks::HideJavaAppElement(
+	MWContext* 				inContext,
+	LJAppletData*			inAppletData)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->HideJavaAppElement(inAppletData);
+}
+
+void CNSContextCallbacks::FreeEdgeElement(
+	MWContext* 				inContext,
+	LO_EdgeStruct*			inEdgeStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->FreeEdgeElement(inEdgeStruct);
+}
+
+void CNSContextCallbacks::FormTextIsSubmit(
+	MWContext* 				inContext,
+	LO_FormElementStruct* 	inElement)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->FormTextIsSubmit(inElement);
+}
+
+void CNSContextCallbacks::DisplaySubtext(
+	MWContext* 				inContext,
+	int 					inLocation,
+	LO_TextStruct*			inText,
+	Int32 					inStartPos,
+	Int32					inEndPos,
+	XP_Bool 				inNeedBG)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplaySubtext(inLocation, inText, inStartPos, inEndPos, inNeedBG);
+}
+
+void CNSContextCallbacks::DisplayText(
+	MWContext* 				inContext,
+	int 					inLocation,
+	LO_TextStruct*			inText,
+	XP_Bool 				inNeedBG)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayText(inLocation, inText, inNeedBG);
+}
+
+void CNSContextCallbacks::DisplayEmbed(
+	MWContext* 				inContext,
+	int 					inLocation,
+	LO_EmbedStruct*			inEmbedStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayEmbed(inLocation, inEmbedStruct);
+}
+
+void CNSContextCallbacks::DisplayJavaApp(
+	MWContext* 				inContext,
+	int 					inLocation,
+	LO_JavaAppStruct*		inJavaAppStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayJavaApp(inLocation, inJavaAppStruct);
+}
+
+void CNSContextCallbacks::DisplayEdge(
+	MWContext* 				inContext,
+	int 					inLocation,
+	LO_EdgeStruct*			inEdgeStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayEdge(inLocation, inEdgeStruct);
+}
+
+void CNSContextCallbacks::DisplayTable(
+	MWContext* 				inContext,
+	int 					inLocation,
+	LO_TableStruct*			inTableStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayTable(inLocation, inTableStruct);
+}
+
+void CNSContextCallbacks::DisplayCell(
+	MWContext* 				inContext,
+	int 					inLocation,
+	LO_CellStruct*			inCellStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayCell(inLocation, inCellStruct);
+}
+
+void CNSContextCallbacks::InvalidateEntireTableOrCell(
+	MWContext* 				inContext,
+	LO_Element*				inElement)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	if (inElement)
+		theNSContext->InvalidateEntireTableOrCell(inElement);
+}
+
+void CNSContextCallbacks::DisplayAddRowOrColBorder(
+	MWContext* 				inContext,
+	XP_Rect*				inRect,
+	XP_Bool					inDoErase)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayAddRowOrColBorder(inRect, inDoErase);
+}
+
+void CNSContextCallbacks::DisplaySubDoc(
+	MWContext* 				inContext,
+	int 					inLocation,
+	LO_SubDocStruct*		inSubdocStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplaySubDoc(inLocation, inSubdocStruct);
+}
+
+void CNSContextCallbacks::DisplayLineFeed(
+	MWContext* 				inContext,
+	int 					inLocation,
+	LO_LinefeedStruct*		inLinefeedStruct,
+	XP_Bool 				inNeedBG)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayLineFeed(inLocation, inLinefeedStruct, inNeedBG);
+}
+
+void CNSContextCallbacks::DisplayHR(
+	MWContext*				inContext,
+	int 					inLocation,
+	LO_HorizRuleStruct*		inRuleStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayHR(inLocation, inRuleStruct);
+}
+
+void CNSContextCallbacks::DisplayBullet(
+	MWContext*				inContext,
+	int 					inLocation,
+	LO_BullettStruct*		inBullettStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayBullet(inLocation, inBullettStruct);
+}
+
+void CNSContextCallbacks::DisplayFormElement(
+	MWContext*				inContext,
+	int 					inLocation,
+	LO_FormElementStruct* 	inFormElement)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayFormElement(inLocation, inFormElement);
+}
+
+void CNSContextCallbacks::DisplayBorder(
+	MWContext*				inContext,
+	int 					inLocation,
+	int					inX,
+	int					inY,
+	int					inWidth,
+	int					inHeight,
+	int					inBW,
+	LO_Color*	 			inColor,
+	LO_LineStyle			inStyle)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayBorder(inLocation, inX, inY, inWidth, inHeight, inBW, inColor, inStyle);
+}
+
+
+void CNSContextCallbacks::UpdateEnableStates( MWContext*	inContext )
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->UpdateEnableStates();
+}
+
+void CNSContextCallbacks::DisplayFeedback(
+	MWContext*				inContext,
+	int 					inLocation,
+	LO_Element* 			inElement)
+{
+	// bail out if non-editor context
+	// this function is to be used only for the editor
+	if ( !inContext->is_editor )
+		return;
+	
+	// called even if the element is not selected
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DisplayFeedback(inLocation, inElement);
+}
+
+void CNSContextCallbacks::ClearView(
+	MWContext* 				inContext,
+	int 					inWhich)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->ClearView(inWhich);
+}
+
+void CNSContextCallbacks::SetDocDimension(
+	MWContext*				inContext,
+	int 					inLocation,
+	Int32 					inWidth,
+	Int32 					inLength)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->SetDocDimension(inLocation, inWidth, inLength);
+}
+
+void CNSContextCallbacks::SetDocPosition(
+	MWContext*				inContext,
+	int 					inLocation,
+	Int32 					inX,
+	Int32 					inY)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->SetDocPosition(inLocation, inX, inY);
+}
+
+void CNSContextCallbacks::GetDocPosition(
+	MWContext*				inContext,
+	int 					inLocation,
+	Int32*					outX,
+	Int32*					outY)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GetDocPosition(inLocation, outX, outY);
+}
+
+void CNSContextCallbacks::BeginPreSection(
+	MWContext* 				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->BeginPreSection();
+}
+
+void CNSContextCallbacks::EndPreSection(
+	MWContext* 				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->EndPreSection();
+}
+
+void CNSContextCallbacks::SetProgressBarPercent(
+	MWContext*				inContext,
+	Int32 					inPercent)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->SetProgressBarPercent(inPercent);
+}
+
+void CNSContextCallbacks::SetBackgroundColor(
+	MWContext*				inContext,
+	Uint8 					inRed,
+	Uint8					inGreen,
+	Uint8 					inBlue)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->SetBackgroundColor(inRed, inGreen, inBlue);
+}
+
+void CNSContextCallbacks::Progress(
+	MWContext* 				inContext,
+	const char*				inMessageText)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->Progress(inMessageText);
+}
+
+void CNSContextCallbacks::Alert(
+	MWContext* 				inContext,
+	const char*				inAlertText)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->Alert(inAlertText);
+}
+
+void CNSContextCallbacks::SetCallNetlibAllTheTime(
+	MWContext* 				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->SetCallNetlibAllTheTime();
+}
+
+void CNSContextCallbacks::ClearCallNetlibAllTheTime(
+	MWContext*				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->ClearCallNetlibAllTheTime();
+}
+
+void CNSContextCallbacks::GraphProgressInit(
+	MWContext*				inContext,
+	URL_Struct*				inURL,
+	Int32 					inContentLength)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GraphProgressInit(inURL, inContentLength);
+}
+
+void CNSContextCallbacks::GraphProgressDestroy(
+	MWContext*				inContext,
+	URL_Struct*				inURL,
+	Int32 					inContentLength,
+	Int32 					inTotalRead)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GraphProgressDestroy(inURL, inContentLength, inTotalRead);
+}
+
+void CNSContextCallbacks::GraphProgress(
+	MWContext*				inContext,
+	URL_Struct*				inURL,
+	Int32 					inBytesReceived,
+	Int32 					inBytesSinceLast,
+	Int32 					inContentLength)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GraphProgress(inURL, inBytesReceived, inBytesSinceLast, inContentLength);
+}
+
+XP_Bool CNSContextCallbacks::UseFancyFTP(
+	MWContext* 				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->UseFancyFTP();
+}
+
+XP_Bool CNSContextCallbacks::UseFancyNewsgroupListing(
+	MWContext* 				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->UseFancyNewsgroupListing();
+}
+
+int CNSContextCallbacks::FileSortMethod(
+	MWContext* 				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->FileSortMethod();
+}
+
+XP_Bool CNSContextCallbacks::ShowAllNewsArticles(
+	MWContext* 				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->ShowAllNewsArticles();
+}
+
+XP_Bool	CNSContextCallbacks::Confirm(
+	MWContext*				inContext,
+	const char* 			inMessage)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->Confirm(inMessage);
+}
+
+char* CNSContextCallbacks::Prompt(
+	MWContext*				inContext,
+	const char* 			inMessage,
+	const char*				inDefaultText)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->Prompt(inMessage, inDefaultText);
+}
+
+char* CNSContextCallbacks::PromptWithCaption(
+	MWContext*				inContext,
+	const char*				inCaption,
+	const char* 			inMessage,
+	const char*				inDefaultText)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->PromptWithCaption(inCaption, inMessage, inDefaultText);
+}
+
+XP_Bool CNSContextCallbacks::PromptUsernameAndPassword(
+	MWContext* 				inContext,
+	const char*				inMessage,
+	char**					outUserName,
+	char**					outPassword)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->PromptUsernameAndPassword(inMessage, outUserName, outPassword);
+}
+
+char* CNSContextCallbacks::PromptPassword(
+	MWContext* 				inContext,
+	const char* 			inMessage)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	return theNSContext->PromptPassword(inMessage);
+}
+
+void CNSContextCallbacks::EnableClicking(
+	MWContext* 				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->EnableClicking();
+}
+
+void CNSContextCallbacks::AllConnectionsComplete(
+	MWContext*				inContext)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	if (theNSContext)
+		theNSContext->AllConnectionsComplete();
+}
+
+void CNSContextCallbacks::EraseBackground(
+	MWContext*				inContext,
+	int						inLocation,
+	Int32					inX,
+	Int32					inY,
+	Uint32					inWidth,
+	Uint32					inHeight,
+	LO_Color*				inColor)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->EraseBackground(inLocation, inX, inY, inWidth, inHeight, inColor);
+}
+
+void CNSContextCallbacks::SetDrawable(
+	MWContext*				inContext,
+	CL_Drawable*			inDrawable)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->SetDrawable(inDrawable);
+}
+
+void CNSContextCallbacks::GetTextFrame(
+	MWContext*				inContext,
+	LO_TextStruct*			inTextStruct,
+	Int32					inStartPos,
+	Int32					inEndPos,
+	XP_Rect*				outFrame)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GetTextFrame(inTextStruct, inStartPos, inEndPos, outFrame);
+}
+
+void CNSContextCallbacks::GetDefaultBackgroundColor(
+	MWContext*				inContext,
+	LO_Color*				outColor)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->GetDefaultBackgroundColor(outColor);
+}
+
+void CNSContextCallbacks::DrawJavaApp(
+	MWContext*				inContext,
+	int 					inLocation,
+	LO_JavaAppStruct*		inJavaAppStruct)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->DrawJavaApp(inLocation, inJavaAppStruct);
+}
+
+void CNSContextCallbacks::HandleClippingView(
+	MWContext*				inContext,
+	struct LJAppletData 	*appletD, 
+	int 					x, 
+	int 					y, 
+	int 					width, 
+	int 					height)
+{
+	CNSContext* theNSContext = ExtractNSContext(inContext);
+	Assert_(theNSContext != NULL);
+	theNSContext->HandleClippingView(appletD, x, y, width, height);
+}

mozilla/cmd/macfe/central/CNSContextCallbacks.h

@@ -0,0 +1,393 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CNSContextCallbacks.h
+
+
+#pragma once
+
+#include "ntypes.h"
+#include "structs.h"
+#include "ctxtfunc.h"
+
+class CNSContext;
+
+
+class CNSContextCallbacks
+{
+	public:
+
+		static CNSContextCallbacks* GetContextCallbacks(void);		// singleton class accessor
+	
+									CNSContextCallbacks();
+		virtual						~CNSContextCallbacks();
+
+		ContextFuncs&				GetInternalCallbacks(void);
+		
+	protected:
+
+		static	MWContext* 			CreateNewDocWindow(
+											MWContext* 				inContext,
+											URL_Struct*				inURL);
+
+		static	void 				LayoutNewDocument(
+											MWContext*				inContext,
+											URL_Struct*				inURL,
+											Int32*					inWidth,
+											Int32*					inHeight,
+											Int32*					inMarginWidth,
+											Int32*					inMarginHeight);
+
+		static	void 				SetDocTitle(
+											MWContext* 				inContext,
+											char* 					inTitle);
+											
+		static	void 				FinishedLayout(
+											MWContext* 				inContext);
+											
+		static	char* 				TranslateISOText(
+											MWContext* 				inContext,
+											int 					inCharset,
+											char*					inISOText);
+											
+		static	int 				GetTextInfo(
+											MWContext* 				inContext,
+											LO_TextStruct*			inText,
+											LO_TextInfo*			inTextInfo);
+											
+		static	int 				MeasureText(
+											MWContext* 				inContext,
+											LO_TextStruct*			inText,
+											short*					outCharLocs);
+											
+		static	void 				GetEmbedSize(
+											MWContext* 				inContext,
+											LO_EmbedStruct*			inEmbedStruct,
+											NET_ReloadMethod		inReloadMethod);
+											
+		static	void 				GetJavaAppSize(
+											MWContext* 				inContext,
+											LO_JavaAppStruct*		inJavaAppStruct,
+											NET_ReloadMethod		inReloadMethod);
+											
+		static	void 				GetFormElementInfo(
+											MWContext* 				inContext,
+											LO_FormElementStruct* 	inElement);
+
+		static	void 				GetFormElementValue(
+											MWContext* 				inContext,
+											LO_FormElementStruct* 	inElement,
+											XP_Bool 				inHide);
+
+		static	void 				ResetFormElement(
+											MWContext* 				inContext,
+											LO_FormElementStruct* 	inElement);
+
+		static	void 				SetFormElementToggle(
+											MWContext* 				inContext,
+											LO_FormElementStruct* 	inElement,
+											XP_Bool 				inToggle);
+
+		static	void 				FreeEmbedElement(
+											MWContext* 				inContext,
+											LO_EmbedStruct*			inEmbedStruct);
+
+		static	void 				CreateEmbedWindow(
+											MWContext* 				inContext,
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		static	void 				SaveEmbedWindow(
+											MWContext* 				inContext,
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		static	void 				RestoreEmbedWindow(
+											MWContext* 				inContext,
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		static	void 				DestroyEmbedWindow(
+											MWContext* 				inContext,
+											NPEmbeddedApp*			inEmbeddedApp);
+
+		static	void 				FreeJavaAppElement(
+											MWContext* 				inContext,
+											LJAppletData*			inAppletData);
+
+		static	void 				HideJavaAppElement(
+											MWContext* 				inContext,
+											LJAppletData*				inAppletData);
+
+		static	void 				FreeEdgeElement(
+											MWContext* 				inContext,
+											LO_EdgeStruct*			inEdgeStruct);
+
+		static	void 				FormTextIsSubmit(
+											MWContext* 				inContext,
+											LO_FormElementStruct* 	inElement);
+
+		static	void 				DisplaySubtext(
+											MWContext* 				inContext,
+											int 					inLocation,
+											LO_TextStruct*			inText,
+											Int32 					inStartPos,
+											Int32					inEndPos,
+											XP_Bool 				inNeedBG);
+
+		static	void 				DisplayText(
+											MWContext* 				inContext,
+											int 					inLocation,
+											LO_TextStruct*			inText,
+											XP_Bool 				inNeedBG);
+
+		static	void 				DisplayEmbed(
+											MWContext* 				inContext,
+											int 					inLocation,
+											LO_EmbedStruct*			inEmbedStruct);
+
+		static	void 				DisplayJavaApp(
+											MWContext* 				inContext,
+											int 					inLocation,
+											LO_JavaAppStruct*		inJavaAppStruct);
+
+		static	void 				DisplayEdge (
+											MWContext* 				inContext,
+											int 					inLocation,
+											LO_EdgeStruct*			inEdgeStruct);
+
+		static	void 				DisplayTable(
+											MWContext* 				inContext,
+											int 					inLocation,
+											LO_TableStruct*			inTableStruct);
+
+		static	void 				DisplayCell(
+											MWContext* 				inContext,
+											int 					inLocation,
+											LO_CellStruct*			inCellStruct);
+
+		static	void 				InvalidateEntireTableOrCell(
+											MWContext* 				inContext,
+											LO_Element*				inElement);
+
+		static	void 				DisplayAddRowOrColBorder(
+											MWContext* 				inContext,
+											XP_Rect*				inRect,
+											XP_Bool					inErase);
+
+		static	void 				DisplaySubDoc(
+											MWContext* 				inContext,
+											int 					inLocation,
+											LO_SubDocStruct*		inSubdocStruct);
+
+		static	void 				DisplayLineFeed(
+											MWContext* 				inContext,
+											int 					inLocation,
+											LO_LinefeedStruct*		inLinefeedStruct,
+											XP_Bool 				inNeedBG);
+
+		static	void 				DisplayHR(
+											MWContext*				inContext,
+											int 					inLocation,
+											LO_HorizRuleStruct*		inRuleStruct);
+
+		static	void 				DisplayBullet(
+											MWContext*				inContext,
+											int 					inLocation,
+											LO_BullettStruct*		inBullettStruct);
+
+		static	void 				DisplayFormElement(
+											MWContext*				inContext,
+											int 					inLocation,
+											LO_FormElementStruct* 	inFormElement);
+
+		static	void 				DisplayBorder(
+											MWContext*				inContext,
+											int 					inLocation,
+											int					inX,
+											int					inY,
+											int					inWidth,
+											int					inHeight,
+											int					inBW,
+											LO_Color* 				inColor,
+											LO_LineStyle		inStyle);
+
+		static	void 				UpdateEnableStates(
+											MWContext* 				inContext);
+
+		static	void 				DisplayFeedback(
+											MWContext*				inContext,
+											int 					inLocation,
+											LO_Element* 			inElement);
+
+		static	void 				ClearView(
+											MWContext* 				inContext,
+											int 					inWhich);
+
+		static	void 				SetDocDimension(
+											MWContext*				inContext,
+											int 					inLocation,
+											Int32 					inWidth,
+											Int32 					inLength);
+
+		static	void 				SetDocPosition(
+											MWContext*				inContext,
+											int 					inLocation,
+											Int32 					inX,
+											Int32 					inY);
+
+		static	void 				GetDocPosition(
+											MWContext*				inContext,
+											int 					inLocation,
+											Int32*					outX,
+											Int32*					outY);
+
+		static	void 				BeginPreSection(
+											MWContext*				inContext);
+
+		static	void 				EndPreSection(
+											MWContext*				inContext);
+
+		static	void 				SetProgressBarPercent(
+											MWContext*				inContext,
+											Int32 					inPercent);
+
+		static	void 				SetBackgroundColor(
+											MWContext*				inContext,
+											Uint8 					inRed,
+											Uint8					inGreen,
+											Uint8 					inBlue);
+
+		static	void 				Progress(
+											MWContext* 				inContext,
+											const char*				inMessageText);
+
+		static	void 				Alert(
+											MWContext* 				inContext,
+											const char*				inAlertText);
+
+		static	void 				SetCallNetlibAllTheTime(
+											MWContext* 				inContext);
+
+		static	void 				ClearCallNetlibAllTheTime(
+											MWContext* 				inContext);
+
+		static	void 				GraphProgressInit(
+											MWContext*				inContext,
+											URL_Struct*				inURL,
+											Int32 					inContentLength);
+
+		static	void 				GraphProgressDestroy(
+											MWContext*				inContext,
+											URL_Struct*				inURL,
+											Int32 					inContentLength,
+											Int32 					inTotalRead);
+
+		static	void 				GraphProgress(
+											MWContext*				inContext,
+											URL_Struct*				inURL,
+											Int32 					inBytesReceived,
+											Int32 					inBytesSinceLast,
+											Int32 					inContentLength);
+
+		static	XP_Bool 			UseFancyFTP(
+											MWContext* 				inContext);
+
+		static	XP_Bool 			UseFancyNewsgroupListing(
+											MWContext* 				inContext);
+
+		static	int 				FileSortMethod(
+											MWContext* 				inContext);
+
+		static	XP_Bool 			ShowAllNewsArticles(
+											MWContext* 				inContext);
+
+		static	XP_Bool				Confirm(
+											MWContext*				inContext,
+											const char* 			inMessage);
+
+		static	char* 				PromptWithCaption(
+											MWContext*				inContext,
+											const char* 			inCaption,
+											const char* 			inMessage,
+											const char*				inDefaultText);
+
+		static	char* 				Prompt(
+											MWContext*				inContext,
+											const char* 			inMessage,
+											const char*				inDefaultText);
+
+		static	XP_Bool 			PromptUsernameAndPassword(
+											MWContext* 				inContext,
+											const char*				inMessage,
+											char**					outUserName,
+											char**					outPassword);
+
+		static	char* 				PromptPassword(
+											MWContext* 				inContext,
+											const char* 			inMessage);
+
+		static	void 				EnableClicking(
+											MWContext* 				inContext);
+
+		static	void 				AllConnectionsComplete(
+											MWContext* 				inContext);
+
+		static	void 				EraseBackground(
+											MWContext*				inContext,
+											int						inLocation,
+											Int32					inX,
+											Int32					inY,
+											Uint32					inWidth,
+											Uint32					inHeight,
+											LO_Color*				inColor);
+
+		static	void 				SetDrawable(
+											MWContext*				inContext,
+											CL_Drawable*			inDrawable);
+
+		static	void 				GetTextFrame(
+											MWContext*				inContext,
+											LO_TextStruct*			inTextStruct,
+											Int32					inStartPos,
+											Int32					inEndPos,
+											XP_Rect*				outFrame);
+
+		static	void 				GetDefaultBackgroundColor(
+											MWContext*				inContext,
+											LO_Color*				outColor);
+
+		static	void 				DrawJavaApp(
+											MWContext*				inContext,
+											int 					inLocation,
+											LO_JavaAppStruct*		inJavaAppStruct);
+											
+		static	void 				HandleClippingView(
+											MWContext*				inContext,
+											struct LJAppletData 	*appletD, 
+											int 					x, 
+											int 					y, 
+											int 					width, 
+											int 					height);
+
+		ContextFuncs				mCallbacks;
+
+		static	CNSContextCallbacks* sContextCallbacks;		// singleton class
+};
+
+inline _ContextFuncs& CNSContextCallbacks::GetInternalCallbacks(void)
+	{	return mCallbacks;					}
+inline CNSContextCallbacks* CNSContextCallbacks::GetContextCallbacks(void)
+	{	return sContextCallbacks;			}

mozilla/cmd/macfe/central/CPlainTextConversionContext.cp

@@ -0,0 +1,252 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// CPlainTextConversionContext.cp
+
+
+// This might seem like a lot of work to go around the code in ns/lib/xlate/text.c,
+// but doing this allows us not to have to put if (inContext == NULL) inside
+// CNSContextCallbacks.cp; and by calling the TXFE_* functions from the overridden
+// methods, we pickup any modifcations made for free.
+
+//#include <yvals.h>
+
+#include "CPlainTextConversionContext.h"
+
+#include "xlate.h"
+
+//_EXTERN_C
+__extern_c
+
+// prototypes for text.c functions
+
+extern void TXFE_DisplayTable(MWContext *cx, int iLoc, LO_TableStruct *table);
+extern void TXFE_DisplayLineFeed(MWContext *cx, int iLocation, LO_LinefeedStruct *line_feed, XP_Bool notused);
+extern void TXFE_DisplayHR(MWContext *cx, int iLocation , LO_HorizRuleStruct *HR);
+extern char *TXFE_TranslateISOText(MWContext *cx, int charset, char *ISO_Text);
+extern void TXFE_DisplayBullet(MWContext *cx, int iLocation, LO_BullettStruct *bullet);
+extern void TXFE_FinishedLayout(MWContext *cx);
+extern void TXFE_AllConnectionsComplete(MWContext *cx);
+extern void TXFE_DisplaySubtext(MWContext *cx, int iLocation, LO_TextStruct *text,
+		    int32 start_pos, int32 end_pos, XP_Bool notused);
+extern void TXFE_DisplayText(MWContext *cx, int iLocation, LO_TextStruct *text, XP_Bool needbg);
+extern void TXFE_DisplaySubDoc(MWContext *cx, int iLocation, LO_SubDocStruct *subdoc_struct);
+extern int TXFE_GetTextInfo(MWContext *cx, LO_TextStruct *text, LO_TextInfo *text_info);
+extern void TXFE_LayoutNewDocument(MWContext *cx, URL_Struct *url, int32 *w, int32 *h, int32* mw, int32* mh);
+
+// These are here because the backend files are .c files, which are only
+// run through the C compiler. Thus we need to create and destroy the
+// CPlainTextConversionContext from a .cp file
+
+MWContext* CreatePlainTextConversionContext(MWContext* inUIContext);
+void DisposePlainTextConversionContext(MWContext* inContext);
+
+__end_extern_c
+
+#pragma mark --- CALLBACKS ---
+
+MWContext* CreatePlainTextConversionContext(MWContext* inUIContext)
+{
+	try {
+		CPlainTextConversionContext* theContext = new CPlainTextConversionContext(inUIContext);
+		// Very slimey, but somebody needs to have an interest in the context
+		theContext->AddUser(theContext);
+		return theContext->operator MWContext*();
+	} catch (...) {
+		return NULL;
+	}
+}
+
+void DisposePlainTextConversionContext(MWContext* inContext)
+{
+	CPlainTextConversionContext* theContext =
+		dynamic_cast<CPlainTextConversionContext*>(ExtractNSContext(inContext));
+	Assert_(theContext != NULL);
+	// One of these days, this call might break
+	theContext->RemoveUser(theContext);
+}
+
+CPlainTextConversionContext::CPlainTextConversionContext(MWContext* inUIContext) :
+	CNSContext(MWContextText)
+{
+	mUIContext = ExtractNSContext(inUIContext);
+	Assert_(mUIContext != NULL);
+}
+
+#pragma mark --- OVERRIDES ---
+
+void CPlainTextConversionContext::LayoutNewDocument(
+	URL_Struct*				inURL,
+	Int32*					inWidth,
+	Int32*					inHeight,
+	Int32*					inMarginWidth,
+	Int32*					inMarginHeight)
+{
+	TXFE_LayoutNewDocument(*this, inURL, inWidth, inHeight, inMarginWidth, inMarginHeight);
+}
+
+void CPlainTextConversionContext::DisplaySubtext(
+	int 					inLocation,
+	LO_TextStruct*			inText,
+	Int32 					inStartPos,
+	Int32					inEndPos,
+	XP_Bool 				inNeedBG)
+{
+	TXFE_DisplaySubtext(*this, inLocation, inText, inStartPos, inEndPos, inNeedBG);
+}
+
+void CPlainTextConversionContext::DisplayText(
+	int 					inLocation,
+	LO_TextStruct*			inText,
+	XP_Bool 				inNeedBG)
+{
+	TXFE_DisplayText(*this, inLocation, inText, inNeedBG);
+}
+
+void CPlainTextConversionContext::DisplaySubDoc(
+	int 					inLocation,
+	LO_SubDocStruct*		inSubdocStruct)
+{
+	TXFE_DisplaySubDoc(*this, inLocation, inSubdocStruct);
+}
+
+void CPlainTextConversionContext::DisplayTable(
+	int 					inLocation,
+	LO_TableStruct*			inTableStruct)
+{
+	TXFE_DisplayTable(*this, inLocation, inTableStruct);
+}
+
+void CPlainTextConversionContext::DisplayLineFeed(
+	int 					inLocation,
+	LO_LinefeedStruct*		inLinefeedStruct,
+	XP_Bool 				inNeedBG)
+{
+	TXFE_DisplayLineFeed(*this, inLocation, inLinefeedStruct, inNeedBG);
+}
+
+void CPlainTextConversionContext::DisplayHR(
+	int 					inLocation,
+	LO_HorizRuleStruct*		inRuleStruct)
+{
+	TXFE_DisplayHR(*this, inLocation, inRuleStruct);
+}
+
+char* CPlainTextConversionContext::TranslateISOText(
+	int 					inCharset,
+	char*					inISOText)
+{
+	return TXFE_TranslateISOText(*this, inCharset, inISOText);
+}
+
+void CPlainTextConversionContext::DisplayBullet(
+	int 					inLocation,
+	LO_BullettStruct*		inBulletStruct)
+{
+	TXFE_DisplayBullet(*this, inLocation, inBulletStruct);
+}
+
+void CPlainTextConversionContext::FinishedLayout(void)
+{
+	TXFE_FinishedLayout(*this);
+}
+
+int CPlainTextConversionContext::GetTextInfo(
+	LO_TextStruct*			inText,
+	LO_TextInfo*			inTextInfo)
+{
+	return TXFE_GetTextInfo(*this, inText, inTextInfo);
+}
+
+int CPlainTextConversionContext::MeasureText(
+	LO_TextStruct*			/*inText*/,
+	short*					/*outCharLocs*/)
+{
+	return 0;
+}
+
+void CPlainTextConversionContext::AllConnectionsComplete(void)
+{
+	if (mProgress)
+	{
+		mProgress->RemoveUser(this);
+		mProgress = NULL;
+	}
+	TXFE_AllConnectionsComplete(*this);
+	mUIContext->AllConnectionsComplete();
+	CNSContext::AllConnectionsComplete();
+}
+
+void CPlainTextConversionContext::GraphProgressInit(
+	URL_Struct*		inURL,
+	Int32			inContentLength)
+{
+	try {
+		Assert_(mUIContext != NULL);
+		if (mUIContext && mUIContext->GetContextProgress())
+			mProgress = mUIContext->GetContextProgress();
+		else
+		{
+			mProgress = new CContextProgress;
+			mUIContext->SetContextProgress(mProgress);
+		}
+		mProgress->AddUser(this);
+	} catch (...) {
+		mProgress = NULL;
+	}
+	mUIContext->GraphProgressInit(inURL, inContentLength);
+}
+
+void CPlainTextConversionContext::Progress(const char* inMessageText )
+{
+	Assert_(mUIContext != NULL);
+	mUIContext->Progress(inMessageText);
+}
+
+void CPlainTextConversionContext::GraphProgressDestroy(
+	URL_Struct*		inURL,
+	Int32 			inContentLength,
+	Int32 			inTotalRead)
+{
+	Assert_(mUIContext != NULL);
+	mUIContext->GraphProgressDestroy(inURL, inContentLength, inTotalRead);
+}
+
+void CPlainTextConversionContext::GraphProgress(
+	URL_Struct*		inURL,
+	Int32			inBytesReceived,
+	Int32			inBytesSinceLast,
+	Int32			inContentLength)
+{
+	Assert_(mUIContext != NULL);
+	mUIContext->GraphProgress(inURL, inBytesReceived, inBytesSinceLast, inContentLength);
+}
+
+#pragma mark --- STUBS ---
+
+// FIX ME? Do we really wan't to override these methods?
+void CPlainTextConversionContext::Alert(const char* /* inAlertText */) {}
+XP_Bool CPlainTextConversionContext::Confirm(const char* /* inMessage */) { return false; }
+char* CPlainTextConversionContext::Prompt(
+	const char* /* inMessage */,
+	const char* /* inDefaultText */) { return NULL; }
+XP_Bool CPlainTextConversionContext::PromptUsernameAndPassword(
+	const char* /* inMessage */,
+	char** /* outUserName */,
+	char** /* outPassword */) { return false; }
+char* CPlainTextConversionContext::PromptPassword(const char* /* inMessage */) { return NULL; }

mozilla/cmd/macfe/central/CPlainTextConversionContext.h

@@ -0,0 +1,133 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// CPlainTextConversionContext.h
+
+//	This is a subclass of CNSContext to handle plain text translation.
+//	This replaces code in ns/lib/xlate/text.c where a new text MWContext is
+//	created.
+
+#pragma once
+
+#include "CNSContext.h"
+
+class CPlainTextConversionContext : public CNSContext
+{
+public:
+					CPlainTextConversionContext(MWContext* inUIContext);
+	virtual			~CPlainTextConversionContext() { }
+
+protected:
+	// Overrides of base CNSContext methods
+
+	virtual	void 				LayoutNewDocument(
+										URL_Struct*				inURL,
+										Int32*					inWidth,
+										Int32*					inHeight,
+										Int32*					inMarginWidth,
+										Int32*					inMarginHeight);
+
+	virtual	void 				DisplaySubtext(
+										int 					inLocation,
+										LO_TextStruct*			inText,
+										Int32 					inStartPos,
+										Int32					inEndPos,
+										XP_Bool 				inNeedBG);
+
+	virtual	void 				DisplayText(
+										int 					inLocation,
+										LO_TextStruct*			inText,
+										XP_Bool 				inNeedBG);
+
+	virtual	void 				DisplaySubDoc(
+										int 					inLocation,
+										LO_SubDocStruct*		inSubdocStruct);
+
+	virtual	void 				DisplayTable(
+										int 					inLocation,
+										LO_TableStruct*			inTableStruct);
+
+	virtual	void 				DisplayLineFeed(
+										int 					inLocation,
+										LO_LinefeedStruct*		inLinefeedStruct,
+										XP_Bool 				inNeedBG);
+
+	virtual	void 				DisplayHR(
+										int 					inLocation,
+										LO_HorizRuleStruct*		inRuleStruct);
+
+	virtual	char* 				TranslateISOText(
+										int 					inCharset,
+										char*					inISOText);
+
+	virtual	int 				GetTextInfo(
+										LO_TextStruct*			inText,
+										LO_TextInfo*			inTextInfo);
+
+	virtual	int 				MeasureText(
+										LO_TextStruct*			inText,
+										short*					outCharLocs);
+										
+	virtual	void 				DisplayBullet(
+										int 					inLocation,
+										LO_BulletStruct*		inBulletStruct);
+
+	virtual	void 				FinishedLayout(void);
+
+	virtual	void 				AllConnectionsComplete(void);
+
+	virtual	void 				Progress(
+										const char*				inMessageText);
+
+	virtual	void 				GraphProgressInit(
+										URL_Struct*				inURL,
+										Int32 					inContentLength);
+
+	virtual	void 				GraphProgressDestroy(
+										URL_Struct*				inURL,
+										Int32 					inContentLength,
+										Int32 					inTotalRead);
+
+	virtual	void 				GraphProgress(
+										URL_Struct*				inURL,
+										Int32 					inBytesReceived,
+										Int32 					inBytesSinceLast,
+										Int32 					inContentLength);
+
+	// Methods to stub out.
+
+		virtual	void 				Alert(
+											const char*				inAlertText);
+
+		virtual	XP_Bool				Confirm(
+											const char* 			inMessage);
+
+		virtual	char* 				Prompt(
+											const char* 			inMessage,
+											const char*				inDefaultText);
+
+		virtual	XP_Bool 			PromptUsernameAndPassword(
+											const char*				inMessage,
+											char**					outUserName,
+											char**					outPassword);
+
+		virtual	char* 				PromptPassword(
+											const char* 			inMessage);
+
+		CNSContext*					mUIContext;
+};

mozilla/cmd/macfe/central/CProxyDragTask.cp

@@ -0,0 +1,205 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CProxyDragTask.cp
+
+
+#include "CProxyDragTask.h"
+
+#include <LDragAndDrop.h>
+#include <UException.h>
+#include <UTextTraits.h>
+#include <UGAColorRamp.h>
+#include <LView.h>
+
+#include "CProxyPane.h"
+#include "StCaptureView.h"
+#include "CGWorld.h"
+#include "StRegionHandle.h"
+#include "CEnvironment.h"
+
+// ---------------------------------------------------------------------------
+//		¥ CProxyDragTask
+// ---------------------------------------------------------------------------
+
+CProxyDragTask::CProxyDragTask(
+	LView&					inProxyView,
+	CProxyPane&				inProxyPane,
+	LCaption&				inPageProxyCaption,
+	const EventRecord&		inEventRecord,
+	CExtraFlavorAdder*		inExtraFlavorAdder)
+	
+	:	mProxyView(inProxyView),
+		mProxyPane(inProxyPane),
+		mPageProxyCaption(inPageProxyCaption),
+		mExtraFlavorAdder(inExtraFlavorAdder),
+
+		Inherited(inEventRecord)
+{
+}
+
+// ---------------------------------------------------------------------------
+//		¥ ~CProxyDragTask
+// ---------------------------------------------------------------------------
+
+CProxyDragTask::~CProxyDragTask()
+{
+	delete mExtraFlavorAdder;
+}
+
+// ---------------------------------------------------------------------------
+//		¥ DoDrag
+// ---------------------------------------------------------------------------
+
+OSErr
+CProxyDragTask::DoDrag()
+{
+	MakeDragRegion(mDragRef, mDragRegion);
+	AddFlavors(mDragRef);
+	
+	if (UEnvironment::HasFeature(env_HasDragMgrImageSupport))
+	{
+		try
+		{
+			DoTranslucentDrag();
+		}
+		catch (...)
+		{
+			DoNormalDrag();
+		}
+	}
+	else
+	{
+		DoNormalDrag();
+	}
+	
+	return noErr;
+}
+
+// ---------------------------------------------------------------------------
+//		¥ DoNormalDrag
+// ---------------------------------------------------------------------------
+
+void
+CProxyDragTask::DoNormalDrag()
+{
+	::TrackDrag(mDragRef, &mEventRecord, mDragRegion);
+}
+
+// ---------------------------------------------------------------------------
+//		¥ DoTranslucentDrag
+// ---------------------------------------------------------------------------
+
+void
+CProxyDragTask::DoTranslucentDrag()
+{
+	Rect				theFrame;
+	StColorPortState	theColorPortState(mProxyView.GetMacPort());
+
+	// Normalize the color state (to make CopyBits happy)
+	
+	StColorState::Normalize();
+	
+	// Build a GWorld containing the page proxy icon and title
+
+	mProxyView.FocusDraw();
+		
+	mProxyView.CalcLocalFrameRect(theFrame);
+
+	CGWorld theGWorld(theFrame, 0, useTempMem);
+	StCaptureView theCaptureView(mProxyView);
+	
+	mPageProxyCaption.Show();
+
+	try
+	{
+		theCaptureView.Capture(theGWorld);
+
+		mProxyView.FocusDraw();
+
+	   	Point theOffsetPoint = topLeft(theFrame);
+		::LocalToGlobal(&theOffsetPoint);
+
+		// Set the drag image
+
+		StRegionHandle theTrackMask;
+
+		mProxyPane.CalcLocalFrameRect(theFrame);
+		ThrowIfOSErr_(::IconSuiteToRgn(theTrackMask, &theFrame, kAlignAbsoluteCenter, mProxyPane.GetIconSuiteH()));
+		
+		mPageProxyCaption.CalcLocalFrameRect(theFrame); // Use frame which bounds the actual text, not the frame bounds
+		theTrackMask += theFrame;
+		
+		PixMapHandle theMap = ::GetGWorldPixMap(theGWorld.GetMacGWorld());
+		OSErr theErr = ::SetDragImage(mDragRef, theMap, theTrackMask, theOffsetPoint, kDragDarkerTranslucency);
+		ThrowIfOSErr_(theErr);
+		
+		// Track the drag
+		
+		::TrackDrag(mDragRef, &mEventRecord, mDragRegion);
+	}
+	catch (...)
+	{
+	}
+	
+	mPageProxyCaption.Hide();
+}
+
+// ---------------------------------------------------------------------------
+//		¥ AddFlavorURL
+// ---------------------------------------------------------------------------
+	
+void
+CProxyDragTask::AddFlavors(DragReference inDragRef)
+{
+	Inherited::AddFlavors(inDragRef);
+	if (mExtraFlavorAdder)
+		mExtraFlavorAdder->AddExtraFlavorData(inDragRef, static_cast<ItemReference>(this));
+}
+
+// ---------------------------------------------------------------------------
+//		¥ MakeDragRegion
+// ---------------------------------------------------------------------------
+	
+void
+CProxyDragTask::MakeDragRegion(
+	DragReference			/*inDragRef*/,
+	RgnHandle				/*inDragRegion*/)
+{
+	Rect		theFrame;
+	
+	// Add the page proxy icon region
+	
+	StRegionHandle theTrackMask;
+
+	mProxyPane.CalcLocalFrameRect(theFrame);
+	ThrowIfOSErr_(::IconSuiteToRgn(theTrackMask, &theFrame, kAlignAbsoluteCenter, mProxyPane.GetIconSuiteH()));
+	theFrame = (**(RgnHandle)theTrackMask).rgnBBox;
+	::LocalToGlobal(&topLeft(theFrame));
+	::LocalToGlobal(&botRight(theFrame));
+	
+	AddRectDragItem(static_cast<ItemReference>(&mProxyPane), theFrame);
+	
+	// Add the page proxy caption region
+		
+	mPageProxyCaption.CalcLocalFrameRect(theFrame);
+	::LocalToGlobal(&topLeft(theFrame));
+	::LocalToGlobal(&botRight(theFrame));
+	
+	AddRectDragItem(static_cast<ItemReference>(&mPageProxyCaption), theFrame);
+}

mozilla/cmd/macfe/central/CProxyDragTask.h

@@ -0,0 +1,77 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CProxyDragTask.h
+
+
+#ifndef CProxyDragTask_H
+#define CProxyDragTask_H
+#pragma once
+
+// Includes
+
+#include "CBrowserDragTask.h"
+
+#include "CProxyPane.h"
+
+// Forward declarations
+
+class LView;
+class CProxyPane;
+class LCaption;
+
+// Class declaration
+
+class CExtraFlavorAdder // to be called by AddFlavor.  Allows a window to add extra flavors.
+{
+	public:
+		virtual void AddExtraFlavorData(DragReference inDragRef, ItemReference inItemRef) = 0;
+};
+
+class CProxyDragTask : public CBrowserDragTask
+{
+public:
+	typedef CBrowserDragTask Inherited;
+	
+							CProxyDragTask(
+											LView&					inProxyView,
+											CProxyPane&				inProxyPane,
+											LCaption&				inPageProxyCaption,
+											const EventRecord&		inEventRecord,
+											CExtraFlavorAdder*		inFlavorAdder = nil);
+	virtual	 				~CProxyDragTask();
+
+	virtual OSErr			DoDrag();
+	virtual void			AddFlavors(DragReference inDragRef);
+						
+protected:
+	virtual	void			DoNormalDrag();
+	virtual	void			DoTranslucentDrag();
+		
+	virtual void			MakeDragRegion(
+											DragReference			inDragRef,
+											RgnHandle				inDragRegion);
+
+	LView&					mProxyView;
+	CProxyPane&				mProxyPane;
+	LCaption&				mPageProxyCaption;
+	CExtraFlavorAdder*		mExtraFlavorAdder;
+};
+
+
+#endif

mozilla/cmd/macfe/central/CSaveProgress.cp

@@ -0,0 +1,125 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "CSaveProgress.h"
+#include "fe_proto.h"
+#include "CBrowserContext.h"
+#include "resgui.h"	// needed for EDITDLG_SAVE_PROGRESS
+#include "uapp.h"
+#include "edt.h"
+#include "PascalString.h"	// CStr255
+#include "proto.h"			// XP_InterruptContext
+#include "macutil.h"		// TrySetCursor
+
+
+#pragma mark CSaveProgress
+void CSaveProgress::FinishCreateSelf()
+{
+	fFilenameText = (LCaption*)this->FindPaneByID( 'flnm' );
+	LDialogBox::FinishCreateSelf();
+}
+
+
+void CSaveProgress::SetFilename(char *pFileName)
+{
+	if ( fFilenameText && pFileName )
+		fFilenameText->SetDescriptor( CStr255(pFileName) );
+}
+
+
+void CSaveProgress::ListenToMessage( MessageT inMessage, void* ioParam )
+{
+	switch ( inMessage )
+	{
+		case msg_Cancel:
+			if ( fContext )
+			{
+				TrySetCursor( watchCursor );
+			
+#ifdef EDITOR
+				if ( EDT_IS_EDITOR( fContext ) )
+					EDT_SaveCancel( fContext );
+				else
+#endif // EDITOR
+					XP_InterruptContext( fContext );
+				
+				SetCursor( &qd.arrow );
+			}
+			break;
+		
+		default:
+			LDialogBox::ListenToMessage( inMessage, ioParam );
+		break;
+	}
+}
+
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//
+#pragma mark --- FTP Upload Dialog ---
+//
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+// FIX ME -- find way to use new CDownloadProgressWindow
+// Most likely, we'll duplicate the code from downloading
+
+
+void FE_SaveDialogCreate( MWContext *pContext, int /*iFileCount*/, ED_SaveDialogType /*saveType*/ )
+{
+	try {
+		CSaveProgress * newWindow = (CSaveProgress*)LWindow::CreateWindow( 
+									EDITDLG_SAVE_PROGRESS, CFrontApp::GetApplication());
+		if ( newWindow == NULL )
+			return;
+		
+		UReanimator::LinkListenerToControls( newWindow, newWindow, EDITDLG_SAVE_PROGRESS );
+		
+		newWindow->SetContext( pContext );
+		ExtractBrowserContext(pContext)->SetSaveDialog( newWindow );
+
+		newWindow->Show();
+	}
+	
+	catch (...)
+	{
+		ExtractBrowserContext(pContext)->SetSaveDialog( NULL );
+	}
+}
+
+#ifdef EDITOR
+void FE_SaveDialogSetFilename( MWContext *pContext, char *pFilename )
+{
+	char *better = FE_URLToLocalName( pFilename );
+	if ( better )
+	{
+		if ( pContext && ExtractBrowserContext(pContext) && ExtractBrowserContext(pContext)->GetSaveDialog() )
+			ExtractBrowserContext(pContext)->GetSaveDialog()->SetFilename( better );	
+		
+		XP_FREE( better );
+	}
+}
+#endif // EDITOR
+
+void FE_SaveDialogDestroy( MWContext *pContext, int /*status*/, char */*pFilename*/ )
+{
+	if ( pContext && ExtractBrowserContext(pContext) && ExtractBrowserContext(pContext)->GetSaveDialog() ) 
+	{
+		ExtractBrowserContext(pContext)->GetSaveDialog()->ListenToMessage( cmd_Close, NULL );
+		ExtractBrowserContext(pContext)->SetSaveDialog( NULL );
+	}
+}
+

mozilla/cmd/macfe/central/CSaveProgress.h

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+#include "CNSContext.h"
+
+
+class CSaveProgress: public LDialogBox
+{
+public:
+	enum				{ class_ID = 'EDL4' };
+	
+						CSaveProgress( LStream* inStream ): LDialogBox( inStream ){};
+	
+	virtual void		FinishCreateSelf();
+	void				SetFilename( char *pFilename );
+	virtual void		ListenToMessage( MessageT inMessage, void* ioParam );
+	void				SetContext( MWContext* context ) {fContext = context;}
+
+protected:	
+	LCaption*			fFilenameText;
+	MWContext*			fContext;
+};
+

mozilla/cmd/macfe/central/CSecureAttachment.cp

@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// CSecureAttachment.cp
+
+#pragma once
+
+#include "CSecureAttachment.h"
+#include "xp_core.h"
+#include "secnav.h"
+#include "secrng.h"
+
+CSecureAttachment::CSecureAttachment()
+	:	LAttachment(msg_Event)
+{
+	mTickCounter = 0;
+}
+
+
+void CSecureAttachment::ExecuteSelf(
+	MessageT		/* inMessage */,
+	void			*ioParam)
+{
+	if (mTickCounter < 500)
+		{
+		EventRecord* theEvent = (EventRecord*)ioParam;
+		RNG_RandomUpdate(theEvent, sizeof(EventRecord));
+		long ticks = ::TickCount();
+		RNG_RandomUpdate(&ticks, sizeof(long));
+		mTickCounter++;
+		}
+	else
+		delete this;
+}
+

mozilla/cmd/macfe/central/CSecureAttachment.h

@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// CSecureAttachment.h
+
+//	Initializes the random seed of the security library.  Add  this
+//	attachment to application startup.
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+#pragma once
+
+#include <LAttachment.h>
+
+class CSecureAttachment : public LAttachment
+{
+	public:
+						CSecureAttachment();
+
+	protected:						
+
+		virtual void	ExecuteSelf(
+								MessageT		inMessage,
+								void			*ioParam);
+								
+		Uint32			mTickCounter;
+};
+

mozilla/cmd/macfe/central/CTSMEditField.cp

@@ -0,0 +1,282 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "CTSMEditField.h"
+
+
+Boolean						CTSMEditField::sInitialized 	= false;
+Boolean 					CTSMEditField::sHasTSM 				= false;
+TSMTEPreUpdateUPP	CTSMEditField::sPreUpdateUPP 	= NewTSMTEPreUpdateProc( CTSMEditField::PreUpdate );
+TSMTEPostUpdateUPP	CTSMEditField::sPostUpdateUPP 	= NewTSMTEPostUpdateProc( CTSMEditField::PostUpdate );
+
+
+//	Default constructor
+
+CTSMEditField::CTSMEditField ()
+{
+}	//	CTSMEditField::CTSMEditField
+
+CTSMEditField::CTSMEditField( LStream* inStream )
+
+	:	LEditField( inStream )
+
+	{
+
+		if ( !sInitialized )
+			Initialize();
+			
+		OSErr		result					= noErr;
+		OSType	theServiceTypes = kTSMTEInterfaceType;
+		
+		mTSMDocID = 0;
+		mTSMTEHandle = NULL;
+		
+
+		Try_ 
+			{
+			
+	  		if ( sHasTSM )
+	  			{
+	  			
+						result = ::NewTSMDocument( 1, &theServiceTypes, &mTSMDocID, static_cast<long>(&mTSMTEHandle) );
+						ThrowIfOSErr_( result );
+
+						if ( !mTSMTEHandle && mTSMDocID )
+							{
+							
+								::DeleteTSMDocument( mTSMDocID );
+								mTSMDocID = 0;
+								
+								Throw_( paramErr );
+							
+							}
+						
+						(*mTSMTEHandle)->textH = mTextEditH;
+						(*mTSMTEHandle)->preUpdateProc = sPreUpdateUPP;
+						(*mTSMTEHandle)->postUpdateProc = sPostUpdateUPP;
+						(*mTSMTEHandle)->updateFlag = kTSMTEAutoScroll;
+						(*mTSMTEHandle)->refCon = (Int32)this;
+								
+					}
+					
+			} 
+				
+		Catch_( inErr ) 
+			{
+			
+// Failure just means that this edit field won't support TSMTE
+	
+			} 
+			
+		EndCatch_;
+				
+	}
+
+//
+//	Parameterized constructor
+
+CTSMEditField::CTSMEditField (	const SPaneInfo&	inPaneInfo,
+										Str255				inString,
+										ResIDT				inTextTraitsID,
+										Int16					inMaxChars,
+										Uint8					inAttributes,
+										TEKeyFilterFunc		inKeyFilter,
+										LCommander*			inSuper)
+					: LEditField ( 	inPaneInfo, 
+									inString, 
+									inTextTraitsID,
+									inMaxChars, 
+									inAttributes,
+									inKeyFilter, 
+									inSuper )
+
+{
+}	//	CTSMEditField::CTSMEditField
+
+
+CTSMEditField::~CTSMEditField()
+	{
+	
+		OSErr	result = noErr;
+		
+		try
+			{
+			
+				if ( mTSMDocID != 0 )
+					{
+					
+						::FixTSMDocument( mTSMDocID );
+						::DeactivateTSMDocument( mTSMDocID ); //	for a bug in TSM.  See TE27
+						
+						result = ::DeleteTSMDocument( mTSMDocID );
+						Assert_( result == noErr );
+					
+						mTSMDocID = 0;
+						
+					}
+					
+			}
+			
+		catch ( ... )
+			{
+			
+			
+			}
+			
+	}
+
+
+pascal void 
+CTSMEditField::PreUpdate( TEHandle inTEHandle, Int32 inRefCon )
+	{
+	
+		CTSMEditField	*theOwnerEditField = NULL;
+
+		if ( inRefCon != NULL )
+			{
+					
+				theOwnerEditField = reinterpret_cast<CTSMEditField *>( inRefCon );
+			
+				theOwnerEditField->FocusDraw();
+				
+			}
+	
+	}
+
+
+pascal void
+CTSMEditField::PostUpdate( 
+	TEHandle inTEHandle, 
+	Int32 fixLen, 
+	Int32 inputAreaStart, 
+	Int32 inputAreaEnd, 
+	Int32 pinStart, 
+	Int32 pinEnd, 
+	Int32 inRefCon )
+	{
+	
+		CTSMEditField	*theOwnerEditField = NULL;
+
+		if ( inRefCon != NULL && fixLen > 0 )
+			{
+					
+				theOwnerEditField = reinterpret_cast<CTSMEditField *>( inRefCon );
+			
+				// Undo of TSM input is currently not supported.
+				//
+				if (theOwnerEditField->mTypingAction != NULL)
+					theOwnerEditField->mTypingAction->Reset();
+				
+			}
+	
+	}
+
+																			
+void CTSMEditField::BeTarget( void )
+	{
+
+		OSErr	result = noErr;
+		short	oldScript = ::GetScriptManagerVariable(smKeyScript);
+		
+		#ifdef Debug_Signal
+
+			OSErr	err;
+
+			//	check to see if a bug in TSM will be encountered
+			ProcessSerialNumber	psn,
+								csn;
+			err = GetCurrentProcess(&psn);
+			err = GetFrontProcess(&csn);
+			Assert_((psn.highLongOfPSN == csn.highLongOfPSN) && (psn.lowLongOfPSN == csn.lowLongOfPSN));
+		#endif
+
+		FocusDraw();
+		
+		LEditField::BeTarget();
+		
+		if ( mTSMDocID != NULL )	
+			{
+			
+				result = ::ActivateTSMDocument( mTSMDocID );
+				Assert_( result == noErr );
+				
+			}
+			
+
+	if (oldScript != ::GetScriptManagerVariable(smKeyScript))
+		::KeyScript(oldScript);
+	}
+
+
+void 
+CTSMEditField::DontBeTarget( void )
+	{
+	
+		OSErr	result = noErr;
+		
+		FocusDraw();
+		
+		if ( mTSMDocID != NULL )
+			{
+			
+				::FixTSMDocument( mTSMDocID );
+				
+				result = ::DeactivateTSMDocument( mTSMDocID );
+				Assert_( result == noErr );
+				
+			}
+			
+		LEditField::DontBeTarget();
+	
+	}
+	
+
+void
+CTSMEditField::Initialize()
+	{
+	
+		OSErr		result						= noErr;
+		SInt32	gestaltResponse		= 0;
+		
+		Assert_( sInitialized == false );
+		
+		if ( sInitialized == false )
+			{
+			
+				sInitialized = true;
+				
+		 		result = ::Gestalt( gestaltTSMgrVersion, &gestaltResponse );
+		 	 	
+				if ( (result == noErr) && (gestaltResponse >= 1) ) 
+					{
+						
+						result = ::Gestalt( gestaltTSMTEAttr, &gestaltResponse );
+				
+						if ( (result == noErr) && ((gestaltResponse >> gestaltTSMTEPresent) & 1) )	
+							{
+							
+								sHasTSM = true;
+								
+							}
+							
+					}
+					
+			}
+	
+	}
+	

mozilla/cmd/macfe/central/CTSMEditField.h

@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#pragma once
+
+
+#include <TextEdit.h>
+#include <TextServices.h>
+#include <TSMTE.h>
+#include <LEditField.h>
+
+
+class CTSMEditField : public LEditField
+	{
+	
+		public:
+
+			enum 
+				{
+					
+					class_ID = 'Tedt'
+					
+				};
+								
+			CTSMEditField();										//	¥ Default Constructor
+			CTSMEditField(	LStream		*inStream);					//	¥ Stream Constructor
+			CTSMEditField		(	const SPaneInfo&	inPaneInfo,
+										Str255			inString,
+										ResIDT			inTextTraitsID,
+										Int16			inMaxChars,
+										Uint8			inAttributes,
+										TEKeyFilterFunc	inKeyFilter,
+										LCommander*			inSuper);
+																	//	¥ Parameterized Constructor
+			virtual						~CTSMEditField();
+
+			static pascal void 	PreUpdate(			TEHandle 	inTEHandle,
+													Int32			inRefCon);
+			static pascal void	PostUpdate( 
+									TEHandle inTEHandle, 
+									Int32 fixLen, 
+									Int32 inputAreaStart, 
+									Int32 inputAreaEnd, 
+									Int32 pinStart, 
+									Int32 pinEnd, 
+									Int32 inRefCon );
+			Int16				GetMaxChars() const { return mMaxChars; } // Make it public.
+
+		protected:
+
+			virtual	void				BeTarget(void);
+			virtual void				DontBeTarget(void);
+
+			virtual void				Initialize();
+			
+			TSMDocumentID							mTSMDocID;
+			TSMTERecHandle						mTSMTEHandle;
+			
+			static Boolean						sInitialized;
+			static Boolean						sHasTSM;
+			static TSMTEPreUpdateUPP	sPreUpdateUPP;
+			static TSMTEPostUpdateUPP	sPostUpdateUPP;
+			
+	};

mozilla/cmd/macfe/central/CTargetedUpdateMenuRegistry.cp

@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CTargetedUpdateMenuRegistry.cp
+
+//
+//	CTargetedUpdateMenuRegistry is used in conjunction with LEventDispatchers
+//	which are CTargetedUpdateMenuRegistry-aware to enable a more targeted
+//	update of menus.
+//
+//	One common example of this is menu items whose text should change when
+//	certain modifiers are held down (Close -> Close All when optionKey is
+//	held down, for example).
+//
+//	Usage notes for callers of UpdateMenus:
+//
+//		(1) Call SetCommands with a list of commands which should be updated.
+//		(2) Call UpdateMenus.
+//
+//	Usage notes for implementors of UpdateMenus:
+//
+//		(1) When looping through commands in menus, determine if the registry
+//			is active by calling UseRegistryToUpdateMenus.
+//		(2) If the registry is active, then check to see if the command is
+//			in the registry by calling CommandInRegistry before processing
+//			command status for the command.
+//
+//	Note: For the targeted update to be useful, there should generally be
+//	a very small number of targeted commands. In fact, command lookup will
+//	slow down if there are too many commands.
+
+#include "CTargetedUpdateMenuRegistry.h"
+
+// === Static Members ===
+
+Boolean			CTargetedUpdateMenuRegistry::sUseRegistryToUpdateMenus = false;
+list<CommandT>	CTargetedUpdateMenuRegistry::sCommands;
+
+// ---------------------------------------------------------------------------
+//		¥ SetCommands
+// ---------------------------------------------------------------------------
+
+void
+CTargetedUpdateMenuRegistry::SetCommands(
+	const list<CommandT>& inCommands)
+{
+	sCommands = inCommands;
+}	
+
+// ---------------------------------------------------------------------------
+//		¥ UpdateMenus
+// ---------------------------------------------------------------------------
+
+void
+CTargetedUpdateMenuRegistry::UpdateMenus()
+{
+	if (LEventDispatcher::GetCurrentEventDispatcher())
+	{
+		StValueChanger<Boolean> setUseRegistryToUpdateMenus(sUseRegistryToUpdateMenus, true);
+	
+		LEventDispatcher::GetCurrentEventDispatcher()->UpdateMenus();
+	}
+}
+
+// ---------------------------------------------------------------------------
+//		¥ CommandInRegistry
+// ---------------------------------------------------------------------------
+
+Boolean
+CTargetedUpdateMenuRegistry::CommandInRegistry(CommandT inCommand)
+{
+	list<CommandT>::const_iterator theCommand = find(
+														sCommands.begin(),
+														sCommands.end(),
+														inCommand);
+	return (theCommand != sCommands.end());
+}

mozilla/cmd/macfe/central/CTargetedUpdateMenuRegistry.h

@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CTargetedUpdateMenuRegistry.h
+
+//
+//	CTargetedUpdateMenuRegistry is used in conjunction with LEventDispatchers
+//	which are CTargetedUpdateMenuRegistry-aware to enable a more targeted
+//	update of menus.
+//
+//	One common example of this is menu items whose text should change when
+//	certain modifiers are held down (Close -> Close All when optionKey is
+//	held down, for example).
+//
+//	Usage notes for callers of UpdateMenus:
+//
+//		(1) Call SetCommands with a list of commands which should be updated.
+//		(2) Call UpdateMenus.
+//
+//	Usage notes for implementors of UpdateMenus:
+//
+//		(1) When looping through commands in menus, determine if the registry
+//			is active by calling UseRegistryToUpdateMenus.
+//		(2) If the registry is active, then check to see if the command is
+//			in the registry by calling CommandInRegistry before processing
+//			command status for the command.
+//
+//	Note: For the targeted update to be useful, there should generally be
+//	a very small number of targeted commands. In fact, command lookup will
+//	slow down if there are too many commands.
+
+#ifndef	CTargetedUpdateMenuRegistry_H
+#define	CTargetedUpdateMenuRegistry_H
+#pragma once
+
+// Includes
+
+#include <list>
+#include <algorithm>
+
+#include <LCommander.h>
+#include <LEventDispatcher.h>
+
+// Class declaration
+
+class CTargetedUpdateMenuRegistry
+{
+public:
+	
+		// Interface for callers of UpdateMenus
+		
+	static void				SetCommands(const list<CommandT>& inCommands);
+	
+	static void				UpdateMenus();
+	
+		// Interface for implementors of UpdateMenus
+		
+	static Boolean			CommandInRegistry(CommandT inCommand);
+	
+	static Boolean			UseRegistryToUpdateMenus();
+	
+private:	
+	static Boolean			sUseRegistryToUpdateMenus;
+	static list<CommandT>	sCommands;
+};
+
+// Inline methods
+	
+inline
+Boolean
+CTargetedUpdateMenuRegistry::UseRegistryToUpdateMenus()
+{
+	return sUseRegistryToUpdateMenus;
+}
+
+#endif

mozilla/cmd/macfe/central/CURLDispatcher.cp

@@ -0,0 +1,867 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CURLDispatcher.cp
+
+
+#include "CURLDispatcher.h"
+#include "CNSContext.h"
+#include "CBrowserWindow.h"
+#include "CDownloadProgressWindow.h"
+#include "CWindowMediator.h"
+#include "CBrowserContext.h"
+#include "CBrowserWindow.h"
+#ifdef MOZ_MAIL_NEWS
+#include "CMailNewsWindow.h"
+#include "CThreadWindow.h"
+#include "CMessageWindow.h"
+#endif
+#include "URobustCreateWindow.h"
+#include "uapp.h"
+#include "CHTMLClickRecord.h"
+#include "CAutoPtr.h"
+#include "CAutoPtrXP.h"
+#include "cstring.h"
+
+#include "xp.h"
+#include "macutil.h"
+#include "umimemap.h"
+#include "ufilemgr.h"
+#include "uprefd.h"
+#include "xlate.h"
+#include "msv2dsk.h"
+#include "msgcom.h"
+#include "uerrmgr.h"		// Need for GetCString
+#include "resgui.h"
+
+CBrowserWindow* CURLDispatcher::sLastBrowserWindowCreated = NULL;
+CAutoPtr<CURLDispatcher> CURLDispatcher::sDispatcher;
+CAutoPtr<CBrowserContext> CURLDispatcher::sDispatchContext;
+
+// URL dispatch proc table
+// URL types listed in net.h are indices into this table.
+// **** NOTE: URL types in net.h start at 1 ****
+const Uint32 cNumURLTypes = 39;
+
+static DispatchProcPtr dispatchProcs[] =
+{
+	CURLDispatcher::DispatchToBrowserWindow		// Unknown URL type        0
+,	CURLDispatcher::DispatchToBrowserWindow		// FILE_TYPE_URL           1
+,	CURLDispatcher::DispatchToBrowserWindow		// FTP_TYPE_URL            2
+,	CURLDispatcher::DispatchToBrowserWindow		// GOPHER_TYPE_URL         3
+,	CURLDispatcher::DispatchToBrowserWindow		// HTTP_TYPE_URL           4
+,	CURLDispatcher::DispatchToLibNet			// MAILTO_TYPE_URL         5
+//,	CURLDispatcher::DispatchToMailNewsWindow	// NEWS_TYPE_URL           6
+,	CURLDispatcher::DispatchMailboxURL			// NEWS_TYPE_URL           6 (use mailbox code)
+,	NULL		// RLOGIN_TYPE_URL         7
+,	CURLDispatcher::DispatchToBrowserWindow		// TELNET_TYPE_URL         8
+,	CURLDispatcher::DispatchToBrowserWindow		// TN3270_TYPE_URL         9
+,	NULL		// WAIS_TYPE_URL           10
+,	CURLDispatcher::DispatchToBrowserWindow		// ABOUT_TYPE_URL          11
+,	NULL		// FILE_CACHE_TYPE_URL     12
+,	NULL		// MEMORY_CACHE_TYPE_URL   13
+,	CURLDispatcher::DispatchToBrowserWindow		// SECURE_HTTP_TYPE_URL    14
+,	NULL		// INTERNAL_IMAGE_TYPE_URL 15
+,	NULL		// URN_TYPE_URL            16
+,	NULL		// POP3_TYPE_URL           17
+,	CURLDispatcher::DispatchMailboxURL			// MAILBOX_TYPE_URL        18
+,	NULL		// INTERNAL_NEWS_TYPE_URL  19
+,	CURLDispatcher::DispatchToBrowserWindow		// SECURITY_TYPE_URL		20
+,	CURLDispatcher::DispatchToBrowserWindow		// MOCHA_TYPE_URL			21
+,	CURLDispatcher::DispatchToBrowserWindow		// VIEW_SOURCE_TYPE_URL	22
+,	NULL		// HTML_DIALOG_HANDLER_TYPE_URL 23
+,	NULL		// HTML_PANEL_HANDLER_TYPE_URL 24
+,	NULL		// INTERNAL_SECLIB_TYPE_URL 25
+,	NULL		// MSG_SEARCH_TYPE_URL     26
+,	CURLDispatcher::DispatchMailboxURL			// IMAP_TYPE_URL			27
+,	CURLDispatcher::DispatchToLibNet			// LDAP_TYPE_URL			28
+,	NULL		// SECURE_LDAP_TYPE_URL	29
+,	CURLDispatcher::DispatchToBrowserWindow		// WYSIWYG_TYPE_URL		30
+,	CURLDispatcher::DispatchToLibNet			// ADDRESS_BOOK_TYPE_URL	31
+,	NULL		// CLASSID_TYPE_URL		32
+,	NULL		// JAVA_TYPE_URL			33
+,	NULL		// DATA_TYPE_URL			34
+,	CURLDispatcher::DispatchToLibNet		// NETHELP_TYPE_URL		35
+,	NULL		// NFS_TYPE_URL		    36
+,	CURLDispatcher::DispatchToBrowserWindow		// MARIMBA_TYPE_URL	    37
+,	NULL		// INTERNAL_CERTLDAP_TYPE_URL 38
+};
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+CURLDispatcher* CURLDispatcher::GetURLDispatcher()	// singleton class
+{
+	if (!sDispatcher.get())
+	{
+		sDispatcher.reset(new CURLDispatcher);
+	}
+	
+	return sDispatcher.get();
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+CURLDispatcher::CURLDispatcher()
+	:	mDelayedURLs(sizeof(CURLDispatchInfo*))
+{
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+CURLDispatcher::~CURLDispatcher()
+{
+}
+
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchToStorage(
+	URL_Struct*				inURL,
+	const FSSpec&			inDestSpec,
+	FO_Present_Types		inOutputFormat,
+	Boolean					inDelay)
+{
+	Assert_((inOutputFormat == FO_SAVE_AS) || (inOutputFormat == FO_SAVE_AS_TEXT));
+	
+	if (!inDelay)
+		{
+		CURLDispatchInfo* dispatchInfo = 
+			new CURLDispatchInfo(inURL, nil, inOutputFormat, inDelay, false, true);
+		dispatchInfo->SetFileSpec(inDestSpec);
+		if (inOutputFormat == FO_SAVE_AS)
+		{
+			DispatchToDisk(dispatchInfo);
+		}
+		else
+			DispatchToDiskAsText(dispatchInfo);
+		}
+	else
+		{
+		CURLDispatchInfo* theDelay =
+			new CURLDispatchInfo(inURL, nil, inOutputFormat, true, false, true);
+		theDelay->SetFileSpec(inDestSpec);
+		GetURLDispatcher()->PostPendingDispatch(theDelay);
+		}
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchToStorage(CURLDispatchInfo* inDispatchInfo)
+{
+	Assert_((inDispatchInfo->GetOutputFormat() == FO_SAVE_AS) || (inDispatchInfo->GetOutputFormat() == FO_SAVE_AS_TEXT));
+	
+	if (!inDispatchInfo->GetDelay())
+		{
+		if (inDispatchInfo->GetOutputFormat() == FO_SAVE_AS)
+			DispatchToDisk(inDispatchInfo);
+		else
+			DispatchToDiskAsText(inDispatchInfo);
+		}
+	else
+		{
+		GetURLDispatcher()->PostPendingDispatch(inDispatchInfo);
+		}
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::SpendTime(const EventRecord& /*inMacEvent*/)
+{
+	if (mDelayedURLs.GetCount() > 0)
+		ProcessPendingDispatch();
+	else
+		StopIdling();
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+		
+void CURLDispatcher::ListenToMessage(
+	MessageT				inMessage,
+	void*					ioParam)
+{
+	if ((inMessage == msg_BroadcasterDied) && (mDelayedURLs.GetCount() > 0))
+		UpdatePendingDispatch((CNSContext*)ioParam);
+}
+
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+
+void CURLDispatcher::DispatchToDisk(CURLDispatchInfo* inDispatchInfo)
+{
+	CBrowserContext* theContext = NULL;
+	CDownloadProgressWindow* theProgressWindow = NULL;
+	FSSpec& destSpec = inDispatchInfo->GetFileSpec();
+	URL_Struct* inURL = inDispatchInfo->GetURLStruct();
+	
+	CAutoPtr<CURLDispatchInfo> info(inDispatchInfo);
+
+	Assert_(inURL != NULL);
+
+	try
+		{
+		theContext = new CBrowserContext(MWContextSaveToDisk);
+		StSharer theShareLock(theContext);
+		
+		theProgressWindow = dynamic_cast<CDownloadProgressWindow*>(URobustCreateWindow::CreateWindow(WIND_DownloadProgress, LCommander::GetTopCommander()));
+		ThrowIfNULL_(theProgressWindow);
+		theProgressWindow->Show();
+		
+		inURL->fe_data = StructCopy(&destSpec, sizeof(FSSpec));
+		theProgressWindow->SetWindowContext(theContext);
+		// the window will be shown on the first progress call.
+		
+		theContext->ImmediateLoadURL(inDispatchInfo->ReleaseURLStruct(), FO_SAVE_AS);
+		}
+	catch (...)
+		{
+		delete theProgressWindow;		
+		throw;
+		}
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+
+extern "C" void SaveAsCompletionProc( PrintSetup* p );
+
+
+void CURLDispatcher::DispatchToDiskAsText(CURLDispatchInfo* inDispatchInfo)
+{
+	
+	CNSContext* theContext = NULL;
+	CDownloadProgressWindow* theProgressWindow = NULL;
+	FSSpec& destSpec = inDispatchInfo->GetFileSpec();
+	URL_Struct* inURL = inDispatchInfo->GetURLStruct();
+	
+	Assert_(inURL != NULL);
+
+	try
+	{
+		theContext = new CNSContext(MWContextSaveToDisk);
+		StSharer theShareLock(theContext);
+		
+		theProgressWindow = dynamic_cast<CDownloadProgressWindow*>(URobustCreateWindow::CreateWindow(WIND_DownloadProgress, LCommander::GetTopCommander()));
+		ThrowIfNULL_(theProgressWindow);
+		theProgressWindow->SetWindowContext(theContext);
+		
+		CMimeMapper *theMapper = CPrefs::sMimeTypes.FindMimeType(CMimeList::HTMLViewer);
+		OSType creator = emSignature, docType='TEXT';
+		if (theMapper != NULL && CMimeMapper::Launch == theMapper->GetLoadAction())
+		{
+			creator = theMapper->GetAppSig();
+			docType = theMapper->GetDocType();
+		}
+		
+		OSErr theErr = ::FSpCreate(&destSpec, creator, docType, 0);
+		if ((theErr != noErr) && (theErr != dupFNErr))
+			ThrowIfOSErr_(theErr);
+		
+		CFileMgr::FileSetComment(destSpec, NET_URLStruct_Address(inURL));
+		
+		char* thePath = CFileMgr::EncodedPathNameFromFSSpec(destSpec, TRUE);
+		ThrowIfNULL_(thePath);
+		
+		thePath = NET_UnEscape(thePath);
+		XP_File theFile = XP_FileOpen(thePath, xpURL, XP_FILE_WRITE);
+		XP_FREE(thePath);
+		ThrowIfNULL_(theFile);
+		
+		PrintSetup print;
+		XL_InitializeTextSetup(&print);
+		print.width = 76;
+		print.out = theFile;
+		print.completion = (XL_CompletionRoutine) SaveAsCompletionProc;
+		print.carg = (void*)(theContext);
+		print.filename = nil;
+		print.url = inURL;
+		inURL->fe_data = theContext;
+		
+		MWContext* textContext = (MWContext*) XL_TranslateText(*theContext, inURL, &print);
+	}
+	catch(...)
+	{
+	}
+}
+
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::PostPendingDispatch(CURLDispatchInfo* inDispatchInfo)
+{
+	mDelayedURLs.InsertItemsAt(1, LArray::index_Last, &inDispatchInfo, sizeof(CURLDispatchInfo*));
+	StartIdling();
+	if (inDispatchInfo->GetTargetContext() != NULL)
+		inDispatchInfo->GetTargetContext()->AddListener(this);
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::UpdatePendingDispatch(
+	CNSContext*				inForContext)
+{
+	Assert_(inForContext != NULL);
+	
+	CURLDispatchInfo* theInfo;
+	LArrayIterator theIter(mDelayedURLs, LArrayIterator::from_Start);
+	while (theIter.Next(&theInfo))
+		{
+		if (theInfo->GetTargetContext() == inForContext)
+			mDelayedURLs.RemoveItemsAt(1, theIter.GetCurrentIndex());
+		}
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::ProcessPendingDispatch(void)
+{
+	if (CFrontApp::GetApplication()->HasProperlyStartedUp())
+	{
+		CURLDispatchInfo* theInfo;
+		mDelayedURLs.FetchItemAt(LArray::index_First, &theInfo);
+		// 97-06-10 pkc -- Hack to workaround trying to dispatch URL's on image
+		// anchors while mocha is loading image
+		CBrowserContext* browserContext =
+			dynamic_cast<CBrowserContext*>(theInfo->GetTargetContext());
+		if (theInfo->GetIsWaitingForMochaImageLoad() &&
+			theInfo->GetTargetContext())
+		{
+			if (browserContext && browserContext->IsMochaLoadingImages())
+			{
+				// The context is loading images for mocha, don't
+				// perform dispatch
+				return;
+			}
+		}
+		mDelayedURLs.RemoveItemsAt(1, LArray::index_First);
+		
+		if (theInfo->GetTargetContext() != NULL)
+			theInfo->GetTargetContext()->RemoveListener(this);
+
+		theInfo->ClearDelay();
+
+		if (theInfo->GetIsSaving())
+			DispatchToStorage(theInfo);
+		else
+		{
+			// See if this delayed URL was for an ftp drag &drop
+			if (theInfo->GetURLStruct()->files_to_post)
+			{
+				// See if the user really meant to upload
+				if (browserContext && !browserContext->Confirm((const char*)GetCString(MAC_UPLOAD_TO_FTP))) /* l10n */
+				{
+					// Delete the info if not
+					delete theInfo;
+				}
+				else
+				{
+					// Ship it!
+					DispatchURL(theInfo);
+				}
+			}
+			else
+			{
+				// Plain ordinary delayed URL
+				DispatchURL(theInfo);
+			}
+		}
+	}
+}
+
+
+// 97-05-13 pkc
+// New URL dispatch mechanism.
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchURL(
+	const char*				inURL,
+	CNSContext*				inTargetContext,
+	Boolean					inDelay,
+	Boolean					inForceCreate,
+	ResIDT					inWindowResID,
+	Boolean					inInitiallyVisible,
+	FO_Present_Types		inOutputFormat,
+	NET_ReloadMethod		inReloadMethod)
+{
+	CURLDispatchInfo* dispatchInfo =
+		new CURLDispatchInfo(
+			inURL,
+			inTargetContext,
+			inOutputFormat,
+			inReloadMethod,
+			inDelay,
+			inForceCreate,
+			false,
+			inWindowResID,
+			inInitiallyVisible
+			);
+	DispatchURL(dispatchInfo);
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchURL(
+	URL_Struct*				inURLStruct,
+	CNSContext*				inTargetContext,
+	Boolean					inDelay,
+	Boolean					inForceCreate,
+	ResIDT					inWindowResID,
+	Boolean					inInitiallyVisible,
+	FO_Present_Types		inOutputFormat,
+	Boolean					inWaitingForMochaImageLoad)
+{
+	CURLDispatchInfo* dispatchInfo =
+		new CURLDispatchInfo(
+			inURLStruct,
+			inTargetContext,
+			inOutputFormat,
+			inDelay,
+			inForceCreate,
+			false,
+			inWindowResID,
+			inInitiallyVisible,
+			inWaitingForMochaImageLoad
+			);
+	DispatchURL(dispatchInfo);
+}
+
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchURL(CURLDispatchInfo* inDispatchInfo)
+{
+	XP_ASSERT(inDispatchInfo != NULL);
+
+	// FIX ME??? Does this go here?
+	sLastBrowserWindowCreated = NULL;
+	
+	// paranoia
+	if (inDispatchInfo)
+	{
+		if (inDispatchInfo->GetDelay())
+		{
+			GetURLDispatcher()->PostPendingDispatch(inDispatchInfo);
+		}
+		// Check to make sure URL type index is within dispatch table bounds
+		else if (inDispatchInfo->GetURLType() < cNumURLTypes)
+		{ 
+			// Get dispatch proc from table
+			DispatchProcPtr dispatchProc = dispatchProcs[inDispatchInfo->GetURLType()];
+			if (dispatchProc)
+			{
+				(*dispatchProc)(inDispatchInfo);
+			}
+		}
+	}
+}
+
+#pragma mark -- Dispatch Procs --
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchToLibNet(CURLDispatchInfo* inDispatchInfo)
+{
+	CAutoPtr<CURLDispatchInfo> info(inDispatchInfo);
+	// If someone passed in a context, use it.
+	if (inDispatchInfo->GetTargetContext())
+	{
+		inDispatchInfo->GetTargetContext()->ImmediateLoadURL(inDispatchInfo->ReleaseURLStruct(), inDispatchInfo->GetOutputFormat());
+	}
+	else
+	{
+		try
+		{
+			if (!sDispatchContext.get())
+			{
+				sDispatchContext.reset(new CBrowserContext());
+			}
+			sDispatchContext->ImmediateLoadURL(inDispatchInfo->ReleaseURLStruct(), inDispatchInfo->GetOutputFormat());
+		}
+		catch (...)
+		{
+		}
+	}
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchToBrowserWindow(CURLDispatchInfo* inDispatchInfo)
+{
+	CAutoPtr<CURLDispatchInfo> info(inDispatchInfo);
+	if (!inDispatchInfo->GetDelay())
+	{
+		if (inDispatchInfo->GetForceCreate())
+		{
+			// Must create a new window
+			DispatchToNewBrowserWindow(info.release());
+		}
+		else if (inDispatchInfo->GetTargetContext())
+		{
+			// Use target context if passed in
+			// 97-09-18 pchen -- use target if it's not "_self"
+			// I found "_current" in npglue.c; do we need to filter that also?
+			if (inDispatchInfo->GetURLStruct()->window_target &&
+				XP_STRCASECMP(inDispatchInfo->GetURLStruct()->window_target, "_self"))
+			{
+				/* The thinking here is that if the URL specifies a preferred window target,
+				   it's not safe to use the given context.  There is a known case where
+				   this is so; it involves a link in a subframe which links to an image
+				   and contains a "target" tag.  In this case, we use the only context
+				   always known to be safe: the one belonging to the window itself.
+				   This is precisely correct if the tag is "target = _top".  I feel
+				   queasy guaranteeing that it's correct for other values of target
+				   as well, but pchen thinks it will always work.  So: */
+				CBrowserContext	*topContext;
+				topContext = ExtractBrowserContext(*inDispatchInfo->GetTargetContext());
+				inDispatchInfo->SetTargetContext(topContext->GetTopContext());
+			}
+			(inDispatchInfo->GetTargetContext())->SwitchLoadURL(inDispatchInfo->ReleaseURLStruct(), inDispatchInfo->GetOutputFormat());
+		}
+		else
+		{
+			// Find topmost "regular" browser window and dispatch into that window
+			CWindowMediator* theMediator = CWindowMediator::GetWindowMediator();
+			CBrowserWindow* theTopWindow =
+				dynamic_cast<CBrowserWindow*>(theMediator->FetchTopWindow(WindowType_Browser, regularLayerType, false));
+			if (theTopWindow)
+			{
+				theTopWindow->Select();
+				CNSContext* theCurrentContext = theTopWindow->GetWindowContext();
+				theCurrentContext->SwitchLoadURL(inDispatchInfo->ReleaseURLStruct(), inDispatchInfo->GetOutputFormat());
+			}
+			else
+			{
+				// No "regular" browser window available, so create one
+				DispatchToNewBrowserWindow(info.release());
+			}
+		}
+	}
+	else
+	{
+		GetURLDispatcher()->PostPendingDispatch(info.release());
+	}
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchMailboxURL(CURLDispatchInfo* inDispatchInfo)
+{
+#ifdef MOZ_MAIL_NEWS
+	const char* urlAddress = inDispatchInfo->GetURL();
+	
+	// Test to see if this is an attachment URL
+	if (XP_STRSTR(urlAddress, "?part=") || XP_STRSTR(urlAddress, "&part="))
+	{
+		// This is a mail attachment, dispatch to browser window
+  		CURLDispatcher::DispatchToBrowserWindow(inDispatchInfo);
+	}
+	else if (inDispatchInfo->GetForceCreate())
+	{
+		CMessageWindow::OpenFromURL (urlAddress);
+		/* note: we can't handle an internal link (as in the clause just below), so
+		   we don't bother trying. Just load the message and let the user ask again
+		   once that's completed, if it's really important to go to an internal link. */
+	}
+	else if (XP_STRCHR(urlAddress, '#'))
+	{
+		// 97-06-08 pkc -- handle internal links here
+		if (inDispatchInfo->GetTargetContext())
+			inDispatchInfo->GetTargetContext()->SwitchLoadURL(
+				inDispatchInfo->ReleaseURLStruct(),
+				inDispatchInfo->GetOutputFormat());
+	}
+	else
+	{
+		// Otherwise, call DispatchToMailNewsWindow
+		DispatchToMailNewsWindow(inDispatchInfo);
+	}
+#endif // MOZ_MAIL_NEWS
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchToMailNewsWindow(CURLDispatchInfo* inDispatchInfo)
+{
+#ifdef MOZ_MAIL_NEWS
+	CAutoPtr<CURLDispatchInfo> info(inDispatchInfo);
+	CAutoPtrXP<char> url(XP_STRDUP(inDispatchInfo->GetURL()));
+	
+	const char* urlAddress = url.get();
+
+	// Otherwise, call CMessageWindow::OpenFromURL
+	switch (MSG_PaneTypeForURL(urlAddress))
+	{
+		case MSG_MAILINGLISTPANE:
+			// ? Open a list window to allow editing of this list?  
+			// Ask someone.  Phil?  Michelle?
+			break;
+			
+		case MSG_ADDRPANE:
+			// Can't happen, MSG_PaneTypeForURL doesn't return this type,  
+			// but a future release should, and MSG_NewWindowRequired should
+			// then return true.
+			break;
+			
+		case MSG_FOLDERPANE:
+			CMailNewsFolderWindow::FindAndShow(true);				
+			break;
+			
+		case MSG_THREADPANE:
+			CThreadWindow::OpenFromURL(urlAddress);
+			break;
+			
+		case MSG_MESSAGEPANE:
+			CMessageWindow::OpenFromURL((char*)urlAddress);
+			break;
+			
+		case MSG_SUBSCRIBEPANE:
+			// Can't happen, MSG_PaneTypeForURL doesn't return this type,  
+			// but a future release should, and MSG_NewWindowRequired should
+			// then return true.
+			// CSubscribePane::FindAndShow();
+			break;
+		
+		case MSG_ANYPANE:	// this gets returned for most URLs
+			
+		case MSG_COMPOSITIONPANE:
+			// presumably, this is from a mailto:, and we handle this already, below.
+		case MSG_SEARCHPANE:
+			// Already handled below.
+		default:
+			break;
+	}
+#endif // MOZ_MAIL_NEWS
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+void CURLDispatcher::DispatchToNewBrowserWindow(CURLDispatchInfo* inDispatchInfo)
+{
+	CAutoPtr<CURLDispatchInfo> info(inDispatchInfo);
+	CBrowserWindow* theBrowserWindow = NULL;
+	CNSContext* theContext = NULL;
+	URL_Struct* theURLStruct = inDispatchInfo->GetURLStruct();
+	
+	XP_ASSERT(inDispatchInfo != NULL);
+	if (inDispatchInfo)
+	{
+		theBrowserWindow = CreateNewBrowserWindow(inDispatchInfo->GetWindowResID(), false);
+		if (theBrowserWindow)
+		{
+			theContext = theBrowserWindow->GetWindowContext();
+			if (theURLStruct != nil)
+			{
+				if (theURLStruct->window_target && theURLStruct->window_target[0] != '_')
+					{
+					// ¥ do not assign special names
+					theContext->SetDescriptor(theURLStruct->window_target);
+					}
+				if (theURLStruct->window_target)
+					theURLStruct->window_target[0] = 0;
+				theContext->ImmediateLoadURL(inDispatchInfo->ReleaseURLStruct(), inDispatchInfo->GetOutputFormat());
+			}
+			if (inDispatchInfo->GetInitiallyVisible()) theBrowserWindow->Show();
+		}
+	}
+}
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+CBrowserWindow* CURLDispatcher::CreateNewBrowserWindow(
+	ResIDT inWindowResID,
+	Boolean inInitiallyVisible)
+{
+	CBrowserWindow* theBrowserWindow = NULL;
+	CBrowserContext* theContext = NULL;
+	
+	try
+	{
+		theContext = new CBrowserContext();
+		StSharer theShareLock(theContext);
+		
+		theBrowserWindow =
+			dynamic_cast<CBrowserWindow*>(URobustCreateWindow::CreateWindow(inWindowResID, LCommander::GetTopCommander()));
+		ThrowIfNULL_(theBrowserWindow);
+
+		theBrowserWindow->SetWindowContext(theContext);
+		sLastBrowserWindowCreated = theBrowserWindow;
+		if (inInitiallyVisible)
+			theBrowserWindow->Show();
+	}
+	catch (...)
+	{
+		delete theBrowserWindow;
+		throw;
+	}
+	
+	return theBrowserWindow;
+}
+
+#pragma mark -
+
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+//	¥	
+// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
+
+CURLDispatchInfo::CURLDispatchInfo()
+	:	mURLType(HTTP_TYPE_URL),
+		mURLStruct(NULL),
+		mTargetContext(NULL),
+		mOutputFormat(NET_DONT_RELOAD),
+		mDelayDispatch(false),
+		mIsSaving(false),
+		mForceCreate(false),
+		mInitiallyVisible(true),
+		mIsWaitingForMochaImageLoad(false),
+		mWindowResID(1010)
+{
+}
+
+CURLDispatchInfo::CURLDispatchInfo(
+	const char*				inURL,
+	CNSContext*				inTargetContext,
+	FO_Present_Types		inOutputFormat,
+	NET_ReloadMethod		inReloadMethod,
+	Boolean					inDelay,
+	Boolean					inForceCreate,
+	Boolean					inIsSaving,
+	ResIDT					inWindowResID,
+	Boolean					inInitiallyVisible)
+	:	mTargetContext(NULL),
+		mOutputFormat(inOutputFormat),
+		mDelayDispatch(inDelay),
+		mForceCreate(inForceCreate),
+		mIsSaving(inIsSaving),
+		mInitiallyVisible(inInitiallyVisible),
+		mIsWaitingForMochaImageLoad(false),
+		mWindowResID(inWindowResID)
+{
+	mURLStruct = NET_CreateURLStruct(inURL, inReloadMethod);
+	if (inTargetContext)
+	{
+		cstring theReferer = inTargetContext->GetCurrentURL();
+		if (theReferer.length() > 0)
+			mURLStruct->referer = XP_STRDUP(theReferer);
+		mTargetContext = inTargetContext;
+	}
+	mURLType = NET_URL_Type(inURL);
+}
+
+CURLDispatchInfo::CURLDispatchInfo(
+	URL_Struct*				inURLStruct,
+	CNSContext*				inTargetContext,
+	FO_Present_Types		inOutputFormat,
+	Boolean					inDelay,
+	Boolean					inForceCreate,
+	Boolean					inIsSaving,
+	ResIDT					inWindowResID,
+	Boolean					inInitiallyVisible,
+	Boolean					inWaitingForMochaImageLoad)
+	:	mURLStruct(inURLStruct),
+		mTargetContext(inTargetContext),
+		mOutputFormat(inOutputFormat),
+		mDelayDispatch(inDelay),
+		mForceCreate(inForceCreate),
+		mIsSaving(inIsSaving),
+		mInitiallyVisible(inInitiallyVisible),
+		mIsWaitingForMochaImageLoad(inWaitingForMochaImageLoad),
+		mWindowResID(inWindowResID)
+{
+	if (inTargetContext && mURLStruct->referer == NULL)
+	{
+		cstring theReferer = inTargetContext->GetCurrentURL();
+		if (theReferer.length() > 0)
+			mURLStruct->referer = XP_STRDUP(theReferer);
+		mTargetContext = inTargetContext;
+	}
+	if (inURLStruct)
+		mURLType = NET_URL_Type(NET_URLStruct_Address(inURLStruct));
+	else
+		mURLType = 0;
+}
+
+CURLDispatchInfo::~CURLDispatchInfo()
+{
+	if (mURLStruct)
+	{
+		NET_FreeURLStruct(mURLStruct);
+	}
+}
+
+URL_Struct* CURLDispatchInfo::ReleaseURLStruct()
+{
+	URL_Struct* url = mURLStruct;
+	mURLStruct = NULL;
+	return url;
+}
+
+char* CURLDispatchInfo::GetURL()
+{
+	if (mURLStruct)
+		return NET_URLStruct_Address(mURLStruct);
+	else
+		return NULL;
+}
+
+void CURLDispatchInfo::SetFileSpec(const FSSpec& inFileSpec)
+{
+	mFileSpec = inFileSpec;
+}

mozilla/cmd/macfe/central/CURLDispatcher.h

@@ -0,0 +1,210 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//	CURLDispatcher.h
+
+
+#ifndef CURLDispatcher_H
+#define CURLDispatcher_H
+#pragma once
+
+#include <LPeriodical.h>
+#include <LListener.h>
+
+#include "structs.h"
+#include "CAutoPtr.h"
+#include "ntypes.h"
+#include "net.h" // for FO_CACHE_AND_PRESENT
+
+class CNSContext;
+class CBrowserContext;
+class CBrowserWindow;
+
+class CURLDispatchInfo;
+
+// Dispatch function prototype
+
+const ResIDT BrowserWindow_ResID = 1010;
+
+typedef void (*DispatchProcPtr)(CURLDispatchInfo* inDispatchInfo);
+
+class CURLDispatcher : 
+	public LPeriodical,
+	public LListener
+{
+	public:
+	
+		static void				DispatchToStorage(
+										URL_Struct*				inURL,
+										const FSSpec&			inDestSpec,
+										FO_Present_Types		inOutputFormat = FO_SAVE_AS,
+										Boolean					inDelay = false);
+		
+		static void				DispatchToStorage(CURLDispatchInfo* inDispatchInfo);
+		
+		
+		virtual	void			SpendTime(const EventRecord&	inMacEvent);
+		
+		virtual void			ListenToMessage(
+										MessageT				inMessage,
+										void*					ioParam);
+						
+		static Uint32 			CountDelayedURLs() { return GetURLDispatcher()->GetCountDelayedURLs(); }
+		
+		// 97-05-13 pkc -- New URL dispatch mechanism
+		
+		static void					DispatchURL(
+										const char*				inURL,
+										CNSContext*				inTargetContext,
+										Boolean					inDelay = false,
+										Boolean					inForceCreate = false,
+										ResIDT					inWindowResID = BrowserWindow_ResID,
+										Boolean					inInitiallyVisible = true,
+										FO_Present_Types		inOutputFormat = FO_CACHE_AND_PRESENT,
+										NET_ReloadMethod		inReloadMethod = NET_DONT_RELOAD);
+										
+		static void					DispatchURL(
+										URL_Struct*				inURLStruct,
+										CNSContext*				inTargetContext,
+										Boolean					inDelay = false,
+										Boolean					inForceCreate = false,
+										ResIDT					inWindowResID = BrowserWindow_ResID,
+										Boolean					inInitiallyVisible = true,
+										FO_Present_Types		inOutputFormat = FO_CACHE_AND_PRESENT,
+										Boolean					inWaitingForMochaImageLoad = false);
+
+		static void					DispatchURL(CURLDispatchInfo* inDispatchInfo);
+
+		// Dispatch procs
+		
+		static void				DispatchToLibNet(CURLDispatchInfo* inDispatchInfo);
+		static void				DispatchToBrowserWindow(CURLDispatchInfo* inDispatchInfo);
+		static void				DispatchMailboxURL(CURLDispatchInfo* inDispatchInfo);
+		static void				DispatchToMailNewsWindow(CURLDispatchInfo* inDispatchInfo);
+
+		// Utility functions
+		
+		static void				DispatchToNewBrowserWindow(CURLDispatchInfo* inDispatchInfo);
+		static CBrowserWindow*	CreateNewBrowserWindow(
+										ResIDT inWindowResID = BrowserWindow_ResID,
+										Boolean inInitiallyVisible = true);
+
+		// Return the browser window created by the last call to DispatchToView. Note that
+		// if the dispatch was delayed, this will be null until the pending dispatch is processed.
+		static CBrowserWindow*	GetLastBrowserWindowCreated() { return sLastBrowserWindowCreated; }
+		
+	protected:
+
+		static CURLDispatcher* GetURLDispatcher();	// singleton class
+
+		static void				DispatchToDisk(CURLDispatchInfo* inDispatchInfo);
+
+		static void				DispatchToDiskAsText(CURLDispatchInfo* inDispatchInfo);
+			
+		Uint32 					GetCountDelayedURLs() const { return mDelayedURLs.GetCount(); }
+
+		virtual	void			PostPendingDispatch(CURLDispatchInfo* inDispatchInfo);
+										
+		virtual void			UpdatePendingDispatch(
+										CNSContext*				inForContext);
+										
+		virtual	void			ProcessPendingDispatch(void);
+
+		LArray					mDelayedURLs;
+		
+		// reset to NULL on entry in DispatchToView(), set in DispatchToNewBrowserWindow()
+		static CBrowserWindow*	sLastBrowserWindowCreated;
+
+		static CAutoPtr<CURLDispatcher>	sDispatcher;
+		static CAutoPtr<CBrowserContext>	sDispatchContext;
+		
+
+private:	
+		friend class CAutoPtr<CURLDispatcher>;
+		friend class CAutoPtr<CBrowserContext>;
+		
+								CURLDispatcher();
+		virtual					~CURLDispatcher();
+		
+};
+
+// Info needed to dispatch a URL
+class CURLDispatchInfo
+{
+	public:
+								CURLDispatchInfo();
+
+								CURLDispatchInfo(
+										const char*				inURL,
+										CNSContext*				inTargetContext,
+										FO_Present_Types		inOutputFormat,
+										NET_ReloadMethod		inReloadMethod = NET_DONT_RELOAD,
+										Boolean					inDelay = false /* BLECH! */,
+										Boolean					inForceCreate = false,
+										Boolean					inIsSaving = false,
+										ResIDT					inWindowResID = BrowserWindow_ResID,
+										Boolean					inInitiallyVisible = true);
+
+								CURLDispatchInfo(
+										URL_Struct*				inURLStruct,
+										CNSContext*				inTargetContext,
+										FO_Present_Types		inOutputFormat,
+										Boolean					inDelay = false /* BLECH! */,
+										Boolean					inForceCreate = false,
+										Boolean					inIsSaving = false,
+										ResIDT					inWindowResID = BrowserWindow_ResID,
+										Boolean					inInitiallyVisible = true,
+										Boolean					inWaitingForMochaImageLoad = false);
+
+		virtual					~CURLDispatchInfo();
+		
+		Int32					GetURLType() { return mURLType; }
+		char*					GetURL();
+		URL_Struct*				GetURLStruct() { return mURLStruct; }
+		CNSContext*				GetTargetContext() { return mTargetContext; }
+		FO_Present_Types		GetOutputFormat() { return mOutputFormat; }
+		Boolean					GetDelay() { return mDelayDispatch; }
+		Boolean					GetIsSaving() { return mIsSaving; }
+		Boolean					GetInitiallyVisible() { return mInitiallyVisible; }
+		FSSpec&					GetFileSpec() { return mFileSpec; }
+		ResIDT					GetWindowResID() { return mWindowResID; }
+		Boolean					GetForceCreate() { return mForceCreate; }
+		Boolean					GetIsWaitingForMochaImageLoad()
+								{ return mIsWaitingForMochaImageLoad; }
+		
+		URL_Struct*				ReleaseURLStruct();
+
+		void					ClearDelay() { mDelayDispatch = false; }		
+		void					SetFileSpec(const FSSpec& inFileSpec);
+		void					SetTargetContext(CNSContext* inTargetContext)
+								{ mTargetContext = inTargetContext; }
+		
+	protected:
+		Int32					mURLType;
+		URL_Struct*				mURLStruct;
+		CNSContext*				mTargetContext;
+		FO_Present_Types		mOutputFormat;
+		Boolean					mDelayDispatch;
+		Boolean					mForceCreate;
+		Boolean					mIsSaving;
+		Boolean					mInitiallyVisible;
+		Boolean					mIsWaitingForMochaImageLoad;
+		FSSpec					mFileSpec;
+		ResIDT					mWindowResID;
+};
+#endif

mozilla/cmd/macfe/central/ExternalMail.cp

@@ -0,0 +1,184 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+/*
+	This file contains Navigator only code which supports "Send Page..." and
+	"mailto:" URLs using an external mail client registered with InternetConfig.
+*/
+
+#ifndef MOZ_MAIL_NEWS
+
+#include "msgcom.h"			// MSG_MailDocument()
+#include "xlate.h"			// PrintSetup
+#include "shist.h"			// SHIST_GetCurrent()
+#include "xpgetstr.h"		// XP_GetString()
+#include "CURLDispatcher.h"	// CURLDispatcher::DispatchURL()
+#include "CNSContext.h"		// ExtractNSContext()
+#include "net.h"			// NET_Escape()
+
+extern int MK_MSG_MSG_COMPOSITION;
+
+#define MAX_MAIL_SIZE 300000
+extern "C" void FE_DoneMailTo(PrintSetup * print) ;
+extern "C" void FE_DoneMailTo(PrintSetup * print) 
+{
+	const char * prefix = "mailto:?body=";
+	const char * blankLines = "\r\n\r\n";
+	
+    XP_ASSERT(print);
+    if (!print)
+    	return;
+    	
+    XP_ASSERT(print->url);
+    if (!print->url)
+    	return;
+    	
+    fclose(print->out);    	// don't need this for writing anymore.
+
+	MWContext * context = (MWContext *) (print->carg);
+	if (!context)			// we'll require this later
+		return;
+
+    char * buffer = (char *) malloc(MAX_MAIL_SIZE);
+    
+    if (buffer) {
+   		strcpy(buffer, print->url->address);
+     	strcat(buffer, blankLines);
+   	
+   		int	buflen = strlen(buffer);
+   		
+		// now tack as much of the page onto the body as we have space for...
+	    FILE * fp = fopen(print->filename, "r");
+	    if (fp) {
+		    int len = fread(buffer + buflen, 1, MAX_MAIL_SIZE - buflen - (5 /* slop? */), fp);
+		    buffer[buflen + len] = '\0';
+		    fclose(fp);  
+		    
+		    char *temp = NET_Escape (buffer, URL_XALPHAS);
+		    
+		    XP_FREE(buffer);
+		    buffer = temp;
+		    
+	    } else {
+	    
+		    XP_FREE(buffer);
+		    buffer = NULL;
+		    
+	    }
+    }
+                        
+    // get rid of the file and free the memory  
+    remove(print->filename);
+
+	char *buffer2 = NULL;
+	
+	if (buffer) {
+	
+		buffer2 = (char *) malloc(strlen(prefix) + strlen(buffer) + 1);
+		
+		if (buffer2) {
+    		strcpy(buffer2, prefix);				// start creating a "mailto:" URL
+			strcat(buffer2, buffer);				// the message
+		}
+	}
+	
+	if (buffer2 == NULL) {			// no buffer, or we don't have enough memory to use it, try to just send the URL...
+		if (buffer)
+			XP_FREE(buffer);			// if we're here, we can't use the buffer anyway...
+			
+		buffer = NET_Escape (print->url->address, URL_XALPHAS);
+		if (buffer == NULL)
+			return;			// not enough memory to do ANYTHING useful!
+			
+		buffer2 = (char *) malloc(strlen(prefix) + strlen(buffer) + 1);
+		if (buffer2 == NULL) {
+			XP_FREE(buffer);
+			return;			// not enough memory to do ANYTHING useful!
+		}
+		
+    	strcpy(buffer2, prefix);				// start creating a "mailto:" URL
+		strcat(buffer2, buffer);				// the message
+	}
+
+	XP_FREE(buffer);
+	
+    // XP_FREE(print->filename);
+    // print->filename = NULL;
+    CURLDispatcher::DispatchURL(buffer2, ExtractNSContext(context));
+    XP_FREE(buffer2);
+}
+
+#ifndef MOZ_MAIL_COMPOSE
+extern MSG_Pane* MSG_MailDocument(MWContext *context)
+{
+    if(!context)
+        return NULL;
+
+    History_entry * hist_ent = SHIST_GetCurrent(&(context->hist));
+        
+    // make sure there was a document loaded
+    if(!hist_ent)
+        return NULL;
+
+
+	//Set hist_ent to NULL if context->title is "Message Composition"
+	//This is a nasty way of determining if we're in here in response
+	//to "Mail Doc" or "New Mail Message".
+	//Also, if there's To: field info present(pBar->m_pszTo) then 
+	//we know that it's a Mailto: and set hist_ent to NULL 
+	//Without this differentiation the code always sends the contents
+	//of the previously mailed document even when someone chooses
+	//"New Mail Message" or "Mailto:"
+   
+	if(!strcmp(XP_GetString(MK_MSG_MSG_COMPOSITION), context->title))
+        return NULL;
+
+    URL_Struct * URL_s = SHIST_CreateURLStructFromHistoryEntry(context, hist_ent);
+    if (!URL_s)
+    	return NULL;
+
+    // Zero out the saved data
+	memset(&URL_s->savedData, 0, sizeof(URL_s->savedData));
+
+    PrintSetup print;                                
+
+    XL_InitializeTextSetup(&print);
+    print.width = 68; 
+    print.prefix = "";
+    print.eol = "\r\n";
+
+    char * name = WH_TempName(xpTemporary, NULL);
+    if(!name) {
+    	// Leak URL_s here
+        return(FALSE);
+    }
+
+    print.out  = fopen(name, "w");
+    print.completion = (XL_CompletionRoutine) FE_DoneMailTo;
+    print.carg = context;
+    print.filename = name;
+    print.url = URL_s;
+
+    // leave pCompose window alive until completion routine
+    XL_TranslateText(context, URL_s, &print); 
+
+    return NULL;
+}
+#endif // ! MOZ_MAIL_COMPOSE
+
+#endif // !MOZ_MAIL_NEWS

mozilla/cmd/macfe/central/InternetConfig.cp

@@ -0,0 +1,670 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+// InternetConfig.cp
+//
+// Created by Tim Craycroft, 2/9/96
+//
+
+#include "InternetConfig.h"
+
+#include <ICAPI.h>
+#include <ICKeys.h>
+
+#include <LListener.h>
+#include <LPeriodical.h>
+
+#include "xp_core.h"
+#include "xp_str.h"
+
+#include "uprefd.h"
+#include "prefapi.h"		// ns/modules/libpref
+#include "ufilemgr.h"
+#include "resgui.h"
+
+//
+// InternetConfig class.
+//
+// Checks the IC seed on resume events
+//
+class CInternetConfig
+{
+	public:
+
+		static void	Connect();
+		static void	Disconnect();
+		
+		static	ICError	GetInternetConfigString(ConstStr255Param	icKey,
+												Str255				s,
+												long				*port = nil);
+
+		static	ICError	GetInternetConfigFileMapping(	OSType fileType, 
+														OSType creator, 
+														ConstStr255Param fileName,
+														ICMapEntry *ent);
+		static	ICError MapFileName( ConstStr255Param filename, ICMapEntry *ent );
+		static  ICError	GetFileSpec( ConstStr255Param icKey , FSSpec & ioSpec );
+		static	ICError	LaunchInternetConfigApplication(ConstStr255Param key);
+
+#ifndef MOZ_MAIL_NEWS
+		static	ICError	SendInternetConfigURL(char *address);
+#endif
+
+		static int		UseICPrefCallback(const char *prefString, void *);
+		static void		ResumeEvent();
+
+		static	Boolean	CurrentlyUsingIC();
+		
+		static	Boolean	HaveICInstance();
+
+	private:
+		
+		CInternetConfig();
+		~CInternetConfig();
+
+		void	SynchIf();	// iff the seed has changed
+		void	SynchFromIC();
+		ICError	SynchStringFromIC(	ConstStr255Param	icKey,
+									CPrefs::PrefEnum	netscapePref,
+									Boolean				stripPort = false,
+									const char			*xpPortPrefName = nil,
+									int32				defaultPort = 0);
+									
+		ICError	SynchSplitStringFromIC(	ConstStr255Param	icKey,
+										char 				divider,
+										CPrefs::PrefEnum	firstString,
+										CPrefs::PrefEnum	secondString,
+										Boolean				stripPort = false);
+		ICError SyncFileSpec (  ConstStr255Param	icKey, CPrefs::PrefEnum	netscapePref );
+		ICError	GetICString(	ConstStr255Param	icKey,
+								Str255				s,
+								int32				*port = nil);
+		ICError	GetFSSpec( ConstStr255Param icKey , FSSpec & ioSpec );
+		ICError GetICFileMapping(	OSType fileType, 
+									OSType creator, 
+									ConstStr255Param fileName,
+									ICMapEntry *ent);
+		ICError MapICFileName( ConstStr255Param filename, ICMapEntry *ent );
+		ICError	LaunchICApplication(ConstStr255Param key);
+									
+#ifndef MOZ_MAIL_NEWS
+		ICError SendICURL(char *address);
+#endif
+		ICInstance	fInstance;
+		SInt32		fSeed;
+
+		static 	CInternetConfig*	sInternetConfigConnection;
+};
+
+
+void
+CInternetConfigInterface::ResumeEvent()
+{
+	CInternetConfig::ResumeEvent();
+}
+
+//
+// ConnectToInternetConfig
+//
+// Only public entrypoint to this InternetConfig module.
+//
+// gets the folder from CPrefs::GetFilePrototype(prefSpec(, MainFolder)
+// 
+void
+CInternetConfigInterface::ConnectToInternetConfig()
+{
+	// I assume that this is only called once, at startup.
+	const char	*useICPrefName = "browser.mac.use_internet_config";
+	PREF_RegisterCallback(useICPrefName, CInternetConfig::UseICPrefCallback, nil);
+	try
+	{
+		if (CInternetConfig::CurrentlyUsingIC())
+		{
+			CInternetConfig::Connect();
+		}
+	}
+	catch(ICError err)
+	{
+		// do something ?	a dialog perhaps ?
+		// only if there is a real problem, not if 
+		// IC just isn't installed.
+	}
+}	
+
+void	
+CInternetConfigInterface::DisconnectFromInternetConfig()
+{
+	CInternetConfig::Disconnect();
+}
+
+Boolean
+CInternetConfigInterface::CurrentlyUsingIC(void)
+{
+	Boolean returnValue = TRUE;
+	returnValue = returnValue && CInternetConfig::CurrentlyUsingIC();
+	returnValue = returnValue && CInternetConfig::HaveICInstance();
+	
+	return returnValue;
+}
+
+void
+CInternetConfigInterface::GetInternetConfigString(	ConstStr255Param icKey,
+													Str255 s,
+													long *port)
+{
+	if (CInternetConfig::GetInternetConfigString(icKey, s, port))
+	{
+		s[0] = 0;
+	}
+}
+
+ICError
+CInternetConfigInterface::GetInternetConfigFileMapping(	OSType fileType, 
+														OSType creator, 
+														ConstStr255Param fileName,
+														ICMapEntry *ent)
+{
+	return CInternetConfig::GetInternetConfigFileMapping(fileType, creator,
+															fileName, ent);
+}
+
+
+ICError CInternetConfigInterface::MapFileName( ConstStr255Param filename, ICMapEntry *ent )
+{
+	return CInternetConfig::MapFileName( filename , ent );
+}
+#ifndef MOZ_MAIL_NEWS
+ICError
+CInternetConfigInterface::SendInternetConfigURL(char *address)
+{
+	return CInternetConfig::SendInternetConfigURL(address);
+}
+#endif
+
+ICError
+CInternetConfigInterface::LaunchInternetConfigApplication(ConstStr255Param key)
+{
+	return CInternetConfig::LaunchInternetConfigApplication(key);
+}
+
+ICError	CInternetConfigInterface::GetFileSpec( ConstStr255Param icKey , FSSpec & ioSpec )
+{
+	return  CInternetConfig::GetFileSpec( icKey, ioSpec);
+}
+
+CInternetConfig*
+CInternetConfig::sInternetConfigConnection = nil;
+
+Boolean
+CInternetConfig::CurrentlyUsingIC()
+{
+	
+	XP_Bool	result;
+	const char	*useICPrefName = "browser.mac.use_internet_config";
+	if (PREF_NOERROR != PREF_GetBoolPref(useICPrefName, &result))
+	{
+		result = false;
+	}
+	return (Boolean)result;
+}
+
+
+//
+// CInternetConfig::Connect
+//
+// Call once to hook up with IC.  
+//
+void
+CInternetConfig::Connect()
+{
+	if (!sInternetConfigConnection)
+	{
+		sInternetConfigConnection = new CInternetConfig();	
+	}
+}
+
+//
+// Bail
+//
+void
+CInternetConfig::Disconnect()
+{
+	if (sInternetConfigConnection != nil)
+	{ 
+		delete sInternetConfigConnection;
+		sInternetConfigConnection = nil;
+	}
+}
+
+Boolean
+CInternetConfig::HaveICInstance(void)
+{
+	Boolean returnValue = FALSE;
+	
+	Connect();
+	if (sInternetConfigConnection != nil)
+	{
+		returnValue = (sInternetConfigConnection->fInstance != NULL);
+	}
+	
+	return returnValue;
+}
+
+//
+// CInternetConfig::CInternetConfig
+//
+CInternetConfig::CInternetConfig():
+fInstance(NULL)
+{	
+	ICError	err;
+		
+	// Detect IC, if present
+	StValueChanger<EDebugAction> okayToFail(gDebugThrow, debugAction_Nothing);
+	err = ::ICStart(&fInstance, emSignature);
+	//ThrowIfOSErr_(err);
+	if (!err)
+	{
+		try
+		{	
+
+			ICDirSpec			prefDir[1];
+			ICDirSpecArrayPtr	prefDirArray;
+			UInt32				dirCount = 0;
+			
+			// what a wonderful api...
+			//
+			// Give IC the directory that contains the pref file we're using
+			// so it can look there for an IC config file.
+			prefDirArray = (ICDirSpecArrayPtr) &prefDir;
+			FSSpec	prefSpec = CPrefs::GetFilePrototype(CPrefs::MainFolder);
+			prefDir[0].vRefNum 	= prefSpec.vRefNum;
+			prefDir[0].dirID	= prefSpec.parID;
+			dirCount 			= 1;	
+			
+			err = ::ICFindConfigFile(fInstance, dirCount, prefDirArray);
+			ThrowIfOSErr_(err);
+
+			// Remember initial seed
+			err = ::ICGetSeed(fInstance, &fSeed);
+			ThrowIfOSErr_(err);
+			
+			// Read prefs from IC
+			if (CurrentlyUsingIC())
+			{
+				SynchFromIC();
+			}
+		}
+		catch(ICError err)
+		{
+			// Close IC connection and pass the error along
+			::ICStop(fInstance);
+			fInstance = NULL;
+		//	throw(err);
+			// we probably out to delete "this" as well
+		}
+	}
+}
+
+int
+CInternetConfig::UseICPrefCallback(const char *, void *)
+{
+	if (CInternetConfig::CurrentlyUsingIC())
+	{
+		Connect();
+		sInternetConfigConnection->SynchFromIC();
+	}
+	return 0;	// You don't even want to know my opinion of this!
+}
+
+
+//
+// CInternetConfig::~CInternetConfig
+//
+CInternetConfig::~CInternetConfig()
+{
+	if (fInstance != NULL)
+	{
+		::ICStop(fInstance);		// close IC connection
+	}
+}
+
+//
+// CInternetConfig::SynchFromIC
+//
+// Reads IC settings and converts them to Netscape prefs
+//
+void
+CInternetConfig::SynchFromIC()
+{
+	ICError	err;
+	
+	err = ::ICBegin(fInstance, icReadOnlyPerm);
+	ThrowIfOSErr_(err);
+	
+	// Again, this is lame.
+	//
+	// We should have a table of some sort
+	//
+	SynchStringFromIC(kICRealName, 		CPrefs::UserName);
+	SynchStringFromIC(kICEmail, 		CPrefs::UserEmail);	
+	SynchStringFromIC(kICEmail, 		CPrefs::ReplyTo);	// IC has no reply-to	
+	SynchSplitStringFromIC(kICMailAccount, '@', CPrefs::PopID, CPrefs::PopHost, true);	
+	SynchStringFromIC(kICSMTPHost, 		CPrefs::SMTPHost, true);	
+	SynchStringFromIC(kICWWWHomePage,	CPrefs::HomePage);
+	SynchStringFromIC(kICOrganization, 	CPrefs::Organization);
+	SynchStringFromIC(kICNNTPHost,		CPrefs::NewsHost, true, "news.server_port", 119);
+	SyncFileSpec( kICDownloadFolder, CPrefs::DownloadFolder );
+	::ICEnd(fInstance);
+}
+
+void
+CInternetConfig::SynchIf()
+{
+	SInt32	seed;
+
+	if (::ICGetSeed(fInstance, &seed))
+	{
+		return;
+	}
+	if (seed != fSeed)
+	{
+		try
+		{
+			SynchFromIC();
+		}
+		catch(ICError err)
+		{
+		}
+		fSeed = seed;
+	}
+}
+
+//
+// CInternetConfig::ResumeEvent
+//
+//
+void
+CInternetConfig::ResumeEvent()
+{
+	if (CurrentlyUsingIC())
+	{
+		Connect();
+		sInternetConfigConnection->SynchIf();
+	}
+}
+
+//
+// CInternetConfig::SynchStringFromIC
+//
+// Set a netscape string from an IC string
+ICError
+CInternetConfig::SynchStringFromIC(	ConstStr255Param	icKey,
+									CPrefs::PrefEnum	netscapePref,
+									Boolean				stripPort,
+									const char			*xpPortPrefName,
+									int32				defaultPort)
+{								
+	char	s[256];
+	ICError	err;
+	
+	int32	*portPtr = stripPort ? &defaultPort : nil;
+
+	err = GetICString(icKey, (unsigned char*) s, portPtr);
+	if (err == 0)
+	{
+		p2cstr((StringPtr)s);
+		CPrefs::SetString(s, netscapePref);
+		if (xpPortPrefName)
+		{
+			PREF_SetIntPref(xpPortPrefName, defaultPort);
+		}
+	}
+	return err;
+}		
+
+//
+// CInternetConfig::SynchSplitStringFromIC
+//
+// Takes a single IC string and splits it into two Netscape strings.
+// Useful for machine@host.domain.com, or proxy.address:port type stuff
+//
+// If the divider can't be found, the entire string is put into the
+// first netscape string and the second netscape string is set to '\0'
+// 
+ICError
+CInternetConfig::SynchSplitStringFromIC(	ConstStr255Param	icKey,
+											char 				divider,
+											CPrefs::PrefEnum	firstString,
+											CPrefs::PrefEnum	secondString,
+											Boolean				stripPort)
+{
+	char	buffer[256];
+	char	*s;
+	char	*split;
+	ICError	err;
+	
+	s 	= buffer;
+	err = GetICString(icKey, (unsigned char *) s);
+	if (err != 0) return err;
+	
+	p2cstr((StringPtr)s);
+		
+	split = strchr(s, divider);
+	if (split != NULL)
+	{
+		*split = '\0';
+		if (stripPort)
+		{
+			char *colon = strchr(split+1, ':');
+			if (colon)
+			{
+				*colon = '\0';
+			}
+		}
+		CPrefs::SetString(split+1, secondString);
+	}	
+	else
+	{
+		CPrefs::SetString('\0', secondString);
+	}	
+	CPrefs::SetString(s, firstString);	
+	
+	return 0;
+}			
+					
+//
+// CInternetConfig::GetICString
+//
+// Gets an IC string pref
+//
+ICError
+CInternetConfig::GetInternetConfigString(	ConstStr255Param	icKey,
+											Str255				s,
+											long				*port)
+{
+	Connect();
+	return sInternetConfigConnection->GetICString(icKey, s, port);
+}								
+
+//
+// CInternetConfig::GetICString
+//
+// Gets an IC string pref
+//
+ICError
+CInternetConfig::GetICString(	ConstStr255Param	icKey,
+								Str255				s,
+								int32				*port)
+{
+	ICAttr attr;	
+	long size = 256;
+	ICError	result;
+	result = ::ICGetPref(fInstance, icKey, &attr, (Ptr)s, &size);
+	if (!result)
+	{
+		if (port)
+		{
+			char	cString[256];
+			BlockMoveData(&s[1], cString, s[0]);
+			cString[s[0]] = '\0';
+			char *colon = strchr(cString, ':');
+			if (colon)
+			{
+				*colon = '\0';
+				s[0] = colon - cString;
+				++colon;
+				// IC supposedly supports notations like:
+				//		news.netscape.com:nntp
+				// The protocol services don't seem to work in IC (or I'm to stupid
+				// to make them work), so we just check for this one value ("nntp")
+				// because that is the only protocol for which we support port numbers.
+				if (!XP_STRCASECMP("nntp", colon))
+				{
+					*port = 119;
+				}
+				else
+				{
+					// Add more protocols here if/when we suppor them.
+					long	portFromICString;
+					int numargs = sscanf(colon, "%ld", &portFromICString);
+					if (1 == numargs)
+					{
+						if (portFromICString >= 0)	// negative port numbers are not valid
+						{
+							*port = portFromICString;
+						}
+					}
+					// else we just use the default port
+				}
+			}
+		}
+	}
+	return result;
+}								
+
+#ifndef MOZ_MAIL_NEWS
+ICError
+CInternetConfig::SendInternetConfigURL(char *address)
+{
+	Connect();
+	return sInternetConfigConnection->SendICURL(address);
+}
+
+ICError
+CInternetConfig::SendICURL(char *address)
+{
+	if (address == NULL)
+		return icNoURLErr;
+		
+	long selStart = 0;
+	long selEnd = strlen(address);
+
+	if( CInternetConfig::HaveICInstance() )
+		return ::ICLaunchURL(fInstance, "\p", address, selEnd, &selStart, &selEnd);
+	else
+		return icPrefNotFoundErr;
+}
+#endif
+
+ICError
+CInternetConfig::GetInternetConfigFileMapping(	OSType fileType,
+												OSType creator,
+												ConstStr255Param filename,
+												ICMapEntry *ent)
+{
+	Connect();
+	return sInternetConfigConnection->GetICFileMapping(fileType, creator, filename, ent);
+}
+
+ICError
+CInternetConfig::GetICFileMapping(	OSType fileType,
+									OSType creator,
+									ConstStr255Param filename,
+									ICMapEntry *ent)
+{
+	if( CInternetConfig::HaveICInstance() )
+		return ::ICMapTypeCreator(fInstance, fileType, creator, filename, ent);
+	else
+		return icPrefNotFoundErr;
+}
+
+ICError
+CInternetConfig::LaunchInternetConfigApplication(ConstStr255Param key)
+{
+	Connect();
+	return sInternetConfigConnection->LaunchICApplication(key);
+}
+
+ICError
+CInternetConfig::LaunchICApplication(ConstStr255Param key)
+{
+	if (CInternetConfig::HaveICInstance())
+		return ::ICEditPreferences(fInstance, key);
+	else
+		return icPrefNotFoundErr;
+}
+ICError
+CInternetConfig::MapFileName(	ConstStr255Param filename, ICMapEntry *ent)
+{
+	Connect();
+	return sInternetConfigConnection->MapICFileName(filename, ent);
+}
+
+ICError CInternetConfig::MapICFileName( ConstStr255Param filename, ICMapEntry *ent )
+{
+	if( CInternetConfig::HaveICInstance() )
+		return ::ICMapFilename(fInstance, filename, ent);
+	else
+		return icPrefNotFoundErr;	
+
+}
+
+ICError	CInternetConfig::GetFileSpec( ConstStr255Param icKey , FSSpec & ioSpec )
+{
+	Connect();
+	return sInternetConfigConnection->GetFSSpec(icKey, ioSpec);
+}
+
+ICError	CInternetConfig::GetFSSpec( ConstStr255Param icKey , FSSpec & ioSpec )
+{
+	ICFileSpec* spec;
+	
+	ICAttr attr;
+	char buffer[512];
+	long size = 512;
+	ICError	result;
+	
+	result = ::ICGetPref(fInstance, icKey, &attr, buffer, &size);
+	if (!result)
+	{
+		spec = (ICFileSpec *) buffer;
+		CFileMgr::CopyFSSpec( spec->fss, ioSpec );
+	}
+	return result;
+}
+
+ICError CInternetConfig::SyncFileSpec (  ConstStr255Param	icKey, CPrefs::PrefEnum	netscapePref )
+{
+	FSSpec icSpec;
+	ICError result = GetFSSpec( icKey, icSpec );
+	if( !result )
+	{
+		 CPrefs::SetFolderSpec( icSpec , netscapePref );
+	}
+	return result;
+}

mozilla/cmd/macfe/central/InternetConfig.h

@@ -0,0 +1,89 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+//
+// InternetConfig.h
+//
+// MacFE interface to its support for Apple Internet Config
+//
+// Created by Tim Craycroft, 2/11/96
+//
+//
+
+#pragma once
+
+#include "ICAPI.h"
+
+// Always call.
+//
+// This will determine if InternetConfig is present
+// and do the right thing.
+//
+// Everything else is taken care of behind the scenes.
+//
+
+// Note:
+//------
+// It reads "Everything else is taken care of behind the scenes" and that's right:
+// the API below is ok. That's the "everything else" which is sub optimal.
+// If you need to add a method in CInternetConfigInterface, I recommend you to
+// have a look at how LaunchInternetConfigApplication() and GetInternetConfigString()
+// are implemented. For a single method here, you need two methods "behind the scenes".
+
+class CInternetConfigInterface
+{
+	public:
+
+		static 	Boolean	CurrentlyUsingIC(void);
+			// returns true iff IC is installed and we're listening to it
+
+		static	ICError	LaunchInternetConfigApplication(ConstStr255Param key);
+			// Lauches the app and opens one of the config panels (if specified).
+			// The list of keys is in <ICKeys.h>.
+
+		static	void	ConnectToInternetConfig();
+			// gets the folder from CPrefs::GetFilePrototype(prefSpec(, MainFolder)
+
+		static	void	DisconnectFromInternetConfig();
+			// yeah, like this gets called
+
+		static	void	GetInternetConfigString(ConstStr255Param icKey,
+												Str255 s,
+												long *port= nil);
+			// If an error is encountered, s is set to "\p".
+			// If port is not nil, then the following assumptions are made:
+			//   * The string is a server name that may be have a ":portnumber"
+			//     appended to it.
+			//   * The initial value of *port is the default port number.
+			// If port is not nil, then the returned string will have the ":number"
+			// stripped and the *port value will be the port specified by the
+			// user.
+
+		static	ICError	GetInternetConfigFileMapping(	OSType fileType,
+														OSType creator,
+														ConstStr255Param filename,
+														ICMapEntry *ent);
+		static	ICError MapFileName( ConstStr255Param filename, ICMapEntry *ent );	
+		static ICError	GetFileSpec( ConstStr255Param icKey , FSSpec & ioSpec );											
+#ifndef MOZ_MAIL_NEWS
+		static	ICError	SendInternetConfigURL(char *address);
+#endif
+			
+		static	void	ResumeEvent();
+			// somebody call me when I need to check the IC seed value
+};

mozilla/cmd/macfe/central/LTSMSupport.cp

@@ -0,0 +1,257 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "LTSMSupport.h"
+static Boolean 				mHasTextServices = false;
+static Boolean				mHasTSMTE = false;
+static ScriptCode			mSysScript = smRoman;
+static Boolean				mTSMTEisVersion1 = false;
+static TSMTEPreUpdateUPP 	mTSMTEPreUpdateUPP = NULL;
+static TSMTEPostUpdateUPP 	mTSMTEPostUpdateUPP = NULL;
+		
+
+static Boolean TrapAvailable(short theTrap);
+static pascal void DefaultTSMTEPreUpdateProc(TEHandle textH, long refCon);
+
+// ---------------------------------------------------------------------------
+//	Copy from InlineInputSample.c
+// this TSMTEPreUpdateProc only works around a bug in TSMTE 1.0, which has
+// been fixed in 1.1. For other possible uses, see technote TE 27.
+// ---------------------------------------------------------------------------
+
+static pascal void DefaultTSMTEPreUpdateProc(TEHandle textH, long refCon)
+{
+	#pragma unused(refCon)
+
+	
+	if (mTSMTEisVersion1)		// Modified here for performance 
+	{
+		ScriptCode keyboardScript;
+		short mode;
+		TextStyle theStyle;
+		
+		keyboardScript = ::GetScriptManagerVariable(smKeyScript);
+		mode = doFont;
+		if (!(::TEContinuousStyle(&mode, &theStyle, textH) &&
+				::FontToScript(theStyle.tsFont) == keyboardScript))
+		{
+			theStyle.tsFont = ::GetScriptVariable(keyboardScript, smScriptAppFond);
+			::TESetStyle(doFont, &theStyle, false, textH);
+		};
+	};
+}
+
+// ---------------------------------------------------------------------------
+//		¥ Initialization
+// ---------------------------------------------------------------------------
+//	Default constructor
+void LTSMSupport::Initialize()
+{
+	mSysScript = ::GetScriptManagerVariable(smSysScript); 
+	CheckForTextServices();
+	BeginTextServices();
+	TSMTENewUPP();
+}
+// ---------------------------------------------------------------------------
+//		¥ CheckForTextServices
+//		Call by constructor
+//		From TE27 Page 4/14
+// ---------------------------------------------------------------------------
+void LTSMSupport::CheckForTextServices(void)
+{
+        long gestaltResponse;
+        
+        if (::TrapAvailable(_Gestalt))
+        {
+                if ((::Gestalt(gestaltTSMgrVersion, &gestaltResponse) == noErr) &&
+                         (gestaltResponse >= 1))
+                {
+                		mTSMTEisVersion1 = (gestaltResponse == gestaltTSMTE1);
+                        mHasTextServices = true;
+                        if (::Gestalt(gestaltTSMTEAttr, &gestaltResponse) == noErr)
+                                mHasTSMTE = ((gestaltResponse >> gestaltTSMTEPresent) & 1);
+                };
+        };
+}
+
+// ---------------------------------------------------------------------------
+//		¥ TSMTENewUPP
+//		Modified from InlineInputSample.c
+// ---------------------------------------------------------------------------
+void LTSMSupport::TSMTENewUPP()
+{
+	if(mHasTSMTE) {
+		if(mTSMTEPreUpdateUPP == NULL )
+			mTSMTEPreUpdateUPP = NewTSMTEPreUpdateProc(DefaultTSMTEPreUpdateProc);
+	}
+}
+// ---------------------------------------------------------------------------
+//		¥ BeginTextServices
+//		Call by constructor
+//		From TE27 Page 4/14
+// ---------------------------------------------------------------------------
+void LTSMSupport::BeginTextServices()
+{
+	if (!(mHasTSMTE && ::InitTSMAwareApplication() == noErr))
+	{
+	        // if this happens, just move on without text services
+	        mHasTextServices = false;
+	        mHasTSMTE = false;
+	};
+}
+// ---------------------------------------------------------------------------
+//		¥ DoQuit
+//		Called by DoQuit()
+//		From TE27 Page 4/14
+// ---------------------------------------------------------------------------
+void LTSMSupport::DoQuit(Int32	/* inSaveOption */)
+{
+	if (mHasTextServices)
+        (void) ::CloseTSMAwareApplication();
+}
+// ---------------------------------------------------------------------------
+//		¥ IntlTSMEvent
+//		From TE27 Page 11/14
+// ---------------------------------------------------------------------------
+Boolean
+LTSMSupport::TSMEvent(const EventRecord &inMacEvent)
+{
+        if(mHasTextServices)
+        {
+	        // make sure we have a port and it's not the Window Manager port
+//	        if (qd.thePort != nil && ::FrontWindow() != nil)
+//	        {
+//	                oldFont = qd.thePort->txFont;
+//	                keyboardScript = ::GetScriptManagerVariable(smKeyScript);
+//	                if (::FontToScript(oldFont) != keyboardScript)
+//	                        ::TextFont(GetScriptVariable(keyboardScript, smScriptAppFond));
+//	        };
+	        return ::TSMEvent((EventRecord *)&inMacEvent);
+	    }
+	    else
+	    {
+	    	return false;
+	    }
+}
+// ---------------------------------------------------------------------------
+//		¥ IntlTSMEvent
+//		From TE27 Page 11/14
+// ---------------------------------------------------------------------------
+Boolean	LTSMSupport::SetTSMCursor(Point mousePos)
+{
+	if(mHasTextServices)
+		return ::SetTSMCursor(mousePos);
+	else
+		return false;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+Boolean	LTSMSupport::HasTextServices()
+{
+	return mHasTextServices;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+Boolean	LTSMSupport::HasTSMTE()
+{
+	return mHasTSMTE;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+
+TSMTEPreUpdateUPP	LTSMSupport::GetDefaultTSMTEPreUpdateUPP()
+{
+	return mTSMTEPreUpdateUPP;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+TSMTEPostUpdateUPP	LTSMSupport::GetDefaultTSMTEPostUpdateUPP()
+{
+	return mTSMTEPostUpdateUPP;
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+void LTSMSupport::StartFontScriptLimit()
+{
+	//short theFontScript = ::FontScript();
+	//StartFontScriptLimit(theFontScript);
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+void LTSMSupport::StartFontScriptLimit(  ScriptCode /* scriptcode */)
+{
+	//	We want to disable all the script except: Roman and the Font script
+	//  1. we have set the system script to the font script
+	//	2. disable all the script except Roman and System script by calling 
+	//			KeyScript(smDisablKybds);
+	//  3. Should we also switch input method to the font script ?
+	//	4. restore the system script.
+	//if(mSysScript != scriptcode)
+	//{
+	//	::SetScriptManagerVariable(smSysScript, scriptcode);		
+	//}
+	//if(scriptcode != ::GetScriptManagerVariable(smKeyScript))
+	//{
+	//	::KeyScript(scriptcode);
+	//}
+//	::KeyScript(smKeyDisableKybds);
+//	::SetScriptManagerVariable(smSysScript, mSysScript);		
+}
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+void LTSMSupport::EndFontScriptLimit()
+{
+	// Re-enable all the script
+	//::KeyScript(smKeyEnableKybds);
+	//::SetScriptManagerVariable(smSysScript, mSysScript);		
+}
+// ---------------------------------------------------------------------------
+// check to see if a given trap is implemented. We follow IM VI-3-8.
+// ---------------------------------------------------------------------------
+static 
+Boolean TrapAvailable(short theTrap)
+{
+	TrapType theTrapType;
+	short numToolboxTraps;
+	
+	if ((theTrap & 0x0800) > 0)
+		theTrapType = ToolTrap;
+	else
+		theTrapType = OSTrap;
+
+	if (theTrapType == ToolTrap)
+	{
+		theTrap = theTrap & 0x07ff;
+		if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xaa6e, ToolTrap))
+			numToolboxTraps = 0x0200;
+		else
+			numToolboxTraps = 0x0400;
+		if (theTrap >= numToolboxTraps)
+			theTrap = _Unimplemented;
+	};
+
+	return (NGetTrapAddress(theTrap, theTrapType) != NGetTrapAddress(_Unimplemented, ToolTrap));
+}

mozilla/cmd/macfe/central/LTSMSupport.h

@@ -0,0 +1,68 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include <TextServices.h>
+#ifndef __LTSMSUPPORT__
+#define __LTSMSUPPORT__
+
+#include <TSMTE.h>
+
+//	ftang:
+//	LTSMSupport handle the following TSM stuff:
+//		InitTSMAwareApplication()	- in Initalize() => BeginTextServices()
+//		CloseTSMAwareApplication()  - in DoQuit() => EndTextServices()
+//		TSMEvent() 					- in TSMEvent()
+//		SetTSMCursor() 				- in SetTSMCursor()
+//
+//	LTSMSupport handle the following TSM stuff:
+//		NewTSMDocument()
+//		DeleteTSMDocument()
+//		ActiveTSMDocument()
+//		DeactivateTSMDocument()
+//		FixTSMDocument()
+//
+//	The following TSM stuff will not be handle:
+//		TSMMenuSelect() : We only deal with input method. Therefore, ignore it
+//							See IM-Text 7-22
+
+class	LTSMSupport {
+public:
+	static void				Initialize();
+	static void				DoQuit(Int32	inSaveOption);
+	static Boolean			TSMEvent(const EventRecord &inMacEvent);		
+	static Boolean			SetTSMCursor(Point mousePos);
+	
+	static Boolean			HasTextServices();
+	static Boolean			HasTSMTE();
+	
+	static TSMTEPreUpdateUPP	GetDefaultTSMTEPreUpdateUPP();
+	static TSMTEPostUpdateUPP	GetDefaultTSMTEPostUpdateUPP();
+	
+	static void 			StartFontScriptLimit();
+ 	static void 			StartFontScriptLimit( ScriptCode scriptcode );
+	
+	static void				EndFontScriptLimit();
+	
+protected:
+	static void				CheckForTextServices(void);	
+	static void				BeginTextServices(void);
+	static void 			TSMTENewUPP();
+
+};
+
+#endif

mozilla/cmd/macfe/central/PascalString.cp

@@ -0,0 +1,685 @@
+//----------------------------------------------------------------------------------------
+// PascalString.cp 
+// Copyright © 1985-1993 by Apple Computer, Inc.  All rights reserved.
+//----------------------------------------------------------------------------------------
+
+#include "PascalString.h"
+// #include "xpassert.h"
+
+#ifndef __STDIO__
+#include <stdio.h>
+#endif
+
+#ifndef __STRING__
+#include <string.h>
+#endif
+
+#pragma segment Main
+
+//========================================================================================
+// CLASS CString
+//========================================================================================
+
+
+//----------------------------------------------------------------------------------------
+// CString::InsertHelper(CString):
+//----------------------------------------------------------------------------------------
+
+void CString::InsertHelper(const CString& insStr,
+						  short pos,
+						  short maxLength)
+{
+	if (pos > Length() + 1)
+	{
+#if qDebugMsg
+		fprintf(stderr, "###CString::InsertHelper: Insert position greater than length of CString.\n");
+#endif
+		if (Length() < maxLength)	
+			pos = Length() + 1;
+	}
+	
+#if qDebugMsg
+	if (Length() + insStr.Length() > maxLength)
+		fprintf(stderr, "### CString::InsertHelper: CString truncated during insert call.\n");	
+#endif
+
+	short usableLengthOfInsertString;
+	short endPosOfInsertString;
+	short usableLengthOfShiftedString;
+	
+	if (pos + insStr.Length() > maxLength)
+		usableLengthOfInsertString = maxLength - pos + 1;
+	else
+		usableLengthOfInsertString = insStr.Length();
+	endPosOfInsertString = pos + usableLengthOfInsertString - 1;
+	
+	if ((endPosOfInsertString + 1) + (Length() - pos + 1) > maxLength)
+		usableLengthOfShiftedString = maxLength - endPosOfInsertString;
+	else
+		usableLengthOfShiftedString = Length() - pos + 1;
+		
+	memmove(&fStr[endPosOfInsertString + 1], &fStr[pos], usableLengthOfShiftedString);
+	memmove(&fStr[pos], &insStr.fStr[1], usableLengthOfInsertString);
+	Length() = usableLengthOfShiftedString + endPosOfInsertString;
+} // CString::InsertHelper(CString)
+
+
+//----------------------------------------------------------------------------------------
+// CString::InsertHelper(char*):
+//----------------------------------------------------------------------------------------
+
+void CString::InsertHelper(const char* insStr,
+						  short pos,
+						  short maxLength)
+{
+	this->InsertHelper(CStr255(insStr), pos, maxLength);
+} // CString::InsertHelper(char*)
+
+
+
+//----------------------------------------------------------------------------------------
+// CString::operator char*:
+//----------------------------------------------------------------------------------------
+
+CString::operator char*() const
+{
+	static short currentCString = 0;
+	static char cStrings[kTempCStrings][kStr255Len+1];
+	
+	currentCString = (currentCString + 1) % kTempCStrings;
+	
+	strncpy(cStrings[currentCString], (char *) &fStr[1], Length());
+	cStrings[currentCString][Length()] = '\0';
+	
+	return cStrings[currentCString];
+} // CString::operator char*
+
+
+//----------------------------------------------------------------------------------------
+// CString::operator long:
+//----------------------------------------------------------------------------------------
+
+CString::operator long() const
+{
+	// The following statement looks like it should work. Right?
+	//
+	//	return *((long *) &fStr[1]);
+	//
+	// Wrong, the C compiler generates a MOVE.L starting on a odd byte boundary for the
+    // preceding statement. This is illegal on the 68000. But its _NOT_ a bug, because
+    // according to the ANSI C reference manual, "A pointer to one type may be converted
+    // to a pointer to another type. The resulting pointer may cause an addressing
+    // exception if the subject pointer does not refer to an object suitably aligned in
+    // storage".
+	
+	long returnLong;
+	
+	memcpy(&returnLong, &fStr[1], sizeof(long));
+	return returnLong;
+} // CString::operator long
+
+
+//----------------------------------------------------------------------------------------
+// CString::Pos(char*):
+//----------------------------------------------------------------------------------------
+
+unsigned char CString::Pos(const char* subStr, unsigned char startPos)
+{
+	char cStr[kStr255Len + 1];
+	char* ptr;
+	
+	memcpy(cStr, &fStr[1], (size_t)Length());
+	cStr[Length()] = 0;
+	ptr = strstr(&cStr[startPos - 1], subStr);
+	return ptr != NULL ? (ptr - cStr) + 1 : 0;
+} // CString::Pos(char*)
+
+
+//----------------------------------------------------------------------------------------
+// CString::Pos(CString):
+//----------------------------------------------------------------------------------------
+
+unsigned char CString::Pos(const CString& subStr, unsigned char startPos)
+{
+	char cStr[kStr255Len + 1];
+
+	memcpy(cStr, &subStr.fStr[1], (size_t)(subStr.Length()));
+	cStr[subStr.Length()] = 0;
+	return this->Pos(cStr, startPos);
+} // CString::Pos(CString)
+
+
+//----------------------------------------------------------------------------------------
+// CString::operator const unsigned char*
+//----------------------------------------------------------------------------------------
+CString::operator const unsigned char*() const
+{
+	return (const unsigned char *) this;
+} // CString::operator const unsigned char*
+
+//----------------------------------------------------------------------------------------
+// CString::Delete
+//----------------------------------------------------------------------------------------
+void CString::Delete(short pos, short length)
+{
+	if ((pos > 0) && (length > 0) && (pos <= Length()))	// should also check that pos <= kMaxLength
+	{
+		if (pos + length > Length())
+			fStr[0] = pos - 1;
+		else
+		{
+			::memcpy(&fStr[pos], &fStr[pos + length], Length() - (pos + length) + kLengthByte);
+			fStr[0] -= length;
+		}
+	}
+} // CString::Delete
+
+//========================================================================================
+// CLASS CStr255
+//========================================================================================
+
+const CStr255 CStr255::sEmptyString("\p");
+
+//----------------------------------------------------------------------------------------
+// CStr255::CStr255(char*):
+//----------------------------------------------------------------------------------------
+
+CStr255::CStr255(const char* str)
+{
+	// Truncate the C CString to 255 bytes if necessary.
+	size_t len = str == NULL ? 0 : strlen(str);
+	Length() = len > kStr255Len ?  kStr255Len : len;
+	
+	if (Length() > kStr255Len)
+		Length() = kStr255Len;
+	memcpy(&fStr[1], str, (size_t)Length());
+} // CStr255::CStr255(char*)
+
+
+//----------------------------------------------------------------------------------------
+// CStr255::CStr255(long): Useful for converting OSType's into CStr255's.
+//----------------------------------------------------------------------------------------
+
+CStr255::CStr255(const long id)
+{
+	Length() = 4;
+	memcpy(&fStr[1], &id, (size_t)Length());
+} // CStr255::CStr255(long)
+
+
+//----------------------------------------------------------------------------------------
+// CStr255::Copy:
+//----------------------------------------------------------------------------------------
+
+CStr255 CStr255::Copy(short pos, short length)
+{
+	CStr255 newString;
+	
+	length = length > Length() - pos + kLengthByte ? Length() - pos + kLengthByte : length;
+	
+	if (length > 0)
+	{
+		memcpy(&newString.fStr[1], &fStr[pos], (size_t)length);
+		newString.Length() = length;
+	}
+	else
+		newString = "";
+		
+	return newString;
+	
+} // CStr255::Copy
+
+
+//----------------------------------------------------------------------------------------
+// CStr255::operator+:
+//----------------------------------------------------------------------------------------
+
+CStr255 operator+(const CString& s1,
+                  const char* s2)
+{
+	CStr255 newStr;
+	short s2Len = s2 == NULL ? 0 : (short)(strlen((const char *) s2));
+
+	if (s1.Length() + s2Len > kStr255Len)
+		newStr.Length() = kStr255Len;
+	else
+		newStr.Length() = s1.Length() + s2Len;
+		
+	memcpy(&newStr.fStr[1], &s1.fStr[1], (size_t)(s1.Length()));
+	memcpy(&newStr.fStr[s1.Length() + kLengthByte], s2, newStr.Length() - s1.Length());
+
+	return newStr;
+} // CStr255::operator+
+
+
+//----------------------------------------------------------------------------------------
+// CStr255::operator+(char*,CString):
+//----------------------------------------------------------------------------------------
+
+CStr255 operator+(const char* s1,
+                  const CString& s2)
+{
+	CStr255 newStr;
+	short s1Len = s1 == NULL ? 0 : (short)(strlen(s1));
+
+	if (s1Len + s2.Length() > kStr255Len)
+		newStr.Length() = kStr255Len;
+	else
+		newStr.Length() = s1Len + s2.Length();
+		
+	memcpy(&newStr.fStr[1], s1, (size_t)s1Len);
+	memcpy(&newStr.fStr[s1Len + kLengthByte], s2.fStr + 1, newStr.Length() - s1Len);
+
+	return newStr;
+} // CStr255::operator+(char*,CString)
+
+
+//----------------------------------------------------------------------------------------
+// CStr255::operator+(CString,CString):
+//----------------------------------------------------------------------------------------
+
+CStr255 operator+(const CString& s1,
+                  const CString& s2)
+{
+	CStr255 newStr;
+
+	if (s1.Length() + s2.Length() > kStr255Len)
+		newStr.Length() = kStr255Len;
+	else
+		newStr.Length() = s1.Length() + s2.Length();
+		
+	memcpy(&newStr.fStr[1], &s1.fStr[1], (size_t)(s1.Length()));
+	memcpy(&newStr.fStr[s1.Length() + kLengthByte], s2.fStr + 1, newStr.Length() - s1.Length());
+
+	return newStr;
+} // CStr255::operator+(CString,CString)
+
+
+//----------------------------------------------------------------------------------------
+// CStr255::operator +=(CString):  Concatenate a string
+//----------------------------------------------------------------------------------------
+
+CStr255& CStr255::operator += (const CString& str)
+{
+	InsertHelper (str, Length() + 1, kStr255Len);
+	return *this;
+} // CStr255::operator +=(CString)
+
+
+//----------------------------------------------------------------------------------------
+// CStr255::operator +=(char*):  Concatenate a string
+//----------------------------------------------------------------------------------------
+
+CStr255& CStr255::operator += (const char* str)
+{
+	InsertHelper (str, Length() + 1, kStr255Len);
+	return *this;
+} // CStr255::operator +=(char*)
+
+
+//----------------------------------------------------------------------------------------
+// CStr255::operator +=(char):  Concatenate a single character
+//----------------------------------------------------------------------------------------
+
+CStr255& CStr255::operator += (const char ch)
+{
+	if (++Length() <= kStr255Len)
+		fStr[Length()] = ch;
+	else
+	{
+		--Length();
+#if qDebugMsg
+		fprintf(stderr, "###CStr255::operator+=: Concatenation produces CStr255 overflow.\n");
+#endif
+	}
+	
+	return *this;
+} // CStr255::operator +=(char)
+
+
+//----------------------------------------------------------------------------------------
+// CStr255::operator =:
+//----------------------------------------------------------------------------------------
+
+CStr255& CStr255::operator = (const char* str)
+{
+	if (str)
+	{
+		// Truncate the C CString to 255 bytes if necessary.
+		register size_t itsSize = strlen(str);
+		if (itsSize > kStr255Len)
+			Length() = kStr255Len;
+		else
+			Length() = (unsigned char)(itsSize);
+
+		memcpy(&fStr[1], str, (size_t)Length());
+	}
+	else
+		Length() = 0;
+	
+	return *this;
+} // CStr255::operator =
+
+
+
+//========================================================================================
+// CLASS CStr63
+//========================================================================================
+
+
+//----------------------------------------------------------------------------------------
+// CStr63::CStr63(char*):
+//----------------------------------------------------------------------------------------
+
+CStr63::CStr63(const char* str)
+{
+	// Truncate the C CString to 63 bytes if necessary.
+
+	Length() = str == NULL ? 0 : (unsigned char)(strlen(str));
+	if (Length() > kStr63Len)
+		Length() = kStr63Len;
+	memcpy(&fStr[1], str, (size_t)Length());
+} // CStr63::CStr63(char*)
+
+
+//----------------------------------------------------------------------------------------
+// CStr63::CStr63(long):
+//----------------------------------------------------------------------------------------
+
+CStr63::CStr63(const long id)
+{
+	Length() = 4;
+	memcpy(&fStr[1], &id, (size_t)Length());
+} // CStr63::CStr63(long)
+
+
+//----------------------------------------------------------------------------------------
+// CStr63::Copy:
+//----------------------------------------------------------------------------------------
+
+CStr63 CStr63::Copy(short pos, short length)
+{
+	CStr63 newString;
+	
+	length = length > Length() - pos + kLengthByte ? Length() - pos + kLengthByte : length;
+	
+	if (length > 0)
+	{
+		memcpy(&newString.fStr[1], &fStr[pos], (size_t)length);
+		newString.Length() = length;
+	}
+	else
+		newString = "";
+		
+	return newString;
+	
+} // CStr63::Copy
+
+
+//----------------------------------------------------------------------------------------
+// CStr63::operator +=(CString):  Concatenate a string
+//----------------------------------------------------------------------------------------
+
+CStr63& CStr63::operator += (const CString& str)
+{
+	InsertHelper (str, Length() + 1, kStr63Len);
+	return *this;
+} // CStr63::operator +=(CString)
+
+
+//----------------------------------------------------------------------------------------
+// CStr63::operator +=(char*):  Concatenate a string
+//----------------------------------------------------------------------------------------
+
+CStr63& CStr63::operator += (const char* str)
+{
+	InsertHelper (str, Length() + 1, kStr63Len);
+	return *this;
+} // CStr63::operator +=(char*)
+
+
+//----------------------------------------------------------------------------------------
+// CStr63::operator +=(char):  Concatenate a single character
+//----------------------------------------------------------------------------------------
+
+CStr63& CStr63::operator += (const char ch)
+{
+	if (++Length() <= kStr63Len)
+		fStr[Length()] = ch;
+	else
+	{
+		--Length();
+#if qDebugMsg
+		fprintf(stderr, "###CStr63::operator+=: Concatenation produces CStr63 overflow.\n");
+#endif
+	}
+	
+	return *this;
+} // CStr63::operator +=(char)
+
+
+
+//========================================================================================
+// CLASS CStr32
+//========================================================================================
+
+
+//----------------------------------------------------------------------------------------
+// CStr32::CStr32(char*):
+//----------------------------------------------------------------------------------------
+
+CStr32::CStr32(const char* str)
+{
+	// Truncate the C CString to 32 bytes if necessary.
+
+	Length() = str == NULL ? 0 : (unsigned char)(strlen(str));
+	if (Length() > kStr32Len)
+		Length() = kStr32Len;
+	memcpy(&fStr[1], str, (size_t)Length());
+} // CStr32::CStr32(char*)
+
+
+//----------------------------------------------------------------------------------------
+// CStr32::CStr32(long):
+//----------------------------------------------------------------------------------------
+
+CStr32::CStr32(const long id)
+{
+	Length() = 4;
+	memcpy(&fStr[1], &id, (size_t)Length());
+} // CStr32::CStr32(long)
+
+
+//----------------------------------------------------------------------------------------
+// CStr32::Copy:
+//----------------------------------------------------------------------------------------
+
+CStr32 CStr32::Copy(short pos, short length)
+{
+	CStr32 newString;
+	
+	length = length > Length() - pos + kLengthByte ? Length() - pos + kLengthByte : length;
+	
+	if (length > 0)
+	{
+		memcpy(&newString.fStr[1], &fStr[pos], (size_t)length);
+		newString.Length() = length;
+	}
+	else
+		newString = "";
+		
+	return newString;
+
+} // CStr32::Copy
+
+
+//----------------------------------------------------------------------------------------
+// CStr32::operator +=(CString):  Concatenate a string
+//----------------------------------------------------------------------------------------
+
+CStr32& CStr32::operator += (const CString& str)
+{
+	InsertHelper (str, Length() + 1, kStr32Len);
+	return *this;
+} // CStr32::operator +=(CString)
+
+
+//----------------------------------------------------------------------------------------
+// CStr32::operator +=(char*):  Concatenate a string
+//----------------------------------------------------------------------------------------
+
+CStr32& CStr32::operator += (const char* str)
+{
+	InsertHelper (str, Length() + 1, kStr32Len);
+	return *this;
+} // CStr32::operator +=(char*)
+
+
+//----------------------------------------------------------------------------------------
+// CStr32::operator +=(char):  Concatenate a single character
+//----------------------------------------------------------------------------------------
+
+CStr32& CStr32::operator += (const char ch)
+{
+	if (++Length() <= kStr32Len)
+		fStr[Length()] = ch;
+	else
+	{
+		--Length();
+#if qDebugMsg
+		fprintf(stderr,"###CStr32::operator+=: Concatenation produces CStr32 overflow.\n");
+#endif
+	}
+	
+	return *this;
+} // CStr32::operator +=(char)
+
+
+//========================================================================================
+// CLASS CStr31
+//========================================================================================
+
+
+//----------------------------------------------------------------------------------------
+// CStr31::CStr31(char*):
+//----------------------------------------------------------------------------------------
+
+CStr31::CStr31(const char* str)
+{
+	// Truncate the C CString to 31 bytes if necessary.
+
+	Length() = str == NULL ? 0 : (unsigned char)(strlen(str));
+	if (Length() > kStr31Len)
+		Length() = kStr31Len;
+	memcpy(&fStr[1], str, (size_t)Length());
+} // CStr31::CStr31(char*)
+
+
+//----------------------------------------------------------------------------------------
+// CStr31::CStr31(long):
+//----------------------------------------------------------------------------------------
+
+CStr31::CStr31(const long id)
+{
+	Length() = 4;
+	memcpy(&fStr[1], &id, (size_t)Length());
+} // CStr31::CStr31(long)
+
+
+//----------------------------------------------------------------------------------------
+// CStr31::CStr31(char*):
+//----------------------------------------------------------------------------------------
+
+void
+CStr31::operator =(const CString& str)
+{
+	Length() = str.Length();
+	
+	if (Length() > kStr31Len)
+		Length() = kStr31Len;
+	memcpy(&fStr[1], &str.fStr[1], (size_t)Length());
+}
+
+void
+CStr31::operator =(const unsigned char* str)
+{
+	Length() = str == NULL ? 0 : str[0];
+	
+	if (Length() > kStr31Len)
+		Length() = kStr31Len;
+	memcpy(&fStr[1], str + 1, (size_t)Length());
+}
+
+void
+CStr31::operator =(const char* str)
+{
+	Length() = str == NULL ? 0 : (unsigned char)(strlen(str));
+	
+	if (Length() > kStr31Len)
+		Length() = kStr31Len;
+	memcpy(&fStr[1], str, (size_t)Length());
+}
+
+//----------------------------------------------------------------------------------------
+// CStr31::Copy:
+//----------------------------------------------------------------------------------------
+
+CStr31 CStr31::Copy(short pos, short length)
+{
+	CStr31 newString;
+	
+	length = length > Length() - pos + kLengthByte ? Length() - pos + kLengthByte : length;
+	
+	if (length > 0)
+	{
+		memcpy(&newString.fStr[1], &fStr[pos], (size_t)length);
+		newString.Length() = length;
+	}
+	else
+		newString = "";
+		
+	return newString;
+
+} // CStr31::Copy
+
+
+//----------------------------------------------------------------------------------------
+// CStr31::operator +=(CString):  Concatenate a string
+//----------------------------------------------------------------------------------------
+
+CStr31& CStr31::operator += (const CString& str)
+{
+	InsertHelper (str, Length() + 1, kStr31Len);
+	return *this;
+} // CStr31::operator +=(CString)
+
+
+//----------------------------------------------------------------------------------------
+// CStr31::operator +=(char*):  Concatenate a string
+//----------------------------------------------------------------------------------------
+
+CStr31& CStr31::operator += (const char* str)
+{
+	InsertHelper (str, Length() + 1, kStr31Len);
+	return *this;
+} // CStr31::operator +=(char*)
+
+
+//----------------------------------------------------------------------------------------
+// CStr31::operator +=(char):  Concatenate a single character
+//----------------------------------------------------------------------------------------
+
+CStr31& CStr31::operator += (const char ch)
+{
+	if (++Length() <= kStr31Len)
+		fStr[Length()] = ch;
+	else
+	{
+		--Length();
+#if qDebugMsg
+		fprintf(stderr,"###CStr31::operator+=: Concatenation produces CStr31 overflow.\n");
+#endif
+	}
+	
+	return *this;
+} // CStr31::operator +=(char)

mozilla/cmd/macfe/central/PascalString.h

@@ -0,0 +1,753 @@
+//----------------------------------------------------------------------------------------
+// PascalString.h 
+// Copyright © 1985-1994 by Apple Computer, Inc.  All rights reserved.
+//----------------------------------------------------------------------------------------
+
+
+// ¥ Updated by Jeroen Schalk - DTS
+// ¥ Use MABlockMove, not memcpy(), memmove(), strncpy().
+// ¥ Changed default constructors to initialize to empty string.
+// ¥ Changed number of temporary strings from 4 to 8
+// ¥ Make operator[] and unsigned char*() inline
+// ¥ Fix bugs in constructors out of const unsigned char* str
+// ¥ Optimized constructors to only move required data
+// ¥ General cleanup of code for readability
+
+#pragma once
+
+#ifndef __PASCALSTRING__
+#define __PASCALSTRING__
+
+#ifndef __MEMORY__
+#include <Memory.h>
+#endif
+
+#ifndef __TYPES__
+#include <Types.h>
+#endif
+
+#ifndef __TEXTUTILS__
+#include <TextUtils.h>
+#endif
+
+#ifndef __OSUTILS__
+#include <OSUtils.h>
+#endif
+
+#ifndef __STRING__
+#include <string.h>
+#endif
+
+// Forward declaration for all the CString classes.
+struct CString;
+struct CStr255;
+struct CStr63;
+struct CStr32;
+struct CStr31;
+
+typedef const CStr255& ConstCStr255Param;
+typedef const CStr63& ConstCStr63Param;
+typedef const CStr32& ConstCStr32Param;
+typedef const CStr31& ConstCStr31Param;
+
+#ifdef Length
+#undef Length
+#endif
+// Some constants defining the length of each of the CString types.
+
+const short kLengthByte = 1;
+const short kBaseLen = 2;
+const short kStr255Len = 255;
+const short kStr63Len = 63;
+const short kStr32Len = 32;
+const short kStr31Len = 31;
+
+// Number of temporary strings
+
+const short kTempCStrings = 8;
+
+//----------------------------------------------------------------------------------------
+// MABlockMove: BlockMoveData() is fastest on PowerPC, memcpy() on 68K
+//----------------------------------------------------------------------------------------
+
+#if powerc
+	#define MABlockMove(srcPtr, destPtr, byteCount) \
+		::BlockMoveData(Ptr(srcPtr), Ptr(destPtr), Size(byteCount))
+#else
+	#define MABlockMove(srcPtr, destPtr, byteCount) \
+		::memcpy(destPtr, srcPtr, size_t(byteCount))
+#endif
+
+//----------------------------------------------------------------------------------------
+// MABlockMoveOverlap: BlockMoveData() is fastest on PowerPC, memmove() on 68K
+//----------------------------------------------------------------------------------------
+
+#if powerc
+	#define MABlockMoveOverlap(srcPtr, destPtr, byteCount) \
+		::BlockMoveData(Ptr(srcPtr), Ptr(destPtr), Size(byteCount))
+#else
+	#define MABlockMoveOverlap(srcPtr, destPtr, byteCount) \
+		::memmove(destPtr, srcPtr, size_t(byteCount))
+#endif
+
+//----------------------------------------------------------------------------------------
+// CString: Superclass of all Pascal string compatible string classes.
+//----------------------------------------------------------------------------------------
+
+typedef struct CString *CStringPtr, **CStringHandle;
+
+struct CString
+{
+public:
+	unsigned char fStr[kBaseLen];
+
+protected:
+	CString() {}
+		// This is here (and protected) to stop people trying to instantiate CString.
+		// To do so is very bad,  because it's suicide to make one of these!  There are
+		// only 2 bytes of data!
+	void InsertHelper(const CString& insStr, short pos, short maxLength);
+	void InsertHelper(const char* insStr, short pos, short maxLength);
+
+public:
+	// Basic length method, inherited by all derived classes. Define one that returns a
+	// reference. Can be used as an lvalue and only can be applied to non-const Strings.
+
+	inline unsigned char& Length()
+	{
+		return fStr[0];
+	}											// for non-const CString
+
+	inline unsigned char Length() const
+	{
+		return fStr[0];
+	}											// for const CString
+
+	inline Boolean IsEmpty()
+	{
+		return fStr[0] <= 0;
+	}											// for non-const CString
+
+	inline Boolean IsEmpty() const
+	{
+		return fStr[0] <= 0;
+	}											// for const CString
+
+	// Character selector operator.
+
+	inline unsigned char& operator[](short pos)
+	{
+		return fStr[pos];
+	}											// for non-const CString
+
+	inline unsigned char operator[](short pos) const
+	{
+		return fStr[pos];
+	}											// for const CString
+	
+	//------------------------------------------------------------------------------------
+	// CAUTION: There is a subtle difference between the (char*) and (unsigned char*)
+    // conversion operators. The first converts a pascal-style string to a c-style
+    // string. The second simply converts between two types (CString and Str55) both of
+    // which are pascal-style strings.
+	
+	// Create a NULL terminated c-style string from a pascal-style CString. Used in
+    // debugging to fprintf a CString.
+	
+	operator char*() const;
+	
+	// Used to create a toolbox type Str255 from our CString. This is simply a type
+	// coercion! Both CString and Str255 are expected to be pascal-style strings.
+	
+	inline operator unsigned char*()
+	{
+		return (unsigned char *) this;
+	}											// for non-const CString
+	
+	operator const unsigned char*() const;		// for const CString
+
+	//------------------------------------------------------------------------------------
+	
+	// Return an ID represented as a CString to the actual ID (a long).
+	
+	operator long() const;
+
+	// Relational operators that are inherited by all the derived CString types. Three of
+	// each so that literal C Strings can be conveniently used for one of the operators as
+	// well as two of the derive classes as operators. These are declared here but defined
+	// below all the CString classes because they use constructors for CStr255 and its class
+	// definition has not been encountered yet.
+
+	friend inline Boolean operator==(const CString& s1,
+							  const char* s2);
+	friend inline Boolean operator==(const char* s1,
+							  const CString& s2);
+	friend inline Boolean operator==(const CString& s1,
+							  const CString& s2);
+	friend inline Boolean operator!=(const CString& s1,
+							  const char* s2);
+	friend inline Boolean operator!=(const char* s1,
+							  const CString& s2);
+	friend inline Boolean operator!=(const CString& s1,
+							  const CString& s2);
+
+	friend inline Boolean operator>(const CString& s1,
+							 const char* s2);
+	friend inline Boolean operator>(const char* s1,
+							 const CString& s2);
+	friend inline Boolean operator>(const CString& s1,
+							 const CString& s2);
+
+	friend inline Boolean operator<(const CString& s1,
+							 const char* s2);
+	friend inline Boolean operator<(const char* s1,
+							 const CString& s2);
+	friend inline Boolean operator<(const CString& s1,
+							 const CString& s2);
+
+	friend inline Boolean operator>=(const CString& s1,
+							  const char* s2);
+	friend inline Boolean operator>=(const char* s1,
+							  const CString& s2);
+	friend inline Boolean operator>=(const CString& s1,
+							  const CString& s2);
+
+	friend inline Boolean operator<=(const CString& s1,
+							  const char* s2);
+	friend inline Boolean operator<=(const char* s1,
+							  const CString& s2);
+	friend inline Boolean operator<=(const CString& s1,
+							  const CString& s2);
+
+	// Concatenation operator that are inherited by all the derived CString types. Three
+	// of each so that literal C Strings can be conveniently used for one of the operators
+	// as well as using any two classes derived from CString.
+
+	friend CStr255 operator+(const CString& s1,
+							 const char* s2);
+	friend CStr255 operator+(const char* s1,
+							 const CString& s2);
+	friend CStr255 operator+(const CString& s1,
+							 const CString& s2);
+
+	// Methods that mimic the Pascal builtin CString functions for Pos, Insert and Delete.
+	// Note that insert and copy is implemented in the derived classes.
+
+	unsigned char Pos(const char* subStr, unsigned char startPos = 1);
+	unsigned char Pos(const CString& subStr, unsigned char startPos = 1);
+	void Delete(short pos, short length);
+
+protected:
+	inline long Min(const long a, const long b) const
+	{
+		return a < b ? a : b;
+	}
+};
+
+
+//----------------------------------------------------------------------------------------
+// CStr255:
+//----------------------------------------------------------------------------------------
+
+struct CStr255 : CString
+{
+	friend struct CStr63;
+	friend struct CStr31;
+
+private:
+	unsigned char fData[kStr255Len - 1];
+
+public:
+	static const CStr255 sEmptyString;
+	
+	CStr255();
+	CStr255(const CStr255& str);
+	CStr255(const CStr63& str);
+	CStr255(const CStr32& str);
+	CStr255(const CStr31& str);
+	CStr255(const unsigned char* str);
+	CStr255(const char* str);
+	CStr255(const long id);
+
+	// Insert and Copy roughly equivalent to the Pascal Insert and Copy functions.
+	
+	void Insert(const CString& str, short pos);
+	void Insert(const char* str, short pos);
+	CStr255 Copy(short pos, short length);
+					   
+	// Concatenation operator
+	
+	CStr255& operator +=(const CString& str);
+	CStr255& operator +=(const char* str);
+	CStr255& operator +=(const char ch);
+
+	// Assignment operator
+
+	CStr255& operator =(const CStr255& str);
+	CStr255& operator =(const CStr63& str);
+	CStr255& operator =(const CStr32& str);
+	CStr255& operator =(const CStr31& str);
+	CStr255& operator =(const unsigned char* str);
+	CStr255& operator =(const char aChar);
+	CStr255& operator =(const char* str);
+};
+
+
+//----------------------------------------------------------------------------------------
+// CStr63:
+//----------------------------------------------------------------------------------------
+
+struct CStr63 : CString
+{
+	friend struct CStr255;
+	friend struct CStr31;
+
+private:
+	unsigned char fData[kStr63Len - 1];
+
+public:
+	CStr63();
+	CStr63(const CStr255& str);
+	CStr63(const CStr63& str);
+	CStr63(const CStr32& str);
+	CStr63(const CStr31& str);
+	CStr63(const unsigned char* str);
+	CStr63(const char* str);
+	CStr63(const long id);
+
+	// Insert and Copy roughly equivalent to the Pascal Insert and Copy functions.
+	
+	void Insert(const CString& str, short pos);
+	void Insert(const char* str, short pos);
+	CStr63 Copy(short pos, short length);
+
+	// Concatenation operator
+	
+	CStr63& operator +=(const CString& str);
+	CStr63& operator +=(const char* str);
+	CStr63& operator +=(const char ch);
+};
+
+
+//----------------------------------------------------------------------------------------
+// CStr32:
+//----------------------------------------------------------------------------------------
+
+struct CStr32 : CString
+{
+	friend struct CStr255;
+	friend struct CStr63;
+
+private:
+	unsigned char fData[kStr32Len - 1];
+
+public:
+	CStr32();
+	inline CStr32(unsigned char length)
+	{
+		fStr[0] = length;
+	}
+
+	CStr32(const CStr255& str);
+	CStr32(const CStr63& str);
+	CStr32(const CStr32& str);
+	CStr32(const CStr31& str);
+	CStr32(const unsigned char* str);
+	CStr32(const char* str);
+	CStr32(const long id);
+
+	// Insert and Copy roughly equivalent to the Pascal Insert and Copy functions.
+	
+	void Insert(const CString& str, short pos);
+	void Insert(const char* str, short pos);
+	CStr32 Copy(short pos, short length);
+
+	// Concatenation operator
+	
+	CStr32& operator +=(const CString& str);
+	CStr32& operator +=(const char* str);
+	CStr32& operator +=(const char ch);
+};
+
+
+//----------------------------------------------------------------------------------------
+// CStr31:
+//----------------------------------------------------------------------------------------
+
+struct CStr31 : CString
+{
+	friend struct CStr255;
+	friend struct CStr63;
+	friend struct CStr32;
+
+private:
+	unsigned char fData[kStr31Len - 1];
+
+public:
+	CStr31();
+	inline CStr31(unsigned char length)
+	{
+		fStr[0] = length;
+	}
+
+	CStr31(const CStr255& str);
+	CStr31(const CStr63& str);
+	CStr31(const CStr32& str);
+	CStr31(const CStr31& str);
+	CStr31(const unsigned char* str);
+	CStr31(const char* str);
+	CStr31(const long id);
+
+	void	operator =(const CString& str);
+	void	operator =(const unsigned char* str);
+	void	operator =(const char* str);
+	
+	// Insert and Copy roughly equivalent to the Pascal Insert and Copy functions.
+	
+	void Insert(const CString& str, short pos);
+	void Insert(const char* str, short pos);
+	CStr31 Copy(short pos, short length);
+
+	// Concatenation operator
+	
+	CStr31& operator +=(const CString& str);
+	CStr31& operator +=(const char* str);
+	CStr31& operator +=(const char ch);
+};
+
+//----------------------------------------------------------------------------------------
+// CStr255 inline function definitions
+//----------------------------------------------------------------------------------------
+
+inline CStr255::CStr255()
+{
+	fStr[0] = 0;
+}
+
+inline CStr255::CStr255(const CStr255& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr255::CStr255(const CStr63& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr255::CStr255(const CStr32& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr255::CStr255(const CStr31& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr255::CStr255(const unsigned char* str)
+{
+	MABlockMove(str, fStr, str[0] + kLengthByte);
+}
+
+inline CStr255& CStr255::operator = (const CStr255& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+	
+	return *this;
+}
+
+inline CStr255& CStr255::operator = (const CStr63& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+	
+	return *this;
+}
+
+inline CStr255& CStr255::operator = (const CStr32& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+	
+	return *this;
+}
+
+inline CStr255& CStr255::operator = (const CStr31& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+	
+	return *this;
+}
+
+inline CStr255& CStr255::operator = (const unsigned char* str)
+{
+	MABlockMove(str, fStr, str[0] + kLengthByte);
+	
+	return *this;
+}
+
+inline CStr255& CStr255::operator = (const char aChar)
+{
+	Length() = (aChar) ? 1 : 0;
+	fStr[1] = aChar;
+	
+	return *this;
+}
+
+inline void CStr255::Insert(const CString& str, short pos)
+{
+	this->InsertHelper(str, pos, kStr255Len);
+}
+
+inline void CStr255::Insert(const char* str, short pos)
+{
+	this->InsertHelper(str, pos, kStr255Len);
+}
+
+
+//----------------------------------------------------------------------------------------
+// CStr63 inline function definitions
+//----------------------------------------------------------------------------------------
+
+inline CStr63::CStr63()
+{
+	fStr[0] = 0;
+}
+
+inline CStr63::CStr63(const CStr255& str)
+{
+	// Truncate the CStr255 to 63 bytes if necessary.
+
+	Length() = str.Length() > kStr63Len ? kStr63Len : str.Length();
+	MABlockMove(&str.fStr[1], &fStr[1], Length());
+}
+
+inline CStr63::CStr63(const CStr63& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr63::CStr63(const CStr32& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr63::CStr63(const CStr31& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr63::CStr63(const unsigned char* str)
+{
+	MABlockMove(str, fStr, Min(str[0] + kLengthByte, sizeof(CStr63)));
+}
+
+inline void CStr63::Insert(const CString& str, short pos)
+{
+	this->InsertHelper(str, pos, kStr63Len);
+}
+
+inline void CStr63::Insert(const char* str, short pos)
+{
+	this->InsertHelper(str, pos, kStr63Len);
+}
+
+
+//----------------------------------------------------------------------------------------
+// CStr32 inline function definitions
+//----------------------------------------------------------------------------------------
+
+inline CStr32::CStr32()
+{
+	fStr[0] = 0;
+}
+
+inline CStr32::CStr32(const CStr255& str)
+{
+	// Truncate the CStr255 to 32 bytes if necessary.
+
+	Length() = str.Length() > kStr32Len ? kStr32Len : str.Length();
+	MABlockMove(&str.fStr[1], &fStr[1], Length());
+}
+
+inline CStr32::CStr32(const CStr63& str)
+{
+	// Truncate the CStr63 to 32 bytes if necessary.
+
+	Length() = str.Length() > kStr32Len ? kStr32Len : str.Length();
+	MABlockMove(&str.fStr[1], &fStr[1], Length());
+}
+
+inline CStr32::CStr32(const CStr32& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr32::CStr32(const CStr31& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr32::CStr32(const unsigned char* str)
+{
+	MABlockMove(str, fStr, Min(str[0] + kLengthByte, sizeof(CStr32)));
+}
+
+inline void CStr32::Insert(const CString& str, short pos)
+{
+	this->InsertHelper(str, pos, kStr32Len);
+}
+
+inline void CStr32::Insert(const char* str, short pos)
+{
+	this->InsertHelper(str, pos, kStr32Len);
+}
+
+
+//----------------------------------------------------------------------------------------
+// CStr31 inline function definitions
+//----------------------------------------------------------------------------------------
+
+inline CStr31::CStr31()
+{
+	fStr[0] = 0;
+}
+
+inline CStr31::CStr31(const CStr255& str)
+{
+	// Truncate the CStr255 to 31 bytes if necessary.
+
+	Length() = str.Length() > kStr31Len ? kStr31Len : str.Length();
+	MABlockMove(&str.fStr[1], &fStr[1], Length());
+}
+
+inline CStr31::CStr31(const CStr63& str)
+{
+	// Truncate the CStr63 to 31 bytes if necessary.
+
+	Length() = str.Length() > kStr31Len ? kStr31Len : str.Length();
+	MABlockMove(&str.fStr[1], &fStr[1], Length());
+}
+
+inline CStr31::CStr31(const CStr32& str)
+{
+	// Truncate the CStr32 to 31 bytes if necessary.
+
+	Length() = str.Length() > kStr31Len ? kStr31Len : str.Length();
+	MABlockMove(&str.fStr[1], &fStr[1], Length());
+}
+
+inline CStr31::CStr31(const CStr31& str)
+{
+	MABlockMove(str.fStr, fStr, str.Length() + kLengthByte);
+}
+
+inline CStr31::CStr31(const unsigned char* str)
+{
+	MABlockMove(str, fStr, Min(str[0] + kLengthByte, sizeof(CStr31)));
+}
+
+inline void CStr31::Insert(const CString& str, short pos)
+{
+	this->InsertHelper(str, pos, kStr31Len);
+}
+
+inline void CStr31::Insert(const char* str, short pos)
+{
+	this->InsertHelper(str, pos, kStr31Len);
+}
+
+
+//----------------------------------------------------------------------------------------
+// Inline friend function definitions for relational string operators.
+//----------------------------------------------------------------------------------------
+
+inline Boolean operator==(const CString& s1, const char* s2)
+{
+	return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) == 0;
+}
+
+inline Boolean operator==(const char* s1, const CString& s2)
+{
+	return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) == 0;
+}
+
+inline Boolean operator==(const CString& s1, const CString& s2)
+{
+	return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) == 0;
+}
+
+inline Boolean operator!=(const CString& s1, const char* s2)
+{
+	return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) != 0;
+}
+
+inline Boolean operator!=(const char* s1, const CString& s2)
+{
+	return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) != 0;
+}
+
+inline Boolean operator!=(const CString& s1, const CString& s2)
+{
+	return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) != 0;
+}
+
+inline Boolean operator>(const CString& s1, const char* s2)
+{
+	return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) > 0;
+}
+
+inline Boolean operator>(const char* s1, const CString& s2)
+{
+	return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) > 0;
+}
+
+inline Boolean operator>(const CString& s1, const CString& s2)
+{
+	return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) > 0;
+}
+
+inline Boolean operator<(const CString& s1, const char* s2)
+{
+	return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) < 0;
+}
+
+inline Boolean operator<(const char* s1, const CString& s2)
+{
+	return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) < 0;
+}
+
+inline Boolean operator<(const CString& s1, const CString& s2)
+{
+	return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) < 0;
+}
+
+inline Boolean operator>=(const CString& s1, const char* s2)
+{
+	return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) >= 0;
+}
+
+inline Boolean operator>=(const char* s1, const CString& s2)
+{
+	return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) >= 0;
+}
+
+inline Boolean operator>=(const CString& s1, const CString& s2)
+{
+	return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) >= 0;
+}
+
+inline Boolean operator<=(const CString& s1, const char* s2)
+{
+	return ::RelString((ConstStr255Param)&s1, CStr255(s2), false, true) <= 0;
+}
+
+inline Boolean operator<=(const char* s1, const CString& s2)
+{
+	return ::RelString(CStr255(s1), (ConstStr255Param)&s2, false, true) <= 0;
+}
+
+inline Boolean operator<=(const CString& s1, const CString& s2)
+{
+	return ::RelString((ConstStr255Param)&s1, (ConstStr255Param)&s2, false, true) <= 0;
+}
+
+#endif