Bommels05/Mozilla
Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
git-svn-id: svn://10.0.0.236/tags/Warpzilla@140 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
(no author) 1998-04-09 20:33:24 +00:00
parent 15e2581318
commit 711d3e7e52
4867 changed files with 0 additions and 1614306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
mozilla/build/build_number
View File

@ -1 +0,0 @@
5009808600

25
mozilla/build/genrc.sh
View File

@ -1,25 +0,0 @@
#!/bin/sh
#
# 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.
#
DATATYPE="$1"
INFILE="$2"
echo "${DATATYPE} RCDATA"
sed 's/"/""/g' ${INFILE} | awk 'BEGIN { printf("BEGIN\n") } { printf("\"%s\\r\\n\",\n", $0) } END { printf("\"\\0\"\nEND\n") }'
exit 0

45
mozilla/build/hcc
View File

@ -1,45 +0,0 @@
#!/bin/sh
#
# 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.
#
#
# Fix brain-damaged compilers that don't understand -o and -c together
#
DASH_C=0
DASH_O=0
for i in $*
do
case $i in
-c) DASH_C=1;;
-o) DASH_O=1;;
*.c) C_SRC=$i;;
*.s) S_SRC=$i;;
*.o) OBJECT=$i;;
esac
done
cc $* || exit $?
# if there was no -c and -o we're done
[ $DASH_C = 1 -a $DASH_O = 1 ] || exit 0
# cc always creates the .o from the .c name
[ $C_SRC ] && OBJ=`basename $C_SRC .c`.o
# or the .o from the .s name
[ $S_SRC ] && OBJ=`basename $S_SRC .s`.o
[ -f $OBJECT ] || [ -f $OBJ ] && mv -f $OBJ $OBJECT

86
mozilla/build/hcpp
View File

@ -1,86 +0,0 @@
#!/bin/sh
#
# 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.
#
#
# Wrapper for brain-damaged compilers that don't understand -o and -c together.
#
DUMMY="XxxXxxX"
DASH_C=0
DASH_O=0
GET_OBJECT=0
C_SRC="${DUMMY}"
CC_SRC="${DUMMY}"
CPP_SRC="${DUMMY}"
S_SRC="${DUMMY}"
OBJECT="${DUMMY}"
for i in $*
do
if [ ${GET_OBJECT} -eq 1 ]; then
OBJECT="$i"
GET_OBJECT=0
fi
case $i in
-c)
DASH_C=1
;;
-o)
DASH_O=1
GET_OBJECT=1
;;
*.c)
C_SRC="$i"
;;
+.*)
;;
*.cpp)
CPP_SRC="$i"
;;
*.cc)
CC_SRC="$i"
;;
*.s)
S_SRC="$i"
;;
esac
done
CC $* || exit $?
# LAME!!!
if [ -f -O ]; then
mv -f -- -O ${OBJECT}
fi
# if there was no -c and -o we're done
[ ${DASH_C} -eq 1 -a ${DASH_O} -eq 1 ] || exit 0
# cc always creates the .o from the .c name
if [ "${C_SRC}" != "${DUMMY}" ]; then
OBJ=`basename ${C_SRC} .c`.o
elif [ "${CPP_SRC}" != "${DUMMY}" ]; then
OBJ=`basename ${CPP_SRC} .cpp`.o
elif [ "${CC_SRC}" != "${DUMMY}" ]; then
OBJ=`basename ${CC_SRC} .cc`.o
# or the .o from the .s name
elif [ "${S_SRC}" != "${DUMMY}" ]; then
OBJ=`basename ${S_SRC} .s`.o
fi
[ -f ${OBJECT} ] || [ -f ${OBJ} ] && mv -f ${OBJ} ${OBJECT}

88
mozilla/build/mac/IDE_Options.h
View File

