зеркало из https://github.com/mozilla/gecko-dev.git
1598 строки
42 KiB
C++
1598 строки
42 KiB
C++
/* -*- 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 "CBrowserApplicationsMediator.h"
|
|
#include "LTableView.h"
|
|
#include <LTableSingleSelector.h>
|
|
#include <LTableMonoGeometry.h>
|
|
#include <UModalDialogs.h>
|
|
#include <LArrayIterator.h>
|
|
|
|
#include "UGraphicGizmos.h"
|
|
#include "LGADialogBox.h"
|
|
#include "LGACheckbox.h"
|
|
#include "LGARadioButton.h"
|
|
#include "CLargeEditField.h"
|
|
|
|
#include "umimemap.h"
|
|
#include "macutil.h"
|
|
#include "resgui.h"
|
|
#include "prefAPI.h"
|
|
#include "macgui.h"
|
|
#include "np.h"
|
|
#include "uerrmgr.h"
|
|
#include "ufilemgr.h"
|
|
#include "miconutils.h"
|
|
#include "InternetConfig.h"
|
|
|
|
enum
|
|
{
|
|
eNormalTextTraits = 12003,
|
|
eGrayTextTraits = 12008,
|
|
eDescriptionField = 12507,
|
|
eMIMETypeField,
|
|
eSuffixes,
|
|
eCommunicatorRButton,
|
|
ePluginRButton,
|
|
ePluginPopupMenu,
|
|
eApplicationRButton,
|
|
eApplicationNameCaption,
|
|
eChooseApplicationButton,
|
|
eFileTypePopupMenu,
|
|
eSaveRButton,
|
|
eUnknownRButton
|
|
#ifdef ANTHRAX
|
|
, eAppletButton,
|
|
eAppletPopupMenu
|
|
#endif
|
|
};
|
|
|
|
#pragma mark --CMimeCell--
|
|
//------------------------------------------------------------------------------
|
|
// ¥ CMimeCell
|
|
//------------------------------------------------------------------------------
|
|
|
|
class CMimeCell
|
|
{
|
|
public:
|
|
CMimeCell(): mMapper(nil) ,mIcon(nil) { };
|
|
~CMimeCell();
|
|
CMimeMapper* mMapper;
|
|
Handle mIcon;
|
|
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ¥ ~CMimeCell
|
|
//------------------------------------------------------------------------------
|
|
// Frees the mapper and icon
|
|
//
|
|
CMimeCell::~CMimeCell()
|
|
{
|
|
delete mMapper;
|
|
if (mIcon)
|
|
::DisposeIconSuite(mIcon, true);
|
|
}
|
|
|
|
#pragma mark --CMimeTableView--
|
|
//------------------------------------------------------------------------------
|
|
// ¥ CMimeTableView
|
|
//------------------------------------------------------------------------------
|
|
class CMimeTableView : public LTableView, public LBroadcaster
|
|
{
|
|
private:
|
|
typedef LTableView Inherited;
|
|
public:
|
|
enum
|
|
{
|
|
class_ID = 'MmLP',
|
|
msg_SelectionChanged = 'SelÆ', // ioparam = this
|
|
msg_DoubleClick = '2Clk' // ioparam = this
|
|
};
|
|
|
|
CMimeTableView( LStream *inStream);
|
|
virtual ~CMimeTableView();
|
|
virtual void SelectionChanged();
|
|
void GetCellData( const STableCell &inCell, void *outDataPtr, Uint32 &ioDataSize) const;
|
|
void AddEntry ( CMimeCell** cellToAdd );
|
|
virtual void RemoveRows( Uint32 inHowMany, TableIndexT inFromRow, Boolean inRefresh = true);
|
|
Boolean MimeTypeExists(CMimeMapper* mapper);
|
|
|
|
protected:
|
|
virtual void ClickCell( const STableCell &inCell, const SMouseDownEvent &inMouseDown);
|
|
virtual void DrawCell( const STableCell& inCell , const Rect& inLocalRect );
|
|
virtual void FinishCreateSelf();
|
|
public:
|
|
LArray mMimeData;
|
|
|
|
};
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ CMimeTableView(LStream*)
|
|
// ---------------------------------------------------------------------------
|
|
// Construct from data in a Stream
|
|
//
|
|
CMimeTableView::CMimeTableView(
|
|
LStream *inStream)
|
|
: LTableView(inStream)
|
|
{
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ ~CMimeTableView
|
|
// ---------------------------------------------------------------------------
|
|
// Destructor
|
|
//
|
|
CMimeTableView::~CMimeTableView()
|
|
{
|
|
LArrayIterator iterator(mMimeData, LArrayIterator::from_Start);
|
|
CMimeCell* currentCell;
|
|
while (iterator.Next(¤tCell))
|
|
{
|
|
delete currentCell;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ FinishCreateSelf
|
|
// ---------------------------------------------------------------------------
|
|
// Sets up Table geometry and selector then loads the table with the current Mime
|
|
// types.
|
|
//
|
|
void CMimeTableView::FinishCreateSelf()
|
|
{
|
|
// Initialize Table
|
|
const Int32 colWidth = 321;
|
|
const Int32 rowHeight = 20;
|
|
mRows = 0;
|
|
mCols = 0;
|
|
mTableStorage = nil;
|
|
SetTableGeometry(new LTableMonoGeometry(this, colWidth, rowHeight));
|
|
SetTableSelector(new LTableSingleSelector(this));;
|
|
LTableView::InsertCols(1, 0, nil, 0, Refresh_No);
|
|
mUseDragSelect = false;
|
|
mCustomHilite = false;
|
|
mDeferAdjustment = false;
|
|
mRefreshAllWhenResized = false;
|
|
|
|
// Load in MimeData
|
|
for (TableIndexT i = 1; i <= CPrefs::sMimeTypes.GetCount(); i++) // Insert a row for each mime type
|
|
{
|
|
CMimeMapper * mime;
|
|
CPrefs::sMimeTypes.FetchItemAt(i, &mime);
|
|
ThrowIfNil_(mime);
|
|
if (!mime->IsTemporary())
|
|
{
|
|
CMimeMapper * duplicate = new CMimeMapper(*mime);
|
|
InsertRows(1, i);
|
|
CMimeCell* cell = new CMimeCell;
|
|
cell->mMapper = duplicate;
|
|
mMimeData.InsertItemsAt ( 1, i, &cell, sizeof( CMimeCell * ) );
|
|
}
|
|
}
|
|
Refresh();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ¥ AddEntry
|
|
//------------------------------------------------------------------------------
|
|
// Adds the passed in cell to the end of the table
|
|
//
|
|
void CMimeTableView::AddEntry ( CMimeCell** cellToAdd )
|
|
{
|
|
InsertRows( 1, mRows );
|
|
mMimeData.InsertItemsAt ( 1 , LArray::index_Last,cellToAdd, sizeof (CMimeCell * ));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ¥ RemoveRows
|
|
//------------------------------------------------------------------------------
|
|
//
|
|
void CMimeTableView::RemoveRows( Uint32 inHowMany, TableIndexT inFromRow, Boolean /* inRefresh */)
|
|
{
|
|
mMimeData.RemoveItemsAt(inHowMany, inFromRow);
|
|
Inherited::RemoveRows( inHowMany, inFromRow, true );
|
|
|
|
}
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ SelectionChanged
|
|
// ---------------------------------------------------------------------------
|
|
// Broadcast message when selected cells change
|
|
//
|
|
void CMimeTableView::SelectionChanged()
|
|
{
|
|
BroadcastMessage( msg_SelectionChanged, (void*) this);
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ GetCellData
|
|
// ---------------------------------------------------------------------------
|
|
// Pass back the data for a particular Cell
|
|
//
|
|
void CMimeTableView::GetCellData(
|
|
const STableCell &inCell,
|
|
void *outDataPtr,
|
|
Uint32 &ioDataSize) const
|
|
{
|
|
Assert_( ioDataSize >= sizeof ( CMimeCell* ) );
|
|
ioDataSize = sizeof( CMimeCell* );
|
|
if ( outDataPtr )
|
|
mMimeData.FetchItemAt( inCell.row, outDataPtr);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ ClickCell
|
|
// ---------------------------------------------------------------------------
|
|
// Broadcast message for a double-click on a cell
|
|
//
|
|
void CMimeTableView::ClickCell(
|
|
const STableCell& /* inCell */,
|
|
const SMouseDownEvent& /* inMouseDown */)
|
|
{
|
|
if (GetClickCount() == 2)
|
|
BroadcastMessage(msg_DoubleClick, (void*) this);
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ DrawCell
|
|
// ---------------------------------------------------------------------------
|
|
// Draw the contents of the specified Cell
|
|
//
|
|
void CMimeTableView::DrawCell(
|
|
const STableCell& inCell ,
|
|
const Rect& inLocalRect )
|
|
{
|
|
// Some constants used for drawing
|
|
const uint32 offsetTable = 7;
|
|
const uint32 offsetTextTop = 15;
|
|
const uint32 offsetMimeType = (offsetTable + 0);
|
|
const uint32 offsetIcon = (offsetTable + 166);
|
|
const uint32 offsetHandler = (offsetIcon + 24);
|
|
const uint32 widthMimeType = (offsetIcon - offsetMimeType - 5);
|
|
Rect cellFrame = inLocalRect;
|
|
|
|
::PenPat( &(UQDGlobals::GetQDGlobals()->gray) );
|
|
::MoveTo(cellFrame.left, cellFrame.bottom-1);
|
|
::LineTo(cellFrame.right, cellFrame.bottom-1);
|
|
::PenPat( &(UQDGlobals::GetQDGlobals()->black) );
|
|
UTextTraits::SetPortTextTraits(10000); // HACK
|
|
FontInfo textFontInfo;
|
|
::GetFontInfo( &textFontInfo);
|
|
|
|
CMimeCell* cellInfo = nil;
|
|
|
|
mMimeData.FetchItemAt( inCell.row, &cellInfo );
|
|
CMimeMapper* mapper = cellInfo->mMapper;
|
|
|
|
|
|
|
|
// Draw mime type
|
|
if (cellInfo->mMapper->IsLocked())
|
|
UTextTraits::SetPortTextTraits(eGrayTextTraits);
|
|
CStr255 description = mapper->GetDescription();
|
|
if (description.IsEmpty())
|
|
description = mapper->GetMimeName();
|
|
|
|
Rect textRect = cellFrame;
|
|
textRect.left += offsetTable;
|
|
textRect.right = widthMimeType;
|
|
textRect.top += 2;
|
|
textRect.bottom -= 2 ;
|
|
UGraphicGizmos::PlaceTextInRect(
|
|
(char *)description, description.Length(),
|
|
textRect, teFlushLeft, teJustCenter, &textFontInfo,true, smTruncMiddle );
|
|
|
|
|
|
|
|
// Draw the icon
|
|
CMimeMapper::LoadAction loadAction = mapper->GetLoadAction();
|
|
|
|
/*if ( loadAction == CMimeMapper::Launch ||
|
|
loadAction == CMimeMapper::Plugin ||
|
|
loadAction == CMimeMapper::Internal ) */
|
|
{
|
|
Rect r;
|
|
r.left = offsetIcon;
|
|
r.top = cellFrame.top + 2;
|
|
r.right = r.left + 16;
|
|
r.bottom = r.top + 16;
|
|
|
|
// Only create the icon when needed.
|
|
if( cellInfo->mIcon == nil )
|
|
{
|
|
OSType appSig = mapper->GetAppSig();
|
|
OSType docSig = 'APPL';
|
|
|
|
if( loadAction == CMimeMapper::Save )
|
|
docSig = mapper->GetDocType();
|
|
|
|
if( loadAction == CMimeMapper::Internal )
|
|
appSig = 'MOSS';
|
|
|
|
CIconUtils::GetDesktopIconSuite( appSig , docSig, kSmallIcon, &cellInfo->mIcon );
|
|
}
|
|
|
|
if ( cellInfo->mIcon )
|
|
::PlotIconSuite(&r, atHorizontalCenter, ttNone, cellInfo->mIcon);
|
|
|
|
}
|
|
|
|
// Draw the handler name
|
|
|
|
CStr255 handlerName;
|
|
switch (loadAction)
|
|
{
|
|
case CMimeMapper::Save:
|
|
handlerName = *GetString(SAVE_RESID);
|
|
break;
|
|
case CMimeMapper::Unknown:
|
|
handlerName = *GetString(UNKNOWN_RESID);
|
|
break;
|
|
case CMimeMapper::Internal:
|
|
handlerName = *GetString(INTERNAL_RESID);
|
|
break;
|
|
case CMimeMapper::Launch:
|
|
handlerName = mapper->GetAppName();
|
|
break;
|
|
case CMimeMapper::Plugin:
|
|
handlerName = mapper->GetPluginName();
|
|
break;
|
|
#ifdef ANTHRAX
|
|
case CMimeMapper::Applet:
|
|
handlerName = mapper->GetAppletName();
|
|
break;
|
|
#endif /* ANTHRAX */
|
|
}
|
|
|
|
textRect.left = offsetHandler;
|
|
textRect.right = inLocalRect.right;
|
|
if (cellInfo->mMapper->IsLocked())
|
|
UTextTraits::SetPortTextTraits(eGrayTextTraits);
|
|
UGraphicGizmos::PlaceTextInRect(
|
|
(char *) handlerName, handlerName.Length(),
|
|
textRect, teFlushLeft, teJustCenter, &textFontInfo,true, smTruncEnd );
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ MimeTypeExists
|
|
// ---------------------------------------------------------------------------
|
|
//
|
|
Boolean CMimeTableView::MimeTypeExists(CMimeMapper* mapper)
|
|
{
|
|
STableCell cell;
|
|
cell.col = 1;
|
|
|
|
CMimeCell* cellInfo = nil;
|
|
|
|
for (int i=1; i<= mRows; i++)
|
|
{
|
|
cell.row = i;
|
|
mMimeData.FetchItemAt( cell.row, &cellInfo );
|
|
if (cellInfo->mMapper != mapper &&
|
|
cellInfo->mMapper->GetMimeName() == mapper->GetMimeName())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
enum
|
|
{
|
|
eEditTypeDialogResID = 12008,
|
|
eHelperScroller = 12501,
|
|
eHelperTable,
|
|
eHelperNewButton,
|
|
eHelperEditButton,
|
|
eHelperDeleteButton,
|
|
eDownloadFilePicker
|
|
};
|
|
|
|
|
|
|
|
|
|
#pragma mark ---CEditMIMEWindow---
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ CEditMIMEWindow
|
|
// ---------------------------------------------------------------------------
|
|
//
|
|
|
|
#define msg_LaunchRadio 300 // Launch option changed
|
|
#define msg_BrowseApp 301 // Pick a new application
|
|
#define msg_FileTypePopup 302 // New file type picked
|
|
//msg_EditField // User typed in a field
|
|
#define msg_NewMimeType 303 // New Mime type
|
|
#define msg_NewMimeTypeOK 305 // Sent by newMimeType dialog window
|
|
//#define msg_ClearCell 306
|
|
#define msg_EditMimeType 307 // Edit Mime type
|
|
#define msg_DeleteMimeType 308 // Delete Mime type
|
|
#define msg_PluginPopup 309 // Pick a plug-in
|
|
|
|
|
|
class CEditMIMEWindow : public LGADialogBox
|
|
{
|
|
public:
|
|
enum { class_ID = 'EMMW' };
|
|
|
|
CEditMIMEWindow(LStream* inStream);
|
|
virtual ~CEditMIMEWindow();
|
|
|
|
virtual void ListenToMessage(MessageT inMessage, void* ioParam);
|
|
|
|
void SetCellInfo(CMimeCell *cell);
|
|
|
|
Boolean Modified() { return mModified; }
|
|
|
|
protected:
|
|
virtual void FinishCreateSelf();
|
|
|
|
private:
|
|
void UpdateMapperToUI();
|
|
void UpdateUIToMapper();
|
|
void SyncTextControls();
|
|
void UpdateRadioUItoMapper();
|
|
void SyncInternalControl();
|
|
void SyncApplicationControls(Boolean mimeTypeChanged);
|
|
void SyncPluginControls(Boolean mimeTypeChanged);
|
|
void BuildPluginMenu();
|
|
void BuildPluginList();
|
|
void DeletePluginList();
|
|
void BuildFileTypeMenu();
|
|
#ifdef ANTHRAX
|
|
void SyncAppletControls(Boolean mimeTypeChanged);
|
|
void BuildAppletList();
|
|
void BuildAppletMenu();
|
|
void DeleteAppletList();
|
|
#endif
|
|
|
|
CMimeMapper::LoadAction GetLoadAction();
|
|
|
|
Boolean mInitialized; // Initialized with fCellInfo yet?
|
|
Boolean mModified; // Have any MIMEs been modified?
|
|
|
|
|
|
CMimeCell* mCellInfo; // Data for selected item
|
|
char** mPluginList; // Null-terminated array of plug-in names
|
|
uint32 mPluginCount; // Number of plug-ins in array
|
|
|
|
LGAPopup *mFileTypePopup;
|
|
LGAPopup *mPluginPopup;
|
|
CLargeEditField *mDescriptionEditField;
|
|
CLargeEditField *mTypeEditField;
|
|
CLargeEditField *mExtensionEditField;
|
|
LGARadioButton *mRadioSave;
|
|
LGARadioButton *mRadioLaunch;
|
|
LGARadioButton *mRadioInternal;
|
|
LGARadioButton *mRadioUnknown;
|
|
LGARadioButton *mRadioPlugin;
|
|
// CFilePicker *mAppPicker;
|
|
LCaption *mAppName;
|
|
LButton *mAppButton;
|
|
// LCaption *mAppMenuLabel;
|
|
CStr255 mAppStr;
|
|
OSType mAppSig;
|
|
Boolean mLocked;
|
|
#ifdef ANTHRAX
|
|
LGARadioButton *mRadioApplet;
|
|
LGAPopup *mAppletPopup;
|
|
char** mAppletList;
|
|
uint32 mAppletCount;
|
|
#endif
|
|
}; // class CEditMIMEWindow
|
|
|
|
//-----------------------------------
|
|
CEditMIMEWindow::CEditMIMEWindow(LStream* inStream):
|
|
//-----------------------------------
|
|
LGADialogBox(inStream),
|
|
mModified(false),
|
|
mInitialized(false),
|
|
#ifdef ANTHRAX
|
|
mAppletList(nil),
|
|
mAppletCount(0),
|
|
#endif
|
|
mPluginList(nil),
|
|
mPluginCount(0),
|
|
mLocked( false )
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------
|
|
CEditMIMEWindow::~CEditMIMEWindow()
|
|
//-----------------------------------
|
|
{
|
|
DeletePluginList();
|
|
#ifdef ANTHRAX
|
|
DeleteAppletList();
|
|
#endif
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::FinishCreateSelf:
|
|
// Fiddle around with a few of our subviews once they've been created.
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::FinishCreateSelf()
|
|
{
|
|
// Cache pointers to all the controls
|
|
mFileTypePopup = (LGAPopup *)FindPaneByID(eFileTypePopupMenu);
|
|
XP_ASSERT(mFileTypePopup);
|
|
|
|
mPluginPopup = (LGAPopup *)FindPaneByID(ePluginPopupMenu);
|
|
XP_ASSERT(mPluginPopup);
|
|
|
|
mDescriptionEditField = (CLargeEditField *)FindPaneByID(eDescriptionField);
|
|
XP_ASSERT(mDescriptionEditField);
|
|
|
|
mTypeEditField = (CLargeEditField *)FindPaneByID(eMIMETypeField);
|
|
XP_ASSERT(mTypeEditField);
|
|
|
|
mExtensionEditField = (CLargeEditField *)FindPaneByID(eSuffixes);
|
|
XP_ASSERT(mExtensionEditField);
|
|
|
|
mRadioSave = (LGARadioButton *)FindPaneByID(eSaveRButton);
|
|
XP_ASSERT(mRadioSave);
|
|
|
|
mRadioLaunch = (LGARadioButton *)FindPaneByID(eApplicationRButton);
|
|
XP_ASSERT(mRadioLaunch);
|
|
|
|
mRadioInternal = (LGARadioButton *)FindPaneByID(eCommunicatorRButton);
|
|
XP_ASSERT(mRadioInternal);
|
|
|
|
mRadioUnknown = (LGARadioButton *)FindPaneByID(eUnknownRButton);
|
|
XP_ASSERT(mRadioUnknown);
|
|
|
|
mRadioPlugin = (LGARadioButton *)FindPaneByID(ePluginRButton);
|
|
XP_ASSERT(mRadioPlugin);
|
|
|
|
#ifdef ANTHRAX
|
|
mRadioApplet = (LGARadioButton *)FindPaneByID(eAppletButton);
|
|
XP_ASSERT(mRadioApplet);
|
|
|
|
mAppletPopup = (LGAPopup *)FindPaneByID(eAppletPopupMenu);
|
|
XP_ASSERT(mAppletPopup);
|
|
#endif /* ANTHRAX */
|
|
|
|
// mAppPicker = (CFilePicker *)FindPaneByID(eApplicationFilePicker);
|
|
// XP_ASSERT(mAppPicker);
|
|
|
|
mAppName = (LCaption *)FindPaneByID(eApplicationNameCaption);
|
|
XP_ASSERT(mAppName);
|
|
|
|
mAppButton = (LButton *)FindPaneByID(eChooseApplicationButton);
|
|
XP_ASSERT(mAppButton);
|
|
|
|
// mAppMenuLabel = (LCaption *)FindPaneByID(pref8AppMenuLabel);
|
|
// XP_ASSERT(mAppMenuLabel);
|
|
|
|
// Text fields cannot become broadcasters automatically because
|
|
// LinkListenerToControls expects fields to be descendants of LControl
|
|
// C++ vtable gets fucked up
|
|
mDescriptionEditField->AddListener(this);
|
|
mTypeEditField->AddListener(this);
|
|
mExtensionEditField->AddListener(this);
|
|
|
|
LGADialogBox::FinishCreateSelf();
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::SetCellInfo:
|
|
// After the CPrefHelpersContain creates us it calls this method to provide
|
|
// us with the info for the selected cell, which we copy. We can then
|
|
// synchronize our controls to the data they display.
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::SetCellInfo(CMimeCell* cellInfo)
|
|
{
|
|
mCellInfo = cellInfo;
|
|
UpdateUIToMapper();
|
|
mInitialized = true;
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::DeletePluginList:
|
|
// Delete the list of plug-ins.
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::DeletePluginList()
|
|
{
|
|
if (mPluginList)
|
|
{
|
|
uint32 index = 0;
|
|
|
|
while (mPluginList[index++])
|
|
{
|
|
free(mPluginList[index]);
|
|
}
|
|
free(mPluginList);
|
|
mPluginList = nil;
|
|
}
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::BuildPluginList:
|
|
// Build a list of plug-ins for this MIME type.
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::BuildPluginList()
|
|
{
|
|
// Delete the old list
|
|
DeletePluginList();
|
|
|
|
// Get the new list from XP code
|
|
mPluginList = NPL_FindPluginsForType(mCellInfo->mMapper->GetMimeName());
|
|
|
|
// Count how many are in the list
|
|
mPluginCount = 0;
|
|
if (mPluginList)
|
|
{
|
|
while (mPluginList[mPluginCount])
|
|
mPluginCount++;
|
|
}
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::BuildPluginMenu:
|
|
// Build the plug-in menu from the list of plug-ins available for the current
|
|
// MIME type. We need to redraw the popup if the plug-in list used to be non-
|
|
// empty or is non-empty now. (It's too expensive to try to detect the case
|
|
// of the plug-in list getting rebuilt but still containing the same items.)
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::BuildPluginMenu()
|
|
{
|
|
uint32 oldCount = mPluginCount;
|
|
|
|
BuildPluginList();
|
|
|
|
if (oldCount || mPluginCount)
|
|
{
|
|
SetMenuSizeForLGAPopup(mPluginPopup, mPluginCount);
|
|
|
|
MenuHandle menuH = mPluginPopup->GetMacMenuH();
|
|
uint32 index = 0;
|
|
uint32 desiredValue = 1; // Default desired value is first item
|
|
while (mPluginList[index])
|
|
{
|
|
SetMenuItemText(menuH, index+1, CStr255(mPluginList[index]));
|
|
::EnableItem(menuH, index+1);
|
|
if (mCellInfo->mMapper->GetPluginName() == mPluginList[index])
|
|
{
|
|
desiredValue = index + 1;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
//
|
|
// If the previously-selected plug-in name is in this list,
|
|
// select it; otherwise just select the first item.
|
|
// If we didn't change the control value, make sure it
|
|
// redraws since the contents of the list have changed.
|
|
//
|
|
uint32 previousValue = mPluginPopup->GetValue();
|
|
if (desiredValue != previousValue)
|
|
{
|
|
mPluginPopup->SetValue(desiredValue);
|
|
}
|
|
else
|
|
{
|
|
mPluginPopup->Refresh();
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef ANTHRAX
|
|
void CEditMIMEWindow::DeleteAppletList()
|
|
{
|
|
if (mAppletList)
|
|
{
|
|
uint32 index = 0;
|
|
|
|
while (mAppletList[index++])
|
|
{
|
|
free(mAppletList[index]);
|
|
}
|
|
free(mAppletList);
|
|
mAppletList = nil;
|
|
}
|
|
}
|
|
|
|
void CEditMIMEWindow::BuildAppletList()
|
|
{
|
|
// Delete the old list
|
|
DeleteAppletList();
|
|
|
|
// Get the new list from XP code - HACK!!!! for now
|
|
mAppletList = NPL_FindAppletsForType(mCellInfo->mMapper->GetMimeName());
|
|
|
|
// Count how many are in the list
|
|
mAppletCount = 0;
|
|
if (mAppletList)
|
|
{
|
|
while (mAppletList[mAppletCount])
|
|
mAppletCount++;
|
|
}
|
|
}
|
|
|
|
void CEditMIMEWindow::BuildAppletMenu()
|
|
{
|
|
uint32 oldCount = mAppletCount;
|
|
|
|
BuildAppletList();
|
|
|
|
if (oldCount || mAppletCount)
|
|
{
|
|
SetMenuSizeForLGAPopup(mAppletPopup, mAppletCount);
|
|
|
|
MenuHandle menuH = mAppletPopup->GetMacMenuH();
|
|
uint32 index = 0;
|
|
uint32 desiredValue = 1; // Default desired value is first item
|
|
while (mAppletList[index])
|
|
{
|
|
SetMenuItemText(menuH, index+1, CStr255(mAppletList[index]));
|
|
::EnableItem(menuH, index+1);
|
|
if (mCellInfo->mMapper->GetAppletName() == mAppletList[index])
|
|
{
|
|
desiredValue = index + 1;
|
|
}
|
|
index++;
|
|
}
|
|
|
|
//
|
|
// If the previously-selected applet name is in this list,
|
|
// select it; otherwise just select the first item.
|
|
// If we didn't change the control value, make sure it
|
|
// redraws since the contents of the list have changed.
|
|
//
|
|
uint32 previousValue = mAppletPopup->GetValue();
|
|
if (desiredValue != previousValue)
|
|
{
|
|
mAppletPopup->SetValue(desiredValue);
|
|
}
|
|
else
|
|
{
|
|
mAppletPopup->Refresh();
|
|
}
|
|
}
|
|
}
|
|
#endif /* ANTHRAX */
|
|
|
|
//struct BNDLIds
|
|
//{ // Utility structure for bundle parsing
|
|
// Int16 localID;
|
|
// Int16 resID;
|
|
//};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::BuildFileTypeMenu:
|
|
// Build the file-type menu from the list file types in the application info.
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::BuildFileTypeMenu()
|
|
{
|
|
|
|
CApplicationIconInfo* newInfo = NULL;
|
|
short refNum;
|
|
Handle bundle = NULL;
|
|
OSErr err;
|
|
Handle appIcon = NULL;
|
|
Boolean handlesAE = TRUE;
|
|
|
|
BNDLIds* iconOffset;
|
|
BNDLIds* frefOffset;
|
|
short numOfIcons;
|
|
short numOfFrefs; // Really number-1, just like in the resource
|
|
BNDLIds frefBNDL;
|
|
Handle iconFamily;
|
|
OSType iconType;
|
|
Handle frefRes = NULL;
|
|
|
|
Try_
|
|
{
|
|
SetResLoad( FALSE );
|
|
FSSpec appSpec;
|
|
OSErr err = CFileMgr::FindApplication( mAppSig, appSpec );
|
|
refNum = ::FSpOpenResFile( &appSpec,fsRdPerm );
|
|
err = ResError();
|
|
SetResLoad( TRUE );
|
|
ThrowIfOSErr_( err );
|
|
|
|
// BNDL
|
|
bundle = ::Get1IndResource( 'BNDL' , 1 );
|
|
ThrowIfNil_( bundle );
|
|
HLock( bundle );
|
|
HNoPurge( bundle );
|
|
// Get the signature
|
|
::BlockMoveData( *bundle, &mAppSig, 4 );
|
|
|
|
|
|
OSType resType;
|
|
Ptr bundlePtr = NULL;
|
|
|
|
bundlePtr = *bundle;
|
|
|
|
::BlockMoveData( bundlePtr + 8, &resType, 4 ); // Get the first resource type
|
|
if ( resType == 'ICN#' )
|
|
{
|
|
::BlockMoveData( bundlePtr + 12, &numOfIcons, 2 );
|
|
iconOffset = (BNDLIds*)( bundlePtr + 14 );
|
|
//::BlockMove( (Ptr)iconOffset + ( numOfIcons + 1) * sizeof( BNDLIds ), &resType, 4 ); // Just checkin'
|
|
::BlockMoveData( (Ptr)iconOffset + (numOfIcons + 1) * sizeof( BNDLIds ) + 4, &numOfFrefs, 2 );
|
|
frefOffset = (BNDLIds*)( (Ptr)iconOffset + 6 + ( numOfIcons + 1 ) * sizeof( BNDLIds ) );
|
|
}
|
|
else // FREF
|
|
{
|
|
::BlockMoveData( bundlePtr + 12, &numOfFrefs, 2 );
|
|
frefOffset = (BNDLIds*) (bundlePtr + 14 );
|
|
//::BlockMove( (Ptr)frefOffset + ( numOfFrefs + 1 ) * sizeof( BNDLIds ), &resType, 4 ); // Just checkin'
|
|
::BlockMoveData( (Ptr)frefOffset + ( numOfFrefs + 1 ) * sizeof( BNDLIds ) + 4, &numOfIcons, 2 );
|
|
iconOffset = (BNDLIds*)( (Ptr)frefOffset + 6 + (numOfFrefs + 1) * sizeof(BNDLIds) );
|
|
}
|
|
// We have the offsets for FREF and ICN# resources
|
|
// Not every FREF has a matching icon, so we read in all
|
|
// the FREFs and try to find the matching icon for each
|
|
|
|
|
|
MenuHandle menuH = mFileTypePopup->GetMacMenuH();
|
|
Int16 numMenuItems = ::CountMItems(menuH);
|
|
while ( numMenuItems > 0 )
|
|
{
|
|
::DeleteMenuItem(menuH, numMenuItems);
|
|
numMenuItems--;
|
|
}
|
|
|
|
|
|
for ( int i = 0; i <= numOfFrefs; i++ )
|
|
{
|
|
// Algorithm:
|
|
// Get the FREF resource specified in BNDL
|
|
// Find the ICN# resource from BNDL with same local ID
|
|
// Get the icon specified in ICN# resource.
|
|
// If getting of the icon fails in any case, use the default icon
|
|
frefBNDL = frefOffset[i];
|
|
iconFamily = NULL;
|
|
iconType = 'DUMB';
|
|
frefRes = ::Get1Resource( 'FREF', frefBNDL.resID );
|
|
if ( frefRes == NULL ) // Ignore the record if FREF resource is not found
|
|
continue;
|
|
::BlockMoveData( *frefRes, &iconType, 4 );
|
|
::ReleaseResource( frefRes );
|
|
|
|
if ( ( iconType == 'fold' ) || // folders are not files
|
|
( iconType == '****' ) || // any file will default to text later
|
|
( iconType == 'pref' ) || // prefs are also ignored
|
|
( iconType == 'PREF' ) )
|
|
continue;
|
|
|
|
if ( iconType == 'APPL' )
|
|
{
|
|
// Don't do anything
|
|
}
|
|
else
|
|
{ // Document icons
|
|
::AppendMenu(menuH, CStr255(iconType));
|
|
Int16 numMenuItems = ::CountMItems(menuH);
|
|
SetMenuItemText(menuH, numMenuItems, CStr255(iconType));
|
|
|
|
}
|
|
} // Done parsing all the file types
|
|
|
|
HUnlock( bundle );
|
|
HPurge( bundle );
|
|
ReleaseResource( bundle );
|
|
|
|
// Error handling: no file types
|
|
numMenuItems = ::CountMItems(menuH);
|
|
if ( numMenuItems == 0 ) // No icons were read, add 1 dummy one
|
|
{
|
|
::AppendMenu(menuH, CStr255(iconType));
|
|
|
|
SetMenuItemText(menuH, numMenuItems +1 , CStr255('TEXT'));
|
|
}
|
|
}
|
|
Catch_(inErr)
|
|
{
|
|
|
|
}
|
|
EndCatch_
|
|
mFileTypePopup->SetPopupMinMaxValues();
|
|
CloseResFile( refNum );
|
|
err = ResError();
|
|
}
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::SyncTextControls:
|
|
// Sync the edit text fields with their actual values (only called when
|
|
// the window is first created).
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::SyncTextControls()
|
|
{
|
|
XP_ASSERT(mCellInfo->mMapper != nil);
|
|
|
|
// MIME type
|
|
mAppStr = mCellInfo->mMapper->GetAppName();
|
|
mDescriptionEditField->SetDescriptor(mCellInfo->mMapper->GetDescription() );
|
|
|
|
// MIME type
|
|
mTypeEditField->SetDescriptor(mCellInfo->mMapper->GetMimeName());
|
|
|
|
// Extensions
|
|
mExtensionEditField->SetDescriptor(mCellInfo->mMapper->GetExtensions());
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::SyncRadioControlValues:
|
|
// Sync the radio buttons with their actual values (only called when
|
|
// the window is first created).
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::UpdateRadioUItoMapper()
|
|
{
|
|
switch (mCellInfo->mMapper->GetLoadAction() )
|
|
{
|
|
case CMimeMapper::Save:
|
|
mRadioSave->SetValue(1);
|
|
break;
|
|
case CMimeMapper::Launch:
|
|
mRadioLaunch->SetValue(1);
|
|
break;
|
|
case CMimeMapper::Internal:
|
|
mRadioInternal->SetValue(1);
|
|
break;
|
|
case CMimeMapper::Unknown:
|
|
mRadioUnknown->SetValue(1);
|
|
break;
|
|
case CMimeMapper::Plugin:
|
|
mRadioPlugin->SetValue(1);
|
|
break;
|
|
#ifdef ANTHRAX
|
|
case CMimeMapper::Applet:
|
|
mRadioApplet->SetValue(1);
|
|
break;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::SyncInternalControl:
|
|
// Sync up the "Use Netscape" radio button when the MIME type changes.
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::SyncInternalControl()
|
|
{
|
|
CStr255 newText;
|
|
mTypeEditField->GetDescriptor( newText);
|
|
if (CMimeMapper::NetscapeCanHandle( newText))
|
|
{
|
|
if( !mLocked )
|
|
mRadioInternal->Enable();
|
|
}
|
|
else
|
|
{
|
|
if (mRadioInternal->GetValue() == 1)
|
|
{
|
|
mRadioUnknown->SetValue(1);
|
|
}
|
|
mRadioInternal->Disable();
|
|
}
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::SyncApplicationControls:
|
|
// Sync up the application-related controls when the "Use application" radio
|
|
// button changes state, etc.
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::SyncApplicationControls(Boolean applicationChanged)
|
|
{
|
|
if (applicationChanged)
|
|
{
|
|
BuildFileTypeMenu();
|
|
}
|
|
|
|
Boolean enableAppControls = ( GetLoadAction() == CMimeMapper::Launch) && !mLocked;
|
|
|
|
//
|
|
// Application name
|
|
//
|
|
ResIDT oldTraits = mAppName->GetTextTraitsID();
|
|
if (enableAppControls)
|
|
{
|
|
mAppName->SetTextTraitsID(eNormalTextTraits); // Normal
|
|
mAppButton->Enable();
|
|
}
|
|
else
|
|
{
|
|
mAppName->SetTextTraitsID(eGrayTextTraits); // Dimmed
|
|
mAppButton->Disable();
|
|
}
|
|
if (applicationChanged)
|
|
{
|
|
mAppName->SetDescriptor( mAppStr);
|
|
}
|
|
|
|
else if (oldTraits != mAppName->GetTextTraitsID())
|
|
{
|
|
mAppName->Refresh();
|
|
}
|
|
|
|
//
|
|
// Popup enabled state
|
|
//
|
|
MenuHandle menuH = mFileTypePopup->GetMacMenuH();
|
|
Int16 numMenuItems = ::CountMItems(menuH);
|
|
if (enableAppControls && numMenuItems > 0 )
|
|
{
|
|
mFileTypePopup->Enable();
|
|
}
|
|
else
|
|
{
|
|
mFileTypePopup->Disable();
|
|
}
|
|
|
|
//
|
|
// File type
|
|
//
|
|
if (mRadioLaunch->GetValue() == 1)
|
|
{
|
|
#if 0
|
|
uint32 item = mFileTypePopup->GetValue();
|
|
XP_ASSERT(item > 0);
|
|
CFileType* fileType = mCellInfo->mIconInfo->GetFileType(item);
|
|
if (fileType)
|
|
{
|
|
mCellInfo->mMapper->SetDocType(fileType->fIconSig);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// CEditMIMEWindow::SyncPluginControls:
|
|
// Sync up the plugin-related controls when the "Use plugin" radio
|
|
// button changes state or the MIME type changes.
|
|
// ---------------------------------------------------------------------------
|
|
void CEditMIMEWindow::SyncPluginControls(Boolean mimeTypeChanged)
|
|
{
|
|
if (mimeTypeChanged)
|
|
{
|
|
BuildPluginMenu();
|
|
}
|
|
//
|
|
// Plug-in radio button enabled state
|
|
//
|
|
if (mPluginCount > 0)
|
|
{
|
|
mRadioPlugin->Enable();
|
|
}
|
|
else
|
|
{
|
|
mRadioPlugin->Disable();
|
|
if (mRadioPlugin->GetValue() == 1)
|
|
{
|
|
mRadioUnknown->SetValue(1);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Plug-in popup control enabled state
|
|
//
|
|
|
|
if (GetLoadAction() == CMimeMapper::Plugin && mPluginCount > 0)
|
|
{
|
|
mPluginPopup->Enable();
|
|
}
|
|
else
|
|
{
|
|
mPluginPopup->Disable();
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef ANTHRAX
|
|
void CEditMIMEWindow::SyncAppletControls(Boolean mimeTypeChanged)
|
|
{
|
|
if (mimeTypeChanged)
|
|
{
|
|
BuildAppletMenu();
|
|
}
|
|
//
|
|
// If we have an Applet installed, enable the radio button
|
|
//
|
|
if (mAppletCount > 0)
|
|
{
|
|
mRadioApplet->Enable();
|
|
}
|
|
else
|
|
{
|
|
mRadioApplet->Disable();
|
|
if (mRadioApplet->GetValue() == 1)
|
|
mRadioUnknown->SetValue(1);
|
|
}
|
|
|
|
//
|
|
// Determine the Applet popup control enabled state
|
|
//
|
|
|
|
if (GetLoadAction() == CMimeMapper::Applet && mAppletCount > 0)
|
|
{
|
|
mAppletPopup->Enable();
|
|
}
|
|
else
|
|
{
|
|
mAppletPopup->Disable();
|
|
}
|
|
}
|
|
#endif /* ANTHRAX */
|
|
|
|
CMimeMapper::LoadAction CEditMIMEWindow::GetLoadAction()
|
|
{
|
|
if (mRadioSave->GetValue() ) return CMimeMapper::Save ;
|
|
if ( mRadioLaunch->GetValue() ) return CMimeMapper::Launch;
|
|
if ( mRadioInternal->GetValue() ) return CMimeMapper::Internal;
|
|
if ( mRadioUnknown->GetValue() ) return CMimeMapper::Unknown;
|
|
if (mRadioPlugin ->GetValue() ) return CMimeMapper::Plugin;
|
|
#ifdef ANTHRAX
|
|
if(mRadioApplet->GetValue()) return CMimeMapper::Applet;
|
|
#endif
|
|
return CMimeMapper::Unknown;
|
|
}
|
|
|
|
//-----------------------------------
|
|
void CEditMIMEWindow::ListenToMessage(MessageT inMessage, void *ioParam)
|
|
// Process a message from the MIME types dialog
|
|
//-----------------------------------
|
|
{
|
|
if (!mInitialized)
|
|
return;
|
|
|
|
if ( ioParam == mRadioLaunch)
|
|
SyncApplicationControls(false);
|
|
if ( ioParam == mRadioPlugin )
|
|
SyncPluginControls(false);
|
|
#ifdef ANTHRAX
|
|
if(ioParam == mRadioApplet)
|
|
SyncAppletControls(false);
|
|
#endif
|
|
|
|
switch (inMessage)
|
|
{
|
|
// Pick a handler
|
|
case eSaveRButton:
|
|
case eApplicationRButton:
|
|
case eCommunicatorRButton:
|
|
case eUnknownRButton:
|
|
case ePluginRButton:
|
|
#ifdef ANTHRAX
|
|
case eAppletButton:
|
|
#endif
|
|
mModified = TRUE;
|
|
break;
|
|
|
|
// Pick a new application
|
|
case eChooseApplicationButton:
|
|
{
|
|
StandardFileReply reply;
|
|
CFilePicker::DoCustomGetFile(reply, CFilePicker::Applications, FALSE); // Pick app
|
|
if (reply.sfGood)
|
|
{
|
|
// set mappers properties from the app
|
|
FInfo finderInfo;
|
|
OSErr err = FSpGetFInfo(&reply.sfFile, &finderInfo);
|
|
mAppSig = finderInfo.fdCreator;
|
|
mAppStr = reply.sfFile.name;
|
|
SyncApplicationControls(true); // App changed
|
|
mModified = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Change the file type
|
|
case eFileTypePopupMenu:
|
|
{
|
|
SyncApplicationControls(false);
|
|
mModified = TRUE;
|
|
break;
|
|
}
|
|
|
|
// Change the plug-in
|
|
case ePluginPopupMenu:
|
|
{
|
|
SyncPluginControls(false);
|
|
mModified = TRUE;
|
|
break;
|
|
}
|
|
|
|
#ifdef ANTHRAX
|
|
case eAppletPopupMenu:
|
|
{
|
|
SyncAppletControls(false);
|
|
mModified = TRUE;
|
|
break;
|
|
}
|
|
#endif /* ANTHRAX */
|
|
|
|
// Edit some text
|
|
case msg_EditField2:
|
|
{
|
|
CStr255 newText;
|
|
|
|
mTypeEditField->GetDescriptor(newText);
|
|
if ( ioParam == mTypeEditField )
|
|
{
|
|
SyncPluginControls(true); // Plug-in choices depend on MIME type
|
|
SyncInternalControl(); // "Use Netscape" radio depends on MIME type
|
|
}
|
|
|
|
mModified = TRUE;
|
|
break;
|
|
}
|
|
|
|
case msg_OK:
|
|
UpdateMapperToUI();
|
|
break;
|
|
case msg_Cancel:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ¥ UpdateUIToMapper
|
|
//------------------------------------------------------------------------------
|
|
// Set up the controls in the dialog box (before it's visible) with the
|
|
// information from the currently selected cell. Note that the order of these
|
|
// unction calls is important
|
|
//
|
|
void CEditMIMEWindow::UpdateUIToMapper()
|
|
{
|
|
|
|
mAppSig = mCellInfo->mMapper->GetAppSig();
|
|
UpdateRadioUItoMapper();
|
|
SyncTextControls();
|
|
SyncInternalControl();
|
|
#ifdef ANTHRAX
|
|
SyncAppletControls(true);
|
|
#endif
|
|
SyncApplicationControls(true);
|
|
SyncPluginControls(true);
|
|
Int32 fileFlags = mCellInfo->mMapper->GetFileFlags();
|
|
Boolean flag = ( fileFlags & ICmap_resource_fork_mask ) > 0;
|
|
|
|
flag = (!(fileFlags & ICmap_not_outgoing_mask) )> 0;
|
|
mLocked = PREF_PrefIsLocked( CPrefs::Concat(mCellInfo->mMapper->GetBasePref(), ".mimetype") );
|
|
if( mLocked )
|
|
{
|
|
#ifdef ANTHRAX
|
|
for( PaneIDT i = eDescriptionField ; i<= eAppletPopupMenu ; i++ )
|
|
#else
|
|
for( PaneIDT i = eDescriptionField ; i<= eUnknownRButton ; i++ )
|
|
#endif
|
|
{
|
|
LPane* pane = FindPaneByID( i );
|
|
if( pane )
|
|
pane->Disable();
|
|
}
|
|
// Disable OK
|
|
LPane* view = FindPaneByID( 900 );
|
|
view->Disable();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ¥ UpdateMapperToUI
|
|
//------------------------------------------------------------------------------
|
|
// Update the UI for the original mapper
|
|
// The mediator is reponsible for actually commiting changes to the prefs
|
|
//
|
|
void CEditMIMEWindow::UpdateMapperToUI()
|
|
{
|
|
CStr255 newText;
|
|
// Description
|
|
mDescriptionEditField->GetDescriptor(newText);
|
|
mCellInfo->mMapper->SetDescription(newText);
|
|
|
|
// MimeType
|
|
mTypeEditField->GetDescriptor(newText);
|
|
mCellInfo->mMapper->SetMimeType(newText);
|
|
|
|
// Extension Fields
|
|
mExtensionEditField->GetDescriptor(newText);
|
|
mCellInfo->mMapper->SetExtensions(newText);
|
|
|
|
// Application Name and Signature
|
|
mCellInfo->mMapper->SetAppSig( mAppSig );
|
|
mCellInfo->mMapper->SetAppName ( mAppStr );
|
|
|
|
// load action
|
|
mCellInfo->mMapper->SetLoadAction( GetLoadAction() );
|
|
|
|
// Plug-in name
|
|
if (mRadioPlugin->GetValue() == 1)
|
|
{
|
|
uint32 item = mPluginPopup->GetValue();
|
|
XP_ASSERT(item > 0);
|
|
if (mPluginList && item > 0 && item <= mPluginCount)
|
|
{
|
|
char* plugin = mPluginList[item - 1]; // Menu is 1-based, list is 0-based
|
|
if (plugin)
|
|
mCellInfo->mMapper->SetPluginName(plugin);
|
|
}
|
|
}
|
|
#ifdef ANTHRAX
|
|
else if(mRadioApplet->GetValue() == 1)
|
|
{
|
|
uint32 item = mAppletPopup->GetValue();
|
|
XP_ASSERT(item > 0);
|
|
if (mAppletList && item > 0 && item <= mAppletCount)
|
|
{
|
|
char* applet = mAppletList[item - 1]; // Menu is 1-based, list is 0-based
|
|
if (applet)
|
|
mCellInfo->mMapper->SetAppletName(applet);
|
|
}
|
|
}
|
|
#endif
|
|
else
|
|
mCellInfo->mMapper->SetPluginName( "\p" );
|
|
|
|
// Since the App has changed, get rid of the old icon
|
|
if ( mCellInfo -> mIcon)
|
|
{
|
|
::DisposeIconSuite( mCellInfo->mIcon , true);
|
|
mCellInfo->mIcon = nil;
|
|
}
|
|
|
|
// XXX this file flag stuff might no longer be needed, but I'm not sure
|
|
Int32 fileFlags = 0;
|
|
mCellInfo->mMapper->SetFileFlags( fileFlags );
|
|
}
|
|
#pragma mark --CBrowserApplicationsMediator--
|
|
//------------------------------------------------------------------------------
|
|
// ¥ RegisterViewClasses
|
|
//------------------------------------------------------------------------------
|
|
//
|
|
void CBrowserApplicationsMediator::RegisterViewClasses()
|
|
{
|
|
RegisterClass_( CEditMIMEWindow);
|
|
RegisterClass_( CMimeTableView );
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ¥ CBrowserApplicationsMediator
|
|
//------------------------------------------------------------------------------
|
|
//
|
|
CBrowserApplicationsMediator::CBrowserApplicationsMediator(LStream*)
|
|
: CPrefsMediator(class_ID)
|
|
, mModified(false)
|
|
, mMIMETable(nil)
|
|
{
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ¥ EditMimeEntry
|
|
//------------------------------------------------------------------------------
|
|
// Brings up a property window for the selected Cell or
|
|
// if isNewEntry is true allows the user to add a new mime type
|
|
//
|
|
void CBrowserApplicationsMediator::EditMimeEntry( Boolean isNewEntry)
|
|
{
|
|
StDialogHandler theHandler(eEditTypeDialogResID, sWindow->GetSuperCommander());
|
|
CEditMIMEWindow* theDialog = (CEditMIMEWindow*)theHandler.GetDialog();
|
|
XP_ASSERT(theDialog);
|
|
UReanimator::LinkListenerToControls(theDialog, theDialog, eEditTypeDialogResID);
|
|
|
|
// Get the info that the dialog should display
|
|
CMimeCell* cellInfo = nil;
|
|
if( isNewEntry )
|
|
{
|
|
cellInfo = new CMimeCell;
|
|
CStr255 emptyType = "";
|
|
cellInfo->mMapper = CPrefs::CreateDefaultUnknownMapper(emptyType, FALSE);
|
|
}
|
|
else
|
|
{
|
|
STableCell cellToEdit = mMIMETable->GetFirstSelectedCell();
|
|
uint32 size = sizeof( cellInfo );
|
|
mMIMETable->GetCellData(cellToEdit, &cellInfo, size );
|
|
}
|
|
|
|
// Tell Dialog what to edit
|
|
theDialog->SetCellInfo( cellInfo);
|
|
|
|
// Let the user have at it...
|
|
theDialog->Show();
|
|
MessageT theMessage = msg_Nothing;
|
|
while ((theMessage != msg_Cancel) && (theMessage != msg_OK))
|
|
{
|
|
theMessage = theHandler.DoDialog();
|
|
|
|
if (theMessage == msg_OK &&
|
|
/* cellInfo->mMapper->GetMimeName() != cellInfo->mMapper->GetMimeName() && */
|
|
mMIMETable->MimeTypeExists(cellInfo->mMapper) )
|
|
{
|
|
ErrorManager::PlainAlert(mPREFS_DUPLICATE_MIME);
|
|
theMessage = msg_Nothing;
|
|
}
|
|
// The CEditMIMEWindow will handle all other messages
|
|
}
|
|
|
|
// Process the munged data as appropriate
|
|
if (theMessage == msg_OK && theDialog->Modified())
|
|
{
|
|
mModified = TRUE; // Remember that something changed
|
|
if( isNewEntry )
|
|
mMIMETable->AddEntry( &cellInfo );
|
|
mMIMETable->Refresh(); // Let table sync to the new data
|
|
|
|
}
|
|
else if ( isNewEntry )
|
|
{
|
|
delete cellInfo; // Throw away changes
|
|
}
|
|
}
|
|
|
|
|
|
void CBrowserApplicationsMediator::DeleteMimeEntry()
|
|
{
|
|
if (ErrorManager::PlainConfirm((const char*) GetCString(DELETE_MIMETYPE)))
|
|
{
|
|
XP_ASSERT(mMIMETable);
|
|
STableCell cellToDelete = mMIMETable->GetFirstSelectedCell();
|
|
|
|
CMimeCell* cellInfo = nil;
|
|
uint32 size = sizeof( CMimeCell * );
|
|
mMIMETable->GetCellData(cellToDelete, &cellInfo, size);
|
|
|
|
// Instead of freeing the item, add it to a list of deleted mime types
|
|
// and at commit time, delete the items from xp pref storage.
|
|
mDeletedTypes.LArray::InsertItemsAt(1, LArray::index_Last, &cellInfo);
|
|
|
|
mModified = TRUE;
|
|
|
|
mMIMETable->RemoveRows(1, cellToDelete.row);
|
|
|
|
// We want to select the cell immediately after the deleted one. It just so
|
|
// happens that its coordinates are now (after deleting), what the cell to
|
|
// delete was before. So we just need to select cellToDelete. However, if
|
|
// there is no cell after the deleted cell (it was the last one), then we
|
|
// just select the last one.
|
|
TableIndexT rows, columns;
|
|
mMIMETable->GetTableSize(rows, columns);
|
|
cellToDelete.row = cellToDelete.row > rows? rows: cellToDelete.row;
|
|
mMIMETable->ScrollCellIntoFrame(cellToDelete);
|
|
mMIMETable->SelectCell(cellToDelete);
|
|
mMIMETable->Refresh();
|
|
}
|
|
}
|
|
|
|
void CBrowserApplicationsMediator::ListenToMessage(MessageT inMessage, void *ioParam)
|
|
{
|
|
switch (inMessage)
|
|
{
|
|
case eHelperDeleteButton:
|
|
DeleteMimeEntry();
|
|
break;
|
|
|
|
case eHelperNewButton:
|
|
EditMimeEntry( true );
|
|
break;
|
|
|
|
case eHelperEditButton:
|
|
case CMimeTableView::msg_DoubleClick:
|
|
EditMimeEntry( false );
|
|
break;
|
|
|
|
case CMimeTableView::msg_SelectionChanged:
|
|
LButton *deleteButton = (LButton *)FindPaneByID(eHelperDeleteButton);
|
|
XP_ASSERT(deleteButton);
|
|
LButton *editButton = (LButton *)FindPaneByID(eHelperEditButton);
|
|
XP_ASSERT(editButton);
|
|
|
|
XP_ASSERT(ioParam);
|
|
STableCell cell = mMIMETable->GetFirstSelectedCell();
|
|
Boolean inactive;
|
|
Boolean locked = false;
|
|
if (cell.row > 0)
|
|
{
|
|
CMimeCell* cellInfo = nil;
|
|
uint32 size = sizeof( CMimeCell * );
|
|
mMIMETable->GetCellData(cell, &cellInfo, size );
|
|
locked = cellInfo->mMapper->IsLocked();
|
|
inactive = CMimeMapper::NetscapeCanHandle(cellInfo->mMapper->GetMimeName());
|
|
editButton->Enable();
|
|
}
|
|
else
|
|
{
|
|
inactive = true;
|
|
editButton->Disable();
|
|
}
|
|
if (inactive)
|
|
deleteButton->Disable();
|
|
else
|
|
{
|
|
if( locked == false )
|
|
deleteButton->Enable();
|
|
}
|
|
break;
|
|
default:
|
|
CPrefsMediator::ListenToMessage(inMessage, ioParam);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CBrowserApplicationsMediator::LoadMainPane()
|
|
{
|
|
CPrefsMediator::LoadMainPane();
|
|
mMIMETable = (CMimeTableView *)FindPaneByID(eHelperTable);
|
|
XP_ASSERT(mMIMETable);
|
|
mMIMETable->AddListener(this);
|
|
STableCell currentCell(1, 1); // This has to be done after
|
|
mMIMETable->SelectCell(currentCell); // mMIMETable->AddListener(); to set the buttons.
|
|
}
|
|
|
|
void CBrowserApplicationsMediator::WritePrefs()
|
|
{
|
|
if (mModified)
|
|
{
|
|
CPrefs::sMimeTypes.DeleteAll(FALSE);
|
|
XP_ASSERT(mMIMETable);
|
|
TableIndexT rows, cols;
|
|
mMIMETable->GetTableSize(rows, cols);
|
|
for (int i = 1; i <= rows; i++)
|
|
{
|
|
CMimeCell* cellInfo = nil;
|
|
uint32 size = sizeof( CMimeCell * );
|
|
STableCell cell( i, 1 );
|
|
mMIMETable->GetCellData( cell , &cellInfo, size);
|
|
|
|
cellInfo->mMapper->WriteMimePrefs();
|
|
CMimeMapper* mapper = new CMimeMapper(*cellInfo->mMapper);
|
|
CPrefs::sMimeTypes.InsertItemsAt(1, LArray::index_Last, &mapper);
|
|
}
|
|
|
|
for (Int32 i = 1; i <= mDeletedTypes.GetCount(); i++)
|
|
{
|
|
CMimeCell* mapper;
|
|
mDeletedTypes.FetchItemAt(i, &mapper);
|
|
PREF_DeleteBranch(mapper->mMapper->GetBasePref());
|
|
delete mapper;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBrowserApplicationsMediator::UpdateFromIC()
|
|
{
|
|
CFilePicker* filePicker = dynamic_cast< CFilePicker*>( FindPaneByID( 12506 ) );
|
|
XP_ASSERT( filePicker );
|
|
if( UseIC() )
|
|
{
|
|
FSSpec specFromIC;
|
|
if (!CInternetConfigInterface::GetFileSpec( kICDownloadFolder , specFromIC ) )
|
|
{
|
|
filePicker->SetFSSpec( specFromIC,false);
|
|
filePicker->Disable();
|
|
}
|
|
}
|
|
else
|
|
filePicker->Enable();
|
|
} |