@ -1,88 +0,0 @@
/* -*- 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

38
mozilla/build/mac/NSCrossProductDefines.h
View File

@ -1,38 +0,0 @@
/* -*- 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))

BIN
mozilla/build/mac/RunTSScript
View File

Binary file not shown.

21
mozilla/cmd/Makefile
View File

@ -1,21 +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 = ..
DIRS = xfe patcher
include $(DEPTH)/config/rules.mk

788
mozilla/cmd/macfe/Composer/CColorPopup.cp
View File

@ -1,788 +0,0 @@
/* -*- 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;
}

74
mozilla/cmd/macfe/Composer/CColorPopup.h
View File

@ -1,74 +0,0 @@
/* -*- 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;
};

71
mozilla/cmd/macfe/Composer/CComposerDragTask.cp
View File

@ -1,71 +0,0 @@
/* -*- 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);
}

56
mozilla/cmd/macfe/Composer/CComposerDragTask.h
View File

@ -1,56 +0,0 @@
/* -*- 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

320
mozilla/cmd/macfe/Composer/CEditDictionary.cp
View File

@ -1,320 +0,0 @@
/* -*- 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 );
}

76
mozilla/cmd/macfe/Composer/CEditDictionary.h
View File

@ -1,76 +0,0 @@
/* -*- 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 );
};

4980
mozilla/cmd/macfe/Composer/CEditView.cp
View File

File diff suppressed because it is too large Load Diff

272
mozilla/cmd/macfe/Composer/CEditView.h
View File

@ -1,272 +0,0 @@
/* -*- 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 Boolean EstablishPort();
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

610
mozilla/cmd/macfe/Composer/CEditorWindow.cp
View File

@ -1,610 +0,0 @@
/* -*- 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"
// 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;
}
// if we don't have a history entry, we're kind of screwed-->just load a blank page
}
// 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();
CStr255 title( inNewTitle );
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 += " - [";
if ( inNewTitle && *inNewTitle )
{
netscapeTitle += title;
if (csBaseURL.Length())
netscapeTitle += " : ";
}
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

67
mozilla/cmd/macfe/Composer/CEditorWindow.h
View File

@ -1,67 +0,0 @@
/* -*- 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;
};

299
mozilla/cmd/macfe/Composer/CFontMenuAttachment.cp
View File

@ -1,299 +0,0 @@
/* -*- 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_
}

73
mozilla/cmd/macfe/Composer/CFontMenuAttachment.h
View File

@ -1,73 +0,0 @@
/* -*- 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

124
mozilla/cmd/macfe/Composer/CFormattingToolBar.cp
View File

@ -1,124 +0,0 @@
/* -*- 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 );
}

42
mozilla/cmd/macfe/Composer/CFormattingToolBar.h
View File

@ -1,42 +0,0 @@
/* -*- 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;
};

184
mozilla/cmd/macfe/Composer/COpenRecentlyEditedPopup.cp
View File

@ -1,184 +0,0 @@
/* -*- 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;
}

63
mozilla/cmd/macfe/Composer/COpenRecentlyEditedPopup.h
View File

@ -1,63 +0,0 @@
/* -*- 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

210
mozilla/cmd/macfe/Composer/CRecentEditMenuAttachment.cp
View File

@ -1,210 +0,0 @@
/* -*- 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 );
}
}
}
}

55
mozilla/cmd/macfe/Composer/CRecentEditMenuAttachment.h
View File

@ -1,55 +0,0 @@
/* -*- 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

1050
mozilla/cmd/macfe/Composer/CSpellChecker.cp
View File

File diff suppressed because it is too large Load Diff

83
mozilla/cmd/macfe/Composer/CSpellChecker.h
View File

@ -1,83 +0,0 @@
/* -*- 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;
};

338
mozilla/cmd/macfe/Composer/CToolsAttachment.cp
View File

@ -1,338 +0,0 @@
/* -*- 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);
}
}
}

64
mozilla/cmd/macfe/Composer/CToolsAttachment.h
View File

@ -1,64 +0,0 @@
/* -*- 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

BIN
mozilla/cmd/macfe/Composer/build/Composer.mcp
View File

Binary file not shown.

49
mozilla/cmd/macfe/Composer/build/Composer_DebugPrefix.h
View File

@ -1,49 +0,0 @@
/* -*- 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 "Moz_DebugConfig.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

46
mozilla/cmd/macfe/Composer/build/Composer_Headers.pch
View File

@ -1,46 +0,0 @@
/* -*- 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 "Moz_Config.h"
#ifdef powerc
#pragma precompile_target "Composer_HeadersPPC"
#else
#pragma precompile_target "Composer_Headers68K"
#endif
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ Include the list of headers.
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
#include "Comm_Headers.c"

52
mozilla/cmd/macfe/Composer/build/Composer_Headers.pch++
View File

@ -1,52 +0,0 @@
/* -*- 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 "Moz_Config.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"

49
mozilla/cmd/macfe/Composer/build/Composer_Prefix.h
View File

@ -1,49 +0,0 @@
/* -*- 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 "Moz_Config.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

5559
mozilla/cmd/macfe/Composer/meditdlg.cp
View File

File diff suppressed because it is too large Load Diff

839
mozilla/cmd/macfe/Composer/meditdlg.h
View File

@ -1,839 +0,0 @@
/* -*- 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* fIncludeCaption;
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* mUseImage;
CLargeEditField* mImageFileName;
LControl* mLeaveImage;
char* pExtra;
};

342
mozilla/cmd/macfe/Composer/meditor.cp
View File

@ -1,342 +0,0 @@
/* -*- 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;
}

19
mozilla/cmd/macfe/Composer/meditor.h
View File

@ -1,19 +0,0 @@
/* -*- 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);

1810
mozilla/cmd/macfe/applevnt/mplugin.cp
View File

File diff suppressed because it is too large Load Diff

133
mozilla/cmd/macfe/applevnt/mplugin.h
View File

@ -1,133 +0,0 @@
/* -*- 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>
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 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() { fPositioned = true; }
// ¥¥ window control
void RegisterWindow(void* window);
void UnregisterWindow(void* window);
Boolean PassWindowEvent(EventRecord& inEvent, 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;
static LArray* sPluginList;
};

539
mozilla/cmd/macfe/applevnt/mregistr.cp
View File

@ -1,539 +0,0 @@
/* -*- 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;
}

57
mozilla/cmd/macfe/applevnt/mregistr.h
View File

@ -1,57 +0,0 @@
/* -*- 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);
};

487
mozilla/cmd/macfe/applevnt/ulaunch.cp
View File

@ -1,487 +0,0 @@
/* -*- 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();
ParamText(map->GetAppName(), CStr255(fileName), ErrorManager::OSNumToStr(err), CStr255(""));
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);
}

45
mozilla/cmd/macfe/applevnt/ulaunch.h
View File

@ -1,45 +0,0 @@
/* -*- 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);

60
mozilla/cmd/macfe/central/BookmarksFile.cp
View File

@ -1,60 +0,0 @@
/* -*- 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 <LStream.h>
#include <algorithm>
//
// ReadBookmarksFile
//
// Given a file containing a single URL (probably dropped on the Finder), open it and
// create a bookmark entry for it 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;
}

27
mozilla/cmd/macfe/central/BookmarksFile.h
View File

@ -1,27 +0,0 @@
/* -*- 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);

322
mozilla/cmd/macfe/central/BrowserClasses.cp
View File

@ -1,322 +0,0 @@
/* -*- 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 <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"
#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 "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_(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);
#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_(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

25
mozilla/cmd/macfe/central/BrowserClasses.h
View File

@ -1,25 +0,0 @@
/* -*- 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);

144
mozilla/cmd/macfe/central/BufferStream.cp
View File

@ -1,144 +0,0 @@
/* -*- 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

54
mozilla/cmd/macfe/central/BufferStream.h
View File

@ -1,54 +0,0 @@
/* -*- 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__

1915
mozilla/cmd/macfe/central/CAppleEventHandler.cp
View File

File diff suppressed because it is too large Load Diff

366
mozilla/cmd/macfe/central/CAppleEventHandler.h
View File

@ -1,366 +0,0 @@
/* -*- 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);
};
/*-------------------------------------------------------------*/
// 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);
// --------------------------------------------------------------
/* 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);
};

389
mozilla/cmd/macfe/central/CBookmarksAttachment.cp
View File

@ -1,389 +0,0 @@
/* -*- 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);
}
}
}
}
}

71
mozilla/cmd/macfe/central/CBookmarksAttachment.h
View File

@ -1,71 +0,0 @@
/* -*- 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

1960
mozilla/cmd/macfe/central/CBrowserContext.cp
View File

File diff suppressed because it is too large Load Diff

485
mozilla/cmd/macfe/central/CBrowserContext.h
View File

@ -1,485 +0,0 @@
/* -*- 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

157
mozilla/cmd/macfe/central/CBrowserDragTask.cp
View File

@ -1,157 +0,0 @@
/* -*- 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 by the Proxy Icon and the Personal Toolbar
// to shuttle around url/title information. 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.
//
// NOTE: THIS FLAVOR WILL NOT BE USED BY THE PERSONAL TOOLBAR IN THE FUTURE
// AND WILL ONLY BE USED BY THE PROXY ICON. AS A RESULT, IT WILL BE MOVED
// INTO CProxyDragTask.
//
void
CBrowserDragTask::AddFlavorBookmark(ItemReference inItemRef, const char* inData)
{
OSErr theErr = ::AddDragItemFlavor(
mDragRef,
inItemRef,
emBookmarkDrag,
inData,
inData ? strlen(inData) + 1 : 0,
flavorSenderTranslated | flavorSenderOnly);
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));
}

49
mozilla/cmd/macfe/central/CBrowserDragTask.h
View File

@ -1,49 +0,0 @@
/* -*- 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

351
mozilla/cmd/macfe/central/CExpandoDivider.cp
View File

@ -1,351 +0,0 @@
/* -*- 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

136
mozilla/cmd/macfe/central/CExpandoDivider.h
View File

@ -1,136 +0,0 @@
/* -*- 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

336
mozilla/cmd/macfe/central/CMochaHacks.cp
View File

@ -1,336 +0,0 @@
/* -*- 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;
}

125
mozilla/cmd/macfe/central/CMochaHacks.h
View File

@ -1,125 +0,0 @@
/* -*- 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;
};

1252
mozilla/cmd/macfe/central/CNSContext.cp
View File

File diff suppressed because it is too large Load Diff

520
mozilla/cmd/macfe/central/CNSContext.h
View File

@ -1,520 +0,0 @@
/* -*- 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
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; }
// 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;
};
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; };

745
mozilla/cmd/macfe/central/CNSContextCallbacks.cp
View File

@ -1,745 +0,0 @@
/* -*- 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);
}

393
mozilla/cmd/macfe/central/CNSContextCallbacks.h
View File

@ -1,393 +0,0 @@
/* -*- 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; }

252
mozilla/cmd/macfe/central/CPlainTextConversionContext.cp
View File

@ -1,252 +0,0 @@
/* -*- 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; }

133
mozilla/cmd/macfe/central/CPlainTextConversionContext.h
View File

@ -1,133 +0,0 @@
/* -*- 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;
};

205
mozilla/cmd/macfe/central/CProxyDragTask.cp
View File

@ -1,205 +0,0 @@
/* -*- 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);
}

77
mozilla/cmd/macfe/central/CProxyDragTask.h
View File

@ -1,77 +0,0 @@
/* -*- 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

125
mozilla/cmd/macfe/central/CSaveProgress.cp
View File

@ -1,125 +0,0 @@
/* -*- 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 );
}
}

40
mozilla/cmd/macfe/central/CSaveProgress.h
View File

@ -1,40 +0,0 @@
/* -*- 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;
};

42
mozilla/cmd/macfe/central/CSecureAttachment.h
View File

@ -1,42 +0,0 @@
/* -*- 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;
};

282
mozilla/cmd/macfe/central/CTSMEditField.cp
View File

@ -1,282 +0,0 @@
/* -*- 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;
}
}
}
}

78
mozilla/cmd/macfe/central/CTSMEditField.h
View File

@ -1,78 +0,0 @@
/* -*- 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 );
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;
};

92
mozilla/cmd/macfe/central/CTargetedUpdateMenuRegistry.cp
View File

@ -1,92 +0,0 @@
/* -*- 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());
}

91
mozilla/cmd/macfe/central/CTargetedUpdateMenuRegistry.h
View File

@ -1,91 +0,0 @@
/* -*- 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

883
mozilla/cmd/macfe/central/CURLDispatcher.cp
View File

@ -1,883 +0,0 @@
/* -*- 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);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
XP_List* gAppleDoubleSpecList = nil; // for the ad decoder (see ad_decode.c)
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));
if (destSpec.name[0] != '\0')
{
// Put the spec into our global variable where the ad decoder will find it.
if (!gAppleDoubleSpecList)
gAppleDoubleSpecList = XP_ListNew();
FSSpec* spec = (FSSpec*)XP_ALLOC(sizeof(FSSpec));
FailNIL_(spec);
OSErr err = CFileMgr::UniqueFileSpec(destSpec, destSpec.name, *spec);
if (err)
throw err;
XP_ListAddObjectToEnd(gAppleDoubleSpecList, spec);
}
theProgressWindow->SetWindowContext(theContext);
// the window will be shown on the first progress call.
theContext->ImmediateLoadURL(inDispatchInfo->ReleaseURLStruct(), FO_SAVE_AS);
}
catch (...)
{
delete theProgressWindow;
XP_ListDestroy(gAppleDoubleSpecList);
gAppleDoubleSpecList = nil;
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;
}

210
mozilla/cmd/macfe/central/CURLDispatcher.h
View File

@ -1,210 +0,0 @@
/* -*- 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

184
mozilla/cmd/macfe/central/ExternalMail.cp
View File

@ -1,184 +0,0 @@
/* -*- 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

609
mozilla/cmd/macfe/central/InternetConfig.cp
View File

@ -1,609 +0,0 @@
/* -*- 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 "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 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 GetICString( ConstStr255Param icKey,
Str255 s,
int32 *port = nil);
ICError GetICFileMapping( OSType fileType,
OSType creator,
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);
}
#ifndef MOZ_MAIL_NEWS
ICError
CInternetConfigInterface::SendInternetConfigURL(char *address)
{
return CInternetConfig::SendInternetConfigURL(address);
}
#endif
ICError
CInternetConfigInterface::LaunchInternetConfigApplication(ConstStr255Param key)
{
return CInternetConfig::LaunchInternetConfigApplication(key);
}
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);
::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;
}

88
mozilla/cmd/macfe/central/InternetConfig.h
View File

@ -1,88 +0,0 @@
/* -*- 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);
#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
};

260
mozilla/cmd/macfe/central/LTSMSupport.cp
View File

@ -1,260 +0,0 @@
/* -*- 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)
{
short oldFont;
ScriptCode keyboardScript;
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));
}

68
mozilla/cmd/macfe/central/LTSMSupport.h
View File

@ -1,68 +0,0 @@
/* -*- 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

685
mozilla/cmd/macfe/central/PascalString.cp
View File

@ -1,685 +0,0 @@
//----------------------------------------------------------------------------------------
// 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)

753
mozilla/cmd/macfe/central/PascalString.h
View File

@ -1,753 +0,0 @@
//----------------------------------------------------------------------------------------
// 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

560
mozilla/cmd/macfe/central/PopupBox.cp
View File

@ -1,560 +0,0 @@
/*-----------------------------------------------------------------------------
StdPopup
Written 1994 Netscape Communications Corporation
Portions derived from MacApp,
Copyright © 1984-1994 Apple Computer, Inc. All rights reserved.
-----------------------------------------------------------------------------*/
// primary header
#include "PopupBox.h"
// local libraries
// cross-platform libraries
#include "xpassert.h"
#include "xp_trace.h"
// PowerPlant
#include <UDrawingState.h>
#include <URegistrar.h>
#include <LStdControl.h>
// Macintosh headers
#include <Icons.h>
#include <Memory.h>
#include <Menus.h>
#include <OSUtils.h>
#include <Traps.h>
// ANSI headers
#include <stdio.h>
#include <UGAColorRamp.h>
#include <UGraphicsUtilities.h>
#include "UFontSwitcher.h"
#include "UUTF8TextHandler.h"
#include "UPropFontSwitcher.h"
#include "UCustomizePopUp.h"
#include "LCustomizeMenu.h"
//-----------------------------------------------------------------------------
// random stuff
//-----------------------------------------------------------------------------
#define SETMODRECT(DEST,SOURCE,TOP,LEFT,BOTTOM,RIGHT) \
SetRect (&(DEST), (SOURCE).LEFT, (SOURCE).TOP, (SOURCE).RIGHT, (SOURCE).BOTTOM)
#ifndef GetMenuProc
#define GetMenuProc(menu) (*((Handle *) ((*((Ptr *) (menu))) + 0x06)))
#endif
//-----------------------------------------------------------------------------
// Discrete List Box
//-----------------------------------------------------------------------------
const Int16 fontNumber_Unknown = -1;
StdPopup::StdPopup (CGAPopupMenu * target)
: LAttachment ()
{
ThrowIfNil_(fTarget = target);
fTarget->SetNeedCustomDrawFlag(NeedCustomPopup());
mExecuteHost = false;
fMenu = nil;
fDirty = true;
}
StdPopup::~StdPopup ()
{
if (fMenu)
DisposeMenu (fMenu);
}
//
// definition
//
short
StdPopup::GetCount ()
{
return 0;
}
CStr255
StdPopup::GetText (short item)
{
char buffer [20];
sprintf (buffer, "%hi", item);
return buffer;
}
//
// interface
//
const int tlo = 18; // offset of text from left side of widget
const int tls = 23; // offset from right side of widget to left side of triangle icon
Point
StdPopup::CalcTargetFrame (short & baseline)
{
SyncMenu (fTarget->GetMacMenuH());
Point size;
size.v = /* text */ 16 + /* border */ 3;
size.h = CalcMaxWidth (fTarget->GetMacMenuH()) + tls;
StColorPenState saveColorPenState;
StTextState saveTextState;
saveColorPenState.Normalize();
saveTextState.Normalize();
FontInfo fontInfo;
GetFontInfo (&fontInfo);
baseline = 1 + fontInfo.ascent;
size.v = fontInfo.ascent+fontInfo.descent+fontInfo.leading+ 2;
return size;
}
void
StdPopup::DirtyMenu ()
{
fDirty = true;
}
//
// internal
//
short
StdPopup::CalcMaxWidth (MenuHandle aquiredMenu)
{
if (1 || fDirty)
{
Rect menuRect;
Point hitPt = {0,0};
short whichItem;
MenuDefUPP * menuProc = (MenuDefUPP*) (*aquiredMenu)->menuProc;
SInt8 theState = HGetState((*aquiredMenu)->menuProc);
HLock((*aquiredMenu)->menuProc);
CallMenuDefProc (*menuProc, mSizeMsg, aquiredMenu, &menuRect, hitPt, &whichItem);
HSetState((*aquiredMenu)->menuProc, theState);
}
return (*aquiredMenu)->menuWidth;
}
void StdPopup::DrawTruncTextBox (CStr255 text, const Rect& box)
{
/*
Truncates the text before drawing.
Does not word wrap.
*/
FontInfo fontInfo;
GetFontInfo (&fontInfo);
MoveTo (box.left, box.bottom - fontInfo.descent -1);
TruncString (box.right - box.left, text, truncEnd);
DrawString (text);
}
void StdPopup::DrawWidget (MenuHandle aquiredMenu, const Rect & widgetFrame)
{
StColorPenState saveColorPenState;
StTextState saveTextState;
saveColorPenState.Normalize();
saveTextState.Normalize();
if (GetTextTraits() != fontNumber_Unknown)
UTextTraits::SetPortTextTraits(GetTextTraits());
Rect r;
SETMODRECT(r,widgetFrame,top+1,left+1,bottom-2,right-2);
EraseRect (&r);
MoveTo (widgetFrame.left + 3, widgetFrame.bottom - 1);
LineTo (widgetFrame.right -1, widgetFrame.bottom - 1);
MoveTo (widgetFrame.right -1, widgetFrame.top + 3);
LineTo (widgetFrame.right -1, widgetFrame.bottom - 1);
SETMODRECT(r,widgetFrame,top,left,bottom-1,right-1);
FrameRect (&r);
SETMODRECT(r,widgetFrame,top-1,right-tls,top-1+16,right-tls+16);
::PlotIconID (&r, atNone, ttNone, 'cz');
short whichItem = fTarget->GetValue();
CStr255 itemText;
if (whichItem)
GetMenuItemText (aquiredMenu, whichItem, itemText);
SETMODRECT(r,widgetFrame,top+1,left+tlo,bottom-1,right-tls);
DrawTruncTextBox (itemText, r);
}
void
StdPopup::ExecuteSelf (MessageT message, void *param)
{
fTarget->SetNeedCustomDrawFlag(NeedCustomPopup());
switch (message) {
case msg_DrawOrPrint: {
// 97-06-07 pkc -- put back SyncMenu otherwise Javascript reflection back
// into popup menu list is broken
SyncMenu (fTarget->GetMacMenuH());
mExecuteHost = true;
break;
}
case msg_Click: {
Rect frame;
SMouseDownEvent* event = (SMouseDownEvent*) param;
ThrowIfNil_(event);
{
// Determine which HotSpot was clicked
Int16 theHotSpot = fTarget->FindHotSpot(event->whereLocal);
if (theHotSpot > 0)
{
fTarget->FocusDraw();
// Track mouse while it is down
if (fTarget->TrackHotSpot(theHotSpot, event->whereLocal, event->macEvent.modifiers))
{
// Mouse released inside HotSpot
fTarget->HotSpotResult(theHotSpot);
}
}
mExecuteHost = false;
}
break;
}
}
}
void
StdPopup::SyncMenu (MenuHandle aquiredMenu)
{
if (!fDirty)
return;
int current = CountMItems (aquiredMenu);
int want = GetCount();
int add = want - current;
if (0 < add) {
for (int i = 1; i <= add; i++)
AppendMenu (aquiredMenu, "\pTest");
}
else if (add < 0) {
for (int i = 1; i <= -add; i++)
DeleteMenuItem (aquiredMenu, want + 1);
}
for (int item = 1; item <= want; item++)
{
CStr255 itemText;
itemText = GetText( item );
if ( itemText[ 1 ] == '-' )
itemText = " " + itemText;
SetMenuItemText (aquiredMenu, item, itemText );
}
if (fTarget->GetMaxValue() != want)
fTarget->SetMaxValue (want);
(*aquiredMenu)->menuWidth += tls;
fDirty = false;
}
Boolean StdPopup::NeedCustomPopup() const
{
return false;
}
ResIDT StdPopup::GetTextTraits() const
{
return fTarget->GetTextTraits();
}
/*-----------------------------------------------------------------------------
LCustomizeFontMenu
-----------------------------------------------------------------------------*/
class LCustomizeFontMenu : public LCustomizeMenu {
public:
LCustomizeFontMenu(short fontNum);
virtual void Draw (MenuHandle menu, MenuDefUPP* root, Rect *rect, Point hitPt, short *item);
virtual void Size (MenuHandle menu, MenuDefUPP* root, Rect *rect, Point hitPt, short *item);
virtual void Choose(MenuHandle menu, MenuDefUPP* root, Rect *rect, Point hitPt, short *item);
protected:
virtual void DrawItemText( Rect& itemrect, Str255 itemtext );
virtual void SetupFont() { ::TextFont(fFontNum); };
private:
short fFontNum;
};
#pragma mark == LCustomizeFontMenu ==
LCustomizeFontMenu::LCustomizeFontMenu(short fontNum)
: LCustomizeMenu()
{
fFontNum = fontNum;
}
void LCustomizeFontMenu::Draw(MenuHandle menu, MenuDefUPP* root, Rect *rect, Point hitPt, short *item)
{
SetupFont();
LCustomizeMenu::Draw(menu, root, rect, hitPt, item);
}
void LCustomizeFontMenu::Size(MenuHandle menu, MenuDefUPP* root, Rect *rect, Point hitPt, short *item)
{
SetupFont();
LCustomizeMenu::Size(menu, root, rect, hitPt, item);
}
void LCustomizeFontMenu::Choose(MenuHandle menu, MenuDefUPP* root, Rect *rect, Point hitPt, short *item)
{
SetupFont();
LCustomizeMenu::Choose(menu, root, rect, hitPt, item);
}
void LCustomizeFontMenu::DrawItemText( Rect& itemrect, Str255 itemtext )
{
SetupFont();
LCustomizeMenu::DrawItemText(itemrect,itemtext);
}
/*-----------------------------------------------------------------------------
LMultiFontTextMenu
-----------------------------------------------------------------------------*/
class LMultiFontTextMenu : public LCustomizeMenu {
public:
LMultiFontTextMenu(UMultiFontTextHandler* texthandler, UFontSwitcher* fs);
protected:
virtual void DrawItemText( Rect& itemrect, Str255 itemtext )
{ fTextHandler->DrawString(fFontSwitcher, itemtext); }
virtual short MeasureItemText(Str255 itemtext )
{ return fTextHandler->StringWidth(fFontSwitcher, itemtext); };
private:
UMultiFontTextHandler* fTextHandler;
UFontSwitcher* fFontSwitcher;
};
LMultiFontTextMenu::LMultiFontTextMenu(UMultiFontTextHandler* texthandler, UFontSwitcher* fs)
: LCustomizeMenu()
{
fTextHandler = texthandler;
fFontSwitcher = fs;
}
#pragma mark -
// ===========================================================================
// ¥ CGAPopupMenu CGAPopupMenu ¥
// ===========================================================================
// ---------------------------------------------------------------------------
// ¥ CGAPopupMenu(LStream*)
// ---------------------------------------------------------------------------
// Construct from data in a Stream
CGAPopupMenu::CGAPopupMenu(
LStream *inStream)
: mNeedCustomDraw(false),
super(inStream)
{
}
CGAPopupMenu::~CGAPopupMenu()
{
}
//-------------------------------------------------------------------------------------
// CGAPopupMenu::DrawPopupTitle
//-------------------------------------------------------------------------------------
void
CGAPopupMenu::DrawPopupTitle ()
{
if(! mNeedCustomDraw)
{ // hacky way, depend on mIsUTF8 to decide wheather we use the super class implementation
super::DrawPopupTitle();
return;
}
StColorPenState theColorPenState;
StTextState theTextState;
// ¥ Get some loal variables setup including the rect for the title
ResIDT textTID = GetTextTraitsID ();
Rect titleRect;
Str255 title;
GetCurrentItemTitle ( title );
// ¥ Figure out what the justification is from the text trait and
// get the port setup with the text traits
UTextTraits::SetPortTextTraits ( textTID );
// ¥ Setup the title justification which is always left justified
Int16 titleJust = teFlushLeft;
// ¥ Calculate the title rect
CalcTitleRect ( titleRect );
// ¥ Setup the text color which by default is black
RGBColor textColor;
::GetForeColor ( &textColor );
// ¥ Get the current item's title
Str255 currentItemTitle;
GetCurrentItemTitle ( currentItemTitle );
// ¥ Loop over any devices we might be spanning and handle the drawing
// appropriately for each devices screen depth
StDeviceLoop theLoop ( titleRect );
Int16 depth;
while ( theLoop.NextDepth ( depth ))
{
if ( depth < 4 ) // ¥ BLACK & WHITE
{
// ¥ If the control is dimmed then we use the grayishTextOr
// transfer mode to draw the text
if ( !IsEnabled ())
{
::RGBForeColor ( &UGAColorRamp::GetBlackColor () );
::TextMode ( grayishTextOr );
}
else if ( IsEnabled () && IsHilited () )
{
// ¥ When we are hilited we simply draw the title in white
::RGBForeColor ( &UGAColorRamp::GetWhiteColor () );
}
// ¥ Now get the actual title drawn with all the appropriate settings
UMultiFontTextHandler *th = UUTF8TextHandler::Instance();
UFontSwitcher *fs = UPropFontSwitcher::Instance();
FontInfo info;
th->GetFontInfo(fs, &info);
::MoveTo(titleRect.left,
(titleRect.top + titleRect.bottom + info.ascent - info.descent ) / 2);
th->DrawString(fs, currentItemTitle);
}
else // ¥ COLOR
{
// ¥ If control is selected we always draw the text in the title
// hilite color, if requested
if ( IsHilited ())
::RGBForeColor ( &UGAColorRamp::GetWhiteColor() );
// ¥ If the box is dimmed then we have to do our own version of the
// grayishTextOr as it does not appear to work correctly across
// multiple devices
if ( !IsEnabled () || !IsActive ())
{
textColor = UGraphicsUtilities::Lighten ( &textColor );
::TextMode ( srcOr );
::RGBForeColor ( &textColor );
}
// ¥ Now get the actual title drawn with all the appropriate settings
UMultiFontTextHandler *th = UUTF8TextHandler::Instance();
UFontSwitcher *fs = UPropFontSwitcher::Instance();
FontInfo info;
th->GetFontInfo(fs, &info);
::MoveTo(titleRect.left,
(titleRect.top + titleRect.bottom + info.ascent - info.descent) / 2);
th->DrawString(fs, currentItemTitle);
}
}
} // CGAPopupMenu::DrawPopupTitle
//-------------------------------------------------------------------------------------
//
// This method is used to calculate the title rect for the currently selected item in
// the popup, this title is drawn inside the popup
const Int16 gsPopup_RightInset = 24; // Used to position the title rect
const Int16 gsPopup_TitleInset = 8; // Apple specification
void
CGAPopupMenu::CalcTitleRect ( Rect &outRect )
{
if(! mNeedCustomDraw)
{ // hacky way, depend on mIsUTF8 to decide wheather we use the super class implementation
super::CalcTitleRect(outRect);
return;
}
StTextState theTextState;
StColorPenState thePenState;
Int16 bevelWidth = 2;
// ¥ Get some loal variables setup including the rect for the title
ResIDT textTID = GetTextTraitsID ();
// ¥ Get the port setup with the text traits
UTextTraits::SetPortTextTraits ( textTID );
// ¥ Figure out the height of the text for the selected font
FontInfo fInfo;
UFontSwitcher *fs = UPropFontSwitcher::Instance();
UMultiFontTextHandler *th = UUTF8TextHandler::Instance();
th->GetFontInfo(fs, &fInfo);
Int16 textHeight = fInfo.ascent + fInfo.descent;
Int16 textBaseline = fInfo.ascent;
// ¥ Get the local inset frame rectangle
CalcLocalPopupFrameRect ( outRect );
::InsetRect ( &outRect, 0, bevelWidth );
outRect.right -= gsPopup_RightInset;
outRect.left += gsPopup_TitleInset;
// ¥ Adjust the title rect to match the height of the font
outRect.top += (( UGraphicsUtilities::RectHeight ( outRect ) - textBaseline) / 2) - 2;
outRect.bottom = outRect.top + textHeight;
} // CGAPopupMenu::CalcTitleRect
//=====================================================================================
// ¥¥ POPUP MENU HANDLING
//-------------------------------------------------------------------------------------
// CGAPopupMenu::HandlePopupMenuSelect
//-------------------------------------------------------------------------------------
void
CGAPopupMenu::HandlePopupMenuSelect ( Point inPopupLoc,
Int16 inCurrentItem,
Int16 &outMenuID,
Int16 &outMenuItem )
{
MenuHandle menuH = GetMacMenuH ();
ThrowIfNil_ ( menuH );
if ( menuH )
{
// BUG#69583: Make sure we *do* use the system font so that the current
// item will be checked properly as in Akbar. So we don't do the LMSetSysFont
// stuff that LGAPopup does.
// ¥ Handle the actual insertion into the hierarchical menubar
::InsertMenu ( menuH, hierMenu );
FocusDraw ();
// ¥ Before we display the menu we need to make sure that we have the
// current item marked in the menu. NOTE: we do NOT use the current
// item that has been passed in here as that always has a value of one
// in the case of a pulldown menu
SetupCurrentMenuItem ( menuH, GetValue () );
// ¥ Then we call PopupMenuSelect and wait for it to return
Int32 result;
// hacky way, depend on mIsUTF8 to decide which implementation to use
if (!mNeedCustomDraw)
{
result = ::PopUpMenuSelect(menuH, inPopupLoc.v, inPopupLoc.h, inCurrentItem );
}
else
{
LMultiFontTextMenu utf8menu(UUTF8TextHandler::Instance(), UPropFontSwitcher::Instance());
result = UCustomizePopUp::PopUpMenuSelect(menuH, &utf8menu, inPopupLoc.v, inPopupLoc.h, inCurrentItem);
}
// ¥ Then we extract the values from the returned result
// these are then passed back out to the caller
outMenuID = HiWord ( result );
outMenuItem = LoWord ( result );
// ¥ Finally get the menu removed
::DeleteMenu ( GetPopupMenuResID ());
}
} // CGAPopupMenu::HandlePopupMenuSelect

125
mozilla/cmd/macfe/central/PopupBox.h
View File

@ -1,125 +0,0 @@
/*-----------------------------------------------------------------------------
StdPopup
Written 1994 Netscape Communications Corporation
Portions derived from MacApp,
Copyright © 1984-1994 Apple Computer, Inc. All rights reserved.
-----------------------------------------------------------------------------*/
#pragma once
#ifndef _DISCRETE_LIST_BOX_
#define _DISCRETE_LIST_BOX_
/*-----------------------------------------------------------------------------
StdPopup
We need non-text menu items, so we will use a custom menu definition
procedure.
We need to have a dynamic number of menus, so we will use PopupMenuSelect.
static Handle sMenuProc
In order to use a custom procedure, we need to dispatch from a handle.
This handle is constant and therefore can be global.
static StdPopup * sMenuObject
We can't figure out which object called PopupMenuSelect, so we will set
this global right before calling it. We will never get a menu callback
except from within PopupMenuSelect.
Handle fDefaultMenuProc
This is the normal definition procedure for the menu. We'll use it to
handle most operations; only overriding drawing.
MenuHandle fMenu
We only need a menu widget when we're calling PopupMenuSelect; we could
actually just have 1 of them and reuse it amongst any number of objects, or
give each item its own widget.
// short item = 0;
// DoMenuProc (mSizeMsg, m, gZeroRect, gZeroPt, item);
-----------------------------------------------------------------------------*/
#include <Menus.h>
#include <LAttachment.h>
#include <LGAPopup.h>
#include "PascalString.h"
class LP_Glypher;
#define dlbPopupMenuID 'cz'
class CGAPopupMenu;
// StdPopup
class StdPopup: public LAttachment {
public:
StdPopup (CGAPopupMenu* target);
~StdPopup ();
// definition
virtual short GetCount ()=0;
virtual CStr255 GetText (short item)=0;
// interface
Point CalcTargetFrame (short & baseline);
void DirtyMenu ();
ResIDT GetTextTraits() const;
ResIDT SetTextTraits(ResIDT inTextTraits);
protected:
MenuHandle GetMacMenuH();
virtual Boolean NeedCustomPopup() const;
virtual void SyncMenu (MenuHandle aquiredMenu);
virtual short CalcMaxWidth (MenuHandle aquiredMenu);
void DrawWidget (MenuHandle aquiredMenu, const Rect & widgetFrame);
virtual void ExecuteSelf (MessageT message, void *param);
// do ScriptCode Menu Trick on IM:MacTbxEss Page3-46
// Give subclass a chance to do it.
virtual void SetMenuItemText(MenuHandle aquiredMenu, int item, CStr255& itemText)
{ ::SetMenuItemText(aquiredMenu, item, itemText); } ;
// Let us have a chance to override PopUpMenuSelect
virtual long PopUpMenuSelect(MenuHandle aquiredMenu, short top, short left, short popUpItem)
{ return ::PopUpMenuSelect( aquiredMenu, top, left, popUpItem); };
virtual void DrawTruncTextBox (CStr255 text, const Rect& box);
friend class TempUseMenu;
CGAPopupMenu* fTarget;
MenuHandle fMenu; // this is used if we're doing the UTF8 stuff
private:
Boolean fDirty;
};
class CGAPopupMenu : public LGAPopup {
friend class StdPopup;
public:
enum { class_ID = 'Gatt' };
typedef LGAPopup super;
CGAPopupMenu(LStream* inStream);
virtual ~CGAPopupMenu();
void SetTextTraits(ResIDT inTextTraitsID) { mTextTraitsID = inTextTraitsID; }
ResIDT GetTextTraits() const { return mTextTraitsID; }
void SetNeedCustomDrawFlag(Boolean needCustomDraw) { mNeedCustomDraw = needCustomDraw; }
// For UTF8
//----<< ¥ DRAWING ¥ >>------------------------------------------------------------
virtual void DrawPopupTitle ();
virtual void CalcTitleRect ( Rect &outRect ); // ¥ OVERRIDE
protected:
//----<< ¥ POPUP MENU HANDLING ¥ >>------------------------------------------------
virtual void HandlePopupMenuSelect ( Point inPopupLoc,
Int16 inCurrentItem,
Int16 &outMenuID,
Int16 &outMenuItem );
private:
Boolean mNeedCustomDraw;
};
#endif /* _DISCRETE_LIST_BOX_ */

1475
mozilla/cmd/macfe/central/RandomFrontEndCrap.cp
View File

File diff suppressed because it is too large Load Diff

34
mozilla/cmd/macfe/central/RandomFrontEndCrap.h
View File

@ -1,34 +0,0 @@
/* -*- 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.
*/
// RandomFrontEndCrap.h
#pragma once
extern char reconnectHack[];
extern char mailNewsReconnect[];
Boolean IsInternalImage(const char* url);
Boolean IsMailToLink(const char* url);
Boolean IsMailNewsReconnect(const char* url);
Boolean IsInternalTypeLink(const char* url);
Boolean IsDocInfoWindow(const char* inName);
Boolean IsViewSourceWindow(const char* inName);
Boolean IsSpecialBrowserWindow(const char* inName);

85
mozilla/cmd/macfe/central/StBlockingDialogHandler.cp
View File

@ -1,85 +0,0 @@
/* -*- 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.
*/
// StBlockingDialogHandler.cp
#include "StBlockingDialogHandler.h"
#include <Balloons.h>
StBlockingDialogHandler::StBlockingDialogHandler(
ResIDT inDialogResID,
LCommander* inSuper)
: StDialogHandler(inDialogResID, inSuper)
{
// disable the Help menu while a dialog is in front
// (to prevent loading of Help URLs)
MenuHandle balloonMenuH = NULL;
HMGetHelpMenuHandle( &balloonMenuH );
if (balloonMenuH)
DisableItem(balloonMenuH, 0);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
StBlockingDialogHandler::~StBlockingDialogHandler()
{
MenuHandle balloonMenuH = NULL;
HMGetHelpMenuHandle( &balloonMenuH );
if (balloonMenuH)
EnableItem(balloonMenuH, 0);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
Boolean StBlockingDialogHandler::ExecuteAttachments(
MessageT inMessage,
void *ioParam)
{
Boolean executeHost = true;
// Execute the Attachments for the EventDispatcher that was
// in control before this one took over
// if (mSaveDispatcher != nil) {
// executeHost = mSaveDispatcher->ExecuteAttachments(inMessage, ioParam);
// }
// Inherited function will execute Attachments for this object
return (executeHost && LAttachable::ExecuteAttachments(inMessage, ioParam));
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// Override to prevent About menu item from being enabled.
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void
StBlockingDialogHandler::FindCommandStatus(
CommandT inCommand,
Boolean &outEnabled,
Boolean& /* outUsesMark */,
Char16& /* outMark */,
Str255 /* outName */)
{
outEnabled = false;
}

41
mozilla/cmd/macfe/central/StBlockingDialogHandler.h
View File

@ -1,41 +0,0 @@
/* -*- 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.
*/
// StBlockingDialogHandler.h
#pragma once
#include <UModalDialogs.h>
class StBlockingDialogHandler : public StDialogHandler
{
public:
StBlockingDialogHandler(
ResIDT inDialogResID,
LCommander* inSuper);
virtual ~StBlockingDialogHandler();
virtual Boolean ExecuteAttachments(
MessageT inMessage,
void *ioParam);
virtual void FindCommandStatus(CommandT inCommand,
Boolean &outEnabled, Boolean &outUsesMark,
Char16 &outMark, Str255 outName);
};

605
mozilla/cmd/macfe/central/TSMProxy.cp
View File

@ -1,605 +0,0 @@
/* -*- 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 "TSMProxy.h"
#include "proto.h"
#include "edt.h"
#include "uintl.h"
#include "intl_csi.h"
HoldUpdatesProxy::HoldUpdatesProxy(CEditView &inTextView) :
mTextView(inTextView)
{
mTextView.SetHoldUpdates(this);
mStartY = 0;
mHeight = 0;
}
HoldUpdatesProxy::~HoldUpdatesProxy()
{
mTextView.SetHoldUpdates(nil);
mTextView.DocumentChanged(mStartY, mHeight);
}
void HoldUpdatesProxy::DocumentChanged( int32 iStartY, int32 iHeight )
{
if (mHeight == 0) { // there is no range already
// just set to the new range
mStartY = iStartY;
mHeight = iHeight;
} else if (mHeight == -1) { // the current range already extends to the bottom
// should the top be moved up?
if (iStartY < mStartY)
mStartY = iStartY;
} else if (iHeight == -1) { // the new range extendes all the way to the bottom
// should the top be moved up?
mHeight = iHeight;
if (iStartY < mStartY)
mStartY = iStartY;
} else {
if (iStartY < mStartY) {
// use the new top
if (iStartY + iHeight > mStartY + mHeight) {
// and the new height
mStartY = iStartY;
mHeight = iHeight;
} else {
// but the old height
mHeight += mStartY - iStartY;
mStartY = iStartY;
}
} else {
// use the old top
if (iStartY + iHeight > mStartY + mHeight) {
// but use the new height
mHeight = iStartY + iHeight - mStartY;
}
}
}
}
AEEventHandlerUPP HTMLInlineTSMProxy::sAEHandler = NewAEEventHandlerProc( AEHandlerTSM );
HTMLInlineTSMProxy *HTMLInlineTSMProxy::sCurrentProxy = NULL;
#if _HAVE_FIXES_FOR_REPLACING_AEGIZMOS_
void HTMLInlineTSMProxy::PasteFromPtr(const Ptr thedata, int32 len, short hiliteStyle)
{
if (len < 1)
return;
EDT_CharacterData *pData = EDT_NewCharacterData();
if (pData) {
pData->mask = TF_INLINEINPUT | TF_INLINEINPUTTHICK | TF_INLINEINPUTDOTTED;
switch (hiliteStyle) {
case kCaretPosition:
pData->values = TF_INLINEINPUT | TF_INLINEINPUTTHICK; // this is just a guess actually: FIX ME!!
break;
case kRawText:
pData->values = 0;
break;
case kSelectedRawText:
pData->values = TF_INLINEINPUT | TF_INLINEINPUTTHICK | TF_INLINEINPUTDOTTED;
break;
default:
XP_ASSERT(false);
case kConvertedText:
pData->values = TF_INLINEINPUT;
break;
case kSelectedConvertedText:
pData->values = TF_INLINEINPUT | TF_INLINEINPUTTHICK;
break;
}
EDT_SetCharacterData( mContext ,pData );
EDT_FreeCharacterData(pData);
}
// HACK HACK HACK
// ok, so everyone has been really helpful and all but I'm going to put this in as a hack
// rather than try to do it "right": unicodeString will either be "thedata" or the result
// if we need to do unicode conversion. We'll free this below if the pointer address has changed
char *unicodeString = thedata;
INTL_CharSetInfo csi = LO_GetDocumentCharacterSetInfo(mContext);
int16 win_csid = INTL_GetCSIWinCSID(csi);
if ( (win_csid == CS_UTF8) || (win_csid==CS_UTF7) ) {
INTL_Encoding_ID winCSID = ScriptToEncoding( ::GetScriptManagerVariable( smKeyScript ) );
unicodeString = (char *)INTL_ConvertLineWithoutAutoDetect( winCSID, CS_UTF8, (unsigned char *)thedata, len );
len = strlen(unicodeString);
}
if (len < 16) { // can we use a small static buffer?
char smallbuffer[16];
XP_MEMCPY(smallbuffer, unicodeString, len);
smallbuffer[len] = '\0';
EDT_InsertText(mContext, smallbuffer);
} else {
char *verytemp = (char *) XP_ALLOC(len + 1);
if (verytemp) {
XP_MEMCPY(verytemp, unicodeString, len);
verytemp[len] = '\0';
EDT_InsertText(mContext, verytemp);
XP_FREE(verytemp);
}
}
// see hack alert above
if ( unicodeString != thedata )
XP_FREEIF(unicodeString);
}
#endif _HAVE_FIXES_FOR_REPLACING_AEGIZMOS_
HTMLInlineTSMProxy::HTMLInlineTSMProxy( CEditView &inTextView )
: mTextView( inTextView )
{
mTSMDocID = 0;
OSType supportedType = kTextService;
OSErr err = ::NewTSMDocument( 1, &supportedType, &mTSMDocID, (long)(void *)this );
ThrowIfOSErr_(err);
mInputHoleActive = false;
mDocActive = false;
}
HTMLInlineTSMProxy::~HTMLInlineTSMProxy()
{
if ( mDocActive )
Deactivate(); // for a bug in TSM. See TE27
OSErr err = noErr;
if ( mTSMDocID )
err = ::DeleteTSMDocument(mTSMDocID);
mTSMDocID = 0;
// Assert_(err == noErr);
}
void
HTMLInlineTSMProxy::Activate( void )
{
OSErr err = noErr;
Assert_( mDocActive == false );
InstallTSMHandlers();
sCurrentProxy = this;
#ifdef Debug_Signal
// check to see if a bug in TSM will be encountered
ProcessSerialNumber psn,
csn;
err = GetCurrentProcess(&psn);
// ThrowIfOSErr_(err);
err = GetFrontProcess(&csn);
// ThrowIfOSErr_(err);
Assert_((psn.highLongOfPSN == csn.highLongOfPSN) && (psn.lowLongOfPSN == csn.lowLongOfPSN));
#endif
if ( mTSMDocID )
err = ::ActivateTSMDocument( mTSMDocID );
else
err = ::UseInputWindow(NULL, true);
// ThrowIfOSErr_(err);
if ( err == noErr )
mDocActive = true;
}
void
HTMLInlineTSMProxy::Deactivate( void )
{
OSErr err = noErr;
Assert_( mDocActive );
RemoveTSMHandlers();
sCurrentProxy = NULL;
err = ::DeactivateTSMDocument( mTSMDocID );
if (err != tsmDocNotActiveErr) // this just seems to happen too much -- it is okay if it happens
{
Assert_( err == noErr );
}
mDocActive = false;
}
void
HTMLInlineTSMProxy::FlushInput( void )
{
OSErr err = noErr;
Assert_( mTSMDocID != 0 );
if ( mTSMDocID != 0 )
{
err = ::FixTSMDocument( mTSMDocID );
}
}
void
HTMLInlineTSMProxy::InstallTSMHandlers( void )
{
OSErr err = noErr;
err = ::AEInstallEventHandler(kTextServiceClass, kUpdateActiveInputArea, sAEHandler, kUpdateActiveInputArea, false);
ThrowIfOSErr_(err);
err = ::AEInstallEventHandler(kTextServiceClass, kPos2Offset, sAEHandler, kPos2Offset, false);
ThrowIfOSErr_(err);
err = ::AEInstallEventHandler(kTextServiceClass, kOffset2Pos, sAEHandler, kOffset2Pos, false);
ThrowIfOSErr_(err);
}
void
HTMLInlineTSMProxy::RemoveTSMHandlers( void )
{
OSErr err = noErr;
err = ::AERemoveEventHandler(kTextServiceClass, kUpdateActiveInputArea, sAEHandler, false);
ThrowIfOSErr_(err);
err = ::AERemoveEventHandler(kTextServiceClass, kPos2Offset, sAEHandler, false);
ThrowIfOSErr_(err);
err = ::AERemoveEventHandler(kTextServiceClass, kOffset2Pos, sAEHandler, false);
ThrowIfOSErr_(err);
}
pascal OSErr
HTMLInlineTSMProxy::AEHandlerTSM( const AppleEvent *inAppleEvent, AppleEvent *outReply, Int32 inRefCon )
{
OSErr err = noErr;
THz oldZone = ::LMGetTheZone(), // Apple bug #115424?
appZone = ::LMGetApplZone();
::LMSetTheZone(appZone);
#if _HAVE_FIXES_FOR_REPLACING_AEGIZMOS_
try
{
Assert_( sCurrentProxy != NULL );
StHandleLocker lock(inAppleEvent->dataHandle);
LAESubDesc appleEvent(*inAppleEvent);
LAEStream replyStream;
ThrowIf_(((Int32)(void *)sCurrentProxy) != appleEvent.KeyedItem(keyAETSMDocumentRefcon).ToInt32());
replyStream.OpenRecord();
if ( sCurrentProxy != NULL )
{
switch( inRefCon )
{
case kUpdateActiveInputArea:
sCurrentProxy->AEUpdate(appleEvent);
break;
case kPos2Offset:
sCurrentProxy->AEPos2Offset(appleEvent, replyStream);
break;
case kOffset2Pos:
sCurrentProxy->AEOffset2Pos(appleEvent, replyStream);
break;
}
}
replyStream.CloseRecord();
// Transfer reply parameters to the real reply (hopefully MacOS 8 will have a way around this)
// ie, can simply say:
//
// replyStream.Close(outReply);
//
StAEDescriptor reply;
replyStream.Close(reply);
LAESubDesc replySD(reply);
AEKeyword key;
for (Int32 i = 1; i <= replySD.CountItems(); i++) {
StAEDescriptor parm;
replySD.NthItem(i, &key).ToDesc(&parm.mDesc);
err = ::AEPutParamDesc(outReply, key, &parm.mDesc);
ThrowIfOSErr_(err);
}
}
catch ( ExceptionCode inErr )
{
err = inErr;
}
catch ( ... )
{
err = paramErr;
}
#endif _HAVE_FIXES_FOR_REPLACING_AEGIZMOS_
::LMSetTheZone(oldZone); // Apple bug #115424?
return err;
}
#if _HAVE_FIXES_FOR_REPLACING_AEGIZMOS_
void HTMLInlineTSMProxy::AEUpdate(
const LAESubDesc &inAppleEvent )
{
CEditView::OutOfFocus(&mTextView);
HoldUpdatesProxy stopUpdatesProxy(mTextView);
// if we don't already have an input hole, remember where we are
if (!mInputHoleActive) {
mInputHoleActive = true;
mInputHoleStart = EDT_GetInsertPointOffset(mContext);
mInputHoleLen = 0;
}
// get the text in the input hole
LAESubDesc textSD(inAppleEvent.KeyedItem(keyAETheData), typeChar);
Ptr thedata = (const Ptr)textSD.GetDataPtr();
int32 len = textSD.GetDataLength();
// fixLength is the number of characters which can be fixed into the buffer.
Int32 fixLength = inAppleEvent.KeyedItem(keyAEFixLength).ToInt32();
if (fixLength < 0) // special signal to fix it all!!
fixLength = len;
mTextView.EraseCaret();
mTextView.HideCaret(true);
// if we do already have an input hole, select all the text and delete so that we start fresh
if (mInputHoleLen) {
EDT_CharacterData *temp = EDT_GetCharacterData( mContext );
EDT_SetInsertPointToOffset(mContext, mInputHoleStart, mInputHoleLen);
EDT_DeletePreviousChar(mContext);
if (temp) {
if (len) // if len == 0, then don't bother setting the character data because there is nothing left!
EDT_SetCharacterData( mContext, temp );
EDT_FreeCharacterData( temp );
}
}
// we will handle this special case because it makes the algorithm easier to understand.
// the input hole is going away because we are going to fix everything...
if (fixLength == len)
{
PasteFromPtr(thedata, fixLength, kRawText);
mInputHoleActive = false;
CEditView::OutOfFocus(&mTextView);
mTextView.HideCaret(false);
return;
}
// we have already selected the old data, now paste in anything that needs to be fixed
if (fixLength) {
PasteFromPtr(thedata, fixLength, kRawText);
mInputHoleStart = EDT_GetInsertPointOffset(mContext); // a new starting point for our input hole
}
if (inAppleEvent.KeyExists(keyAEHiliteRange)) {
LAESubDesc hiliteSD(inAppleEvent.KeyedItem(keyAEHiliteRange), typeTextRangeArray);
TextRangeArrayPtr p = (TextRangeArrayPtr)hiliteSD.GetDataPtr();
for (Int32 i = 0; i < p->fNumOfRanges; i++) {
TextRange record;
// we don't care about any extra information which is supposed to be encoded in the sign of any of these numbers
record.fStart = abs(p->fRange[i].fStart);
record.fEnd = abs(p->fRange[i].fEnd);
record.fHiliteStyle = abs(p->fRange[i].fHiliteStyle);
PasteFromPtr(thedata + fixLength + record.fStart, record.fEnd - record.fStart, record.fHiliteStyle);
}
}
mInputHoleLen = EDT_GetInsertPointOffset(mContext) - mInputHoleStart; // a new length for our input hole
// output
mTextView.HideCaret(false);
CEditView::OutOfFocus(&mTextView);
}
// so which is it?
#define keyAELeadingEdge keyAELeftSide
void HTMLInlineTSMProxy::AEPos2Offset(
const LAESubDesc &inAppleEvent,
LAEStream &inStream) const
{
// input
Point where;
Boolean dragging = false;
inAppleEvent.KeyedItem(keyAECurrentPoint).ToPtr(typeQDPoint, &where, sizeof(where));
LAESubDesc sd = inAppleEvent.KeyedItem(keyAEDragging);
if (sd.GetType() != typeNull) // keyAEdragging is optional
dragging = sd.ToBoolean();
// process
CEditView::OutOfFocus(&mTextView);
mTextView.FocusDraw(); // for GlobalToLocal
::GlobalToLocal(&where);
CEditView::OutOfFocus(&mTextView);
SPoint32 where32;
mTextView.LocalToImagePoint(where, where32);
LO_HitResult result;
LO_Hit(mContext, where32.h, where32.v, false, &result, nil);
if (result.type != LO_HIT_ELEMENT ||
// result.lo_hitElement.region != LO_HIT_ELEMENT_REGION_MIDDLE ||
result.lo_hitElement.position.element->type != LO_TEXT) {
inStream.WriteKey(keyAEOffset);
Int32 offset = -1;
inStream.WriteDesc(typeLongInteger, &offset, sizeof(offset));
inStream.WriteKey(keyAERegionClass);
short aShort = kTSMOutsideOfBody;
inStream.WriteDesc(typeShortInteger, &aShort, sizeof(aShort));
return;
}
ED_BufferOffset newPosition = EDT_LayoutElementToOffset( mContext, result.lo_hitElement.position.element, result.lo_hitElement.position.position);
/*
ED_BufferOffset saveSelStart, saveSelEnd;
EDT_GetSelectionOffsets(mContext, &saveSelStart, &saveSelEnd); // remember position
EDT_PositionCaret(mContext, where32.h, where32.v );
ED_BufferOffset newPosition = EDT_GetInsertPointOffset(mContext);
EDT_SetInsertPointToOffset(mContext, saveSelStart, saveSelEnd - saveSelStart); // restore position
*/
// restrict to the active range if you are dragging
if (dragging) {
if (newPosition < mInputHoleStart) newPosition = mInputHoleStart;
if (newPosition > mInputHoleStart + mInputHoleLen) newPosition = mInputHoleStart + mInputHoleLen;
}
// output
inStream.WriteKey(keyAEOffset);
Int32 offset = newPosition;
offset -= mInputHoleStart;
inStream.WriteDesc(typeLongInteger, &offset, sizeof(offset));
inStream.WriteKey(keyAERegionClass);
short aShort = kTSMOutsideOfBody;
SDimension32 sizeImage;
SDimension16 sizeFrame;
mTextView.GetImageSize(sizeImage);
mTextView.GetFrameSize(sizeFrame);
if ((0 <= where32.h) && (where32.h < sizeFrame.width) && (0 <= where32.v) && (where.v < sizeImage.height))
{
if (offset >= 0 && offset <= mInputHoleLen)
aShort = kTSMInsideOfActiveInputArea;
else
aShort = kTSMInsideOfBody;
}
inStream.WriteDesc(typeShortInteger, &aShort, sizeof(aShort));
}
void HTMLInlineTSMProxy::AEOffset2Pos(
const LAESubDesc &inAppleEvent,
LAEStream &inStream) const
{
// input
Int32 offset = inAppleEvent.KeyedItem(keyAEOffset).ToInt32();
offset += mInputHoleStart;
LO_Element * element;
int32 caretPos;
EDT_OffsetToLayoutElement(mContext, offset, &element, &caretPos);
SPoint32 where32;
int32 veryTemp;
GetCaretPosition( mContext, element, caretPos, &where32.h, &veryTemp, &where32.v );
Point where;
mTextView.ImageToLocalPoint(where32, where);
CEditView::OutOfFocus(&mTextView);
mTextView.FocusDraw(); // for LocalToGlobal
::LocalToGlobal(&where);
// output
inStream.WriteKey(keyAEPoint);
inStream.WriteDesc(typeQDPoint, &where, sizeof(where));
}
#endif _HAVE_FIXES_FOR_REPLACING_AEGIZMOS_

89
mozilla/cmd/macfe/central/TSMProxy.h
View File

@ -1,89 +0,0 @@
/* -*- 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 "CEditView.h"
class HoldUpdatesProxy
{
public:
HoldUpdatesProxy( CEditView &inTextView );
~HoldUpdatesProxy();
void DocumentChanged( int32 iStartY, int32 iHeight );
protected:
CEditView &mTextView;
int32 mStartY;
int32 mHeight;
};
class HTMLInlineTSMProxy //: public VTSMProxy
{
// friend class WTSMManager;
public:
HTMLInlineTSMProxy( CEditView &inTextView );
~HTMLInlineTSMProxy();
void SetContext( MWContext *inContext )
{
mContext = inContext;
};
virtual void Activate(void);
virtual void Deactivate(void);
virtual void FlushInput(void);
virtual void InstallTSMHandlers(void);
virtual void RemoveTSMHandlers(void);
static
pascal OSErr AEHandlerTSM( const AppleEvent *inAppleEvent, AppleEvent *outReply, Int32 inRefCon );
#if _HAVE_FIXES_FOR_REPLACING_AEGIZMOS_
protected:
virtual void AEUpdate( const LAESubDesc &inAppleEvent );
virtual void AEPos2Offset( const LAESubDesc &inAppleEvent, LAEStream &inStream ) const;
virtual void AEOffset2Pos( const LAESubDesc &inAppleEvent, LAEStream &inStream ) const;
void PasteFromPtr( const Ptr thedata, int32 len, short hiliteStyle );
#endif _HAVE_FIXES_FOR_REPLACING_AEGIZMOS_
int mInputHoleActive;
ED_BufferOffset mInputHoleStart; // since we have this...
int32 mInputHoleLen; // and this.
CEditView &mTextView;
MWContext *mContext;
TSMDocumentID mTSMDocID;
Boolean mDocActive;
static AEEventHandlerUPP sAEHandler;
static HTMLInlineTSMProxy *sCurrentProxy;
};

1911
mozilla/cmd/macfe/central/UFormElementFactory.cp
View File

File diff suppressed because it is too large Load Diff

149
mozilla/cmd/macfe/central/UFormElementFactory.h
View File

@ -1,149 +0,0 @@
/* -*- 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.
*/
// UFormElementFactory.h
#pragma once
// PowerPlant
#include <PP_Types.h>
// Backend
#include "ntypes.h" // for LO_* struct typedefs
#include "libi18n.h"
class CHTMLView;
class CNSContext;
class UFormElementFactory
{
public:
// Form Class Registration
static void RegisterFormTypes();
// Form Element Creation
static void MakeFormElem(
CHTMLView* inHTMLView,
CNSContext* inNSContext,
LO_FormElementStruct* formElem
);
static LPane* MakeTextFormElem(
CHTMLView* inHTMLView,
CNSContext* inNSContext,
Int32 &width,
Int32 &height,
Int32& baseline,
LO_FormElementStruct *formElem
);
static LPane* MakeReadOnlyFormElem(
CHTMLView* inHTMLView,
CNSContext* inNSContext,
Int32 &width,
Int32 &height,
Int32& baseline,
LO_FormElementStruct *formElem
);
static LPane* MakeTextArea(
CHTMLView* inHTMLView,
CNSContext* inNSContext,
Int32 &width,
Int32 &height,
Int32& baseline,
LO_FormElementStruct *formElem
);
static LPane* MakeButton(
CHTMLView* inHTMLView,
CNSContext* inNSContext,
Int32 &width,
Int32 &height,
Int32& baseline,
LO_FormElementStruct *formElem
);
static LPane* MakeFilePicker(
CHTMLView* inHTMLView,
CNSContext* inNSContext,
Int32 &width,
Int32 &height,
Int32& baseline,
LO_FormElementStruct *formElem
);
static LPane* MakeToggle(
CHTMLView* inHTMLView,
CNSContext* inNSContext,
Int32 &width,
Int32 &height,
Int32& baseline,
LO_FormElementStruct *formElem
);
static LPane* MakePopup (
CHTMLView* inHTMLView,
CNSContext* inNSContext,
Int32 &width,
Int32 &height,
Int32& baseline,
LO_FormElementStruct *formElem
);
static LPane* MakeList(
CHTMLView* inHTMLView,
CNSContext* inNSContext,
Int32 &width,
Int32 &height,
Int32& baseline,
LO_FormElementStruct *formElem
);
// Form Element Destruction
static void FreeFormElement(
LO_FormElementData *formElem
);
// Utility Routines
static void DisplayFormElement(
CNSContext* inNSContext,
LO_FormElementStruct* formElem
);
static void ResetFormElement(
LO_FormElementStruct *formElem,
Boolean redraw,
Boolean fromDefaults
);
static void SetFormElementToggle(
LO_FormElementStruct* formElem,
Boolean value
);
static void FormTextIsSubmit(
LO_FormElementStruct * formElem
);
static void GetFormElementValue(
LO_FormElementStruct *formElem,
Boolean hide
);
static void HideFormElement(
LO_FormElementStruct* formElem
);
static void ResetFormElementData(
LO_FormElementStruct *formElem,
Boolean redraw,
Boolean fromDefaults,
Boolean reflect
);
};

188
mozilla/cmd/macfe/central/ULocationIndependence.cp
View File

@ -1,188 +0,0 @@
/* -*- 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.
*/
// ULocationIndependence.cp - MacFE specific location independence code
#include "uapp.h"
#include "li_public.h"
#include "pprthred.h"
#include "plevent.h"
#include <LCommander.h>
// CLICommander
// Location independence commands
class CLICommander : public LCommander, public LEventDispatcher {
enum EQuitState {
eWaitingForUploadAll,
eUploadAllStarted,
eUploadAllComplete
};
public:
int fVerifyLoginCount;
int fNumOfCriticalFiles;
EQuitState fState;
// Constructors
CLICommander(LCommander * inSuper);
virtual ~CLICommander() {};
// Startup logic
static void GetCriticalClosure(void * closure, LIStatus result);
void GetCriticalFiles();
void VerifyLogin();
// Quit logic
virtual Boolean AttemptQuit(long inSaveOption);
private:
static void VerifyLoginCallback(void * closure, LIStatus result);
static void uploadAllClosure( void * closure, LIStatus result);
void UploadAllComplete(LIStatus status);
// Does a busy wait, while processing events
void WaitOnInt(int * boolean);
};
CLICommander::CLICommander(LCommander * inSuper)
: LCommander(inSuper)
{
fState = eWaitingForUploadAll;
/*
LIFile * file1 = new LIFile ("/Speedy/coreprofile/file1", "FirstFile", "Test file 1");
LIFile * file2 = new LIFile ("/Speedy/coreprofile/file2", "SecondFile", "Test file 2");
LIFile * file3 = new LIFile ("/Speedy/coreprofile/file3", "ThirdFile", "Test file 3");
fGroup = new LIClientGroup();
fGroup->addFile( file1, NULL, NULL, NULL, NULL);
fGroup->addFile( file2, NULL, NULL, NULL, NULL);
fGroup->addFile( file3, NULL, NULL, NULL, NULL);
*/
}
extern PREventQueue *mozilla_event_queue;
void CLICommander::GetCriticalFiles()
{
fNumOfCriticalFiles = 0;
LI_StartGettingCriticalFiles( &fNumOfCriticalFiles );
WaitOnInt(&fNumOfCriticalFiles);
}
void CLICommander::VerifyLoginCallback(void * closure, LIStatus result)
{
CLICommander * commander = (CLICommander*) closure;
commander->fVerifyLoginCount = 0;
}
void CLICommander::VerifyLogin()
{
fVerifyLoginCount = 1;
LIMediator::verifyLogin(VerifyLoginCallback, this);
WaitOnInt(&fVerifyLoginCount);
}
void CLICommander::WaitOnInt(int * waitInt)
{
EventRecord macEvent;
while (*waitInt > 0)
{
if (IsOnDuty()) {
::OSEventAvail(0, &macEvent);
AdjustCursor(macEvent);
}
SetUpdateCommandStatus(false);
Boolean gotEvent = ::WaitNextEvent(everyEvent, &macEvent,
1, mMouseRgnH);
// Let Attachments process the event. Continue with normal
// event dispatching unless suppressed by an Attachment.
if (LEventDispatcher::ExecuteAttachments(msg_Event, &macEvent)) {
if (gotEvent) {
DispatchEvent(macEvent);
} else {
UseIdleTime(macEvent);
}
}
// Repeaters get time after every event
LPeriodical::DevoteTimeToRepeaters(macEvent);
// Update status of menu items
if (IsOnDuty() && GetUpdateCommandStatus()) {
UpdateMenus();
}
// This pumps the mocha thread
PL_ProcessPendingEvents(mozilla_event_queue);
}
// We need to give time to idlers once again because:
// HTML conflict dialogs are being destroyed on a timer by libsec
// CreateStartupEnvironment() will not display any new windows if any HTML windows are visible
// => Must let timers run to destroy HTML dialogs before we proceed
macEvent.when = ::TickCount();
LPeriodical::DevoteTimeToIdlers(macEvent);
}
void CLICommander::uploadAllClosure( void * closure, LIStatus status)
{
CLICommander * c = (CLICommander*) closure;
c->UploadAllComplete(status);
}
void CLICommander::UploadAllComplete(LIStatus status)
{
fState = eUploadAllComplete;
LI_Shutdown();
(CFrontApp::GetApplication())->DoQuit();
}
Boolean CLICommander::AttemptQuit(long inSaveOption)
{
switch (fState)
{
case eWaitingForUploadAll:
LIMediator::uploadAll(uploadAllClosure, this);
break;
case eUploadAllStarted:
return false;
break;
case eUploadAllComplete:
return true; // We can quit now
}
return false;
}
#ifndef MOZ_LITE
// InitializeLocationIndependence
// Busy wait until all the Critical Files have been downloaded
void CFrontApp::InitializeLocationIndependence()
{
// LI_Startup();
// CLICommander * newCommander = new CLICommander(this);
// newCommander->VerifyLogin();
// newCommander->GetCriticalFiles();
}
#endif

218
mozilla/cmd/macfe/central/UMenuUtils.cp
View File

@ -1,218 +0,0 @@
/* -*- 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.
*/
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// UMenuUtils.cp
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
#include <UTextTraits.h>
#include <LString.h>
#include <string.h>
#include "UMenuUtils.h"
#include "cstring.h"
#include "net.h" // for NET_UnEscape
#ifndef __WINDOWS__
#include <WIndows.h>
#endif
#ifndef __LOWMEM__
#include <LowMem.h>
#endif
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
Uint8 UMenuUtils::sEnabledDummy[] = "\px";
Uint8 UMenuUtils::sDisabledDummy[] = "\p(x";
Uint8 UMenuUtils::sDisabledSep[] = "\p(-";
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void UMenuUtils::PurgeMenuItems(MenuHandle inMenu, Int16 inAfter)
{
Int16 theItemCount = ::CountMItems(inMenu) - inAfter;
while (theItemCount > 0)
{
::DeleteMenuItem(inMenu, inAfter + 1);
theItemCount--;
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
Int16 UMenuUtils::InsertMenuItem(
MenuHandle inMenu,
ConstStringPtr inText,
Int16 inAfter,
Boolean inEnabled)
{
Int16 theItemIndex;
Int16 theItemCount;
if (inAfter == 0)
theItemIndex = 1;
else
{
theItemCount = ::CountMItems(inMenu);
if (inAfter >= theItemCount)
theItemIndex = theItemCount + 1;
else
theItemIndex = inAfter + 1;
}
if (inEnabled)
::InsertMenuItem(inMenu, sEnabledDummy, inAfter);
else
::InsertMenuItem(inMenu, sDisabledDummy, inAfter);
::SetMenuItemText(inMenu, theItemIndex, inText);
return theItemIndex;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
Int16 UMenuUtils::AppendMenuItem(
MenuHandle inMenu,
ConstStringPtr inText,
Boolean inEnabled)
{
Int16 theItemIndex = ::CountMItems(inMenu) + 1;
if (inEnabled)
::AppendMenu(inMenu, sEnabledDummy);
else
::AppendMenu(inMenu, sDisabledDummy);
::SetMenuItemText(inMenu, theItemIndex, inText);
return theItemIndex;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void UMenuUtils::AppendSeparator(MenuHandle inMenu)
{
::AppendMenu(inMenu, sDisabledSep);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
Int32 UMenuUtils::PopupWithTraits(
MenuHandle inMenu,
Point inGlobalWhere,
Int16 inTopItem,
ResIDT inTraitsID)
{
TextTraitsH theTraits = UTextTraits::LoadTextTraits(inTraitsID);
CGrafPtr theWindowMgrPort;
::GetCWMgrPort(&theWindowMgrPort);
Int16 saveFontFam = LMGetSysFontFam();
Int16 saveFont = theWindowMgrPort->txFont;
Int16 saveSize = theWindowMgrPort->txSize;
Int16 saveFace = theWindowMgrPort->txFace;
theWindowMgrPort->txFont = (*theTraits)->fontNumber;
theWindowMgrPort->txSize = (*theTraits)->size;
theWindowMgrPort->txFace = (*theTraits)->style;
LMSetSysFontFam((*theTraits)->fontNumber);
Int32 theResult = ::PopUpMenuSelect(inMenu, inGlobalWhere.v, inGlobalWhere.h, inTopItem);
theWindowMgrPort->txFont = saveFont;
theWindowMgrPort->txSize = saveSize;
theWindowMgrPort->txFace = saveFace;
LMSetSysFontFam(saveFontFam);
return theResult;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// This is a copy of CreateMenuString that takes a char*
void UMenuUtils::AdjustStringForMenuTitle(cstring& inString)
{
// NET_UnEscape returns a char* which, for now, is
// just the string passed in
NET_UnEscape(inString);
if ( LString::CStringLength(inString) > 50 ) // Cut it down to reasonable size
{
inString[50] = '\0'; // truncate inString
inString += "...";
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ=
UInt16 UMenuUtils::GetMenuBarWidth()
{
GDHandle menuBarDevice;
Rect screenRect;
menuBarDevice = GetMainDevice();
screenRect = (**menuBarDevice).gdRect;
return screenRect.right - screenRect.left;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void UMenuUtils::ConvertToIconMenu(
MenuHandle inMenu,
ResIDT inIconResID)
{
Handle iconSuite;
if (GetMenuBarWidth() >= 640) return;
if (GetIconSuite(&iconSuite, inIconResID, kSelectorAllSmallData) == noErr)
{
// Set the menu title to exactly 5 characters in length.
SetMenuItemText(inMenu, 0, "\p12345");
char *menuData = *(char **)inMenu + sizeof(MenuInfo) - sizeof(Str255);
// Set the first byte of the title equal to 1 to indicate it's "iconized."
*(menuData + 1) = 1;
// Store the icon suite handle in the remaining 4 bytes of the title.
*(Handle *)(menuData + 2) = iconSuite;
}
}

67
mozilla/cmd/macfe/central/UMenuUtils.h
View File

@ -1,67 +0,0 @@
/* -*- 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.
*/
// UMenuUtils.h
#pragma once
#include <PP_Prefix.h>
#ifndef __MENUS__
#include <Menus.h>
#endif
class cstring;
class UMenuUtils
{
public:
static void PurgeMenuItems(MenuHandle inMenu, Int16 inAfter = 0);
static Int16 InsertMenuItem(
MenuHandle inMenu,
ConstStringPtr inText,
Int16 inAfter,
Boolean inEnabled = true);
static Int16 AppendMenuItem(
MenuHandle inMenu,
ConstStringPtr inText,
Boolean inEnabled = true);
static void AppendSeparator(MenuHandle inMenu);
static Int32 PopupWithTraits(
MenuHandle inMenu,
Point inGlobalWhere,
Int16 inTopItem = 1,
ResIDT inTraitsID = 0);
static void AdjustStringForMenuTitle(cstring& inString);
static void ConvertToIconMenu(MenuHandle inMenu, ResIDT inIconResID);
static UInt16 GetMenuBarWidth();
protected:
static Uint8 sEnabledDummy[];
static Uint8 sDisabledDummy[];
static Uint8 sDisabledSep[];
};

Some files were not shown because too many files have changed in this diff Show More