1998-03-28 05:44:41 +03:00
|
|
|
|
/* -*- 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.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
// umimemap.cp
|
|
|
|
|
// CMimeMapper class and CMimeList
|
|
|
|
|
// Created by atotic, June 6th, 1994
|
|
|
|
|
// ===========================================================================
|
|
|
|
|
|
|
|
|
|
// Front End
|
|
|
|
|
#include "umimemap.h"
|
|
|
|
|
#include "macutil.h"
|
|
|
|
|
#include "resae.h"
|
|
|
|
|
#include "uapp.h"
|
|
|
|
|
#include "CAppleEventHandler.h"
|
|
|
|
|
#include "ulaunch.h"
|
|
|
|
|
#include "ufilemgr.h"
|
|
|
|
|
#include "uprefd.h"
|
|
|
|
|
#include "resgui.h"
|
|
|
|
|
#include "BufferStream.h"
|
|
|
|
|
|
|
|
|
|
// Netscape
|
|
|
|
|
#include "client.h"
|
|
|
|
|
#include "net.h"
|
|
|
|
|
// stdc
|
|
|
|
|
#include <String.h>
|
|
|
|
|
|
|
|
|
|
#include "uerrmgr.h"
|
|
|
|
|
#include "prefapi.h"
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
// class CMimeMapper
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
// <20><> Constructors/destructors
|
|
|
|
|
|
|
|
|
|
// Initialize all the variables to defaults
|
|
|
|
|
// Every initializer calls it
|
|
|
|
|
void CMimeMapper::InitMapper()
|
|
|
|
|
{
|
|
|
|
|
fTemporary = false; // This is only a temporary mapper
|
|
|
|
|
fRegisteredViewer = false; // This is a registered viewer, use all the special codes
|
|
|
|
|
fTempAppSig = '????'; // Application
|
|
|
|
|
fTempFileType = '????'; // File signature
|
|
|
|
|
fFromOldPrefs = false; // Was this mapper from pre-plugin prefs?
|
|
|
|
|
fLatentPlugin = false; // Was the plug-in disabled because it<69>s missing?
|
|
|
|
|
fLoadAction = CMimeMapper::Unknown;
|
|
|
|
|
fBasePref = nil; // Corresponding XP pref branch name
|
1998-06-23 05:36:59 +04:00
|
|
|
|
fIsLocked = false; // was this locked by Mission Control (disables edit and delete)
|
|
|
|
|
fNumChildrenFound = 0;
|
|
|
|
|
fFileFlags = 0;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Boolean
|
1998-06-23 05:36:59 +04:00
|
|
|
|
CMimeMapper::NetscapeCanHandle(const CStr255& mimeType)
|
1998-03-28 05:44:41 +03:00
|
|
|
|
{
|
|
|
|
|
return ((mimeType == IMAGE_GIF) ||
|
|
|
|
|
(mimeType == IMAGE_JPG) ||
|
|
|
|
|
(mimeType == IMAGE_XBM) ||
|
1998-06-23 05:36:59 +04:00
|
|
|
|
(mimeType == IMAGE_PNG) ||
|
1998-03-28 05:44:41 +03:00
|
|
|
|
(mimeType == APPLICATION_BINHEX) ||
|
|
|
|
|
(mimeType == HTML_VIEWER_APPLICATION_MIME_TYPE) ||
|
1998-06-23 05:36:59 +04:00
|
|
|
|
(mimeType == APPLICATION_PRE_ENCRYPTED) ||
|
1998-03-28 05:44:41 +03:00
|
|
|
|
(mimeType == TEXT_PLAIN));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// <20><> XP Prefs
|
|
|
|
|
//
|
|
|
|
|
// CMimeMapper is technically now redundant because all the information
|
|
|
|
|
// it contains is also reflected in xp prefs. Keeping duplicate
|
|
|
|
|
// structures is not ideal but it's minimal-impact.
|
|
|
|
|
//
|
|
|
|
|
// The xp pref routines are:
|
|
|
|
|
// - CreateMapperFor: creates a mapper corresponding to a specific
|
|
|
|
|
// xp mime pref (e.g. mime.image_gif)
|
|
|
|
|
// - ReadMimePref: converts an xp pref to a mapper (called from
|
|
|
|
|
// CreateMapperFor, and when xp prefs are updated by auto-config).
|
|
|
|
|
// - WriteMimePref: converts a mapper to its xp pref representation
|
|
|
|
|
// (called when initializing 3.0-format preferences, after editing
|
|
|
|
|
// a mime type from its pref UI, and when registering plug-ins).
|
|
|
|
|
|
|
|
|
|
static const char* Pref_MimeType = ".mimetype";
|
|
|
|
|
static const char* Pref_AppName = ".mac_appname";
|
|
|
|
|
static const char* Pref_AppSig = ".mac_appsig";
|
|
|
|
|
static const char* Pref_FileType = ".mac_filetype";
|
|
|
|
|
static const char* Pref_Extension = ".extension";
|
|
|
|
|
static const char* Pref_PluginName = ".mac_plugin_name";
|
|
|
|
|
static const char* Pref_Description = ".description";
|
|
|
|
|
static const char* Pref_LoadAction = ".load_action";
|
|
|
|
|
static const char* Pref_LatentPlugin = ".latent_plug_in";
|
1998-06-23 05:36:59 +04:00
|
|
|
|
static const char* Pref_FileFlags = ".file_flags";
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
|
|
// CreateMapperFor converts an xp pref name into a mimetype mapper.
|
|
|
|
|
// Finds an existing mapper or creates a new one, and
|
|
|
|
|
// populates its fields from user pref values.
|
|
|
|
|
CMimeMapper* CMimeMapper::CreateMapperFor( const char* basepref, Boolean newPrefFormat )
|
|
|
|
|
{
|
|
|
|
|
CMimeMapper* mapper = CPrefs::sMimeTypes.FindBasePref(basepref);
|
|
|
|
|
|
|
|
|
|
if (mapper) {
|
|
|
|
|
mapper->ReadMimePrefs();
|
|
|
|
|
return NULL; // already exists; caller doesn't use it.
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
mapper = new CMimeMapper(basepref);
|
|
|
|
|
// FromOldPrefs triggers plug-ins to install themselves as preferred viewers
|
|
|
|
|
mapper->fFromOldPrefs = !newPrefFormat;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
|
|
|
|
|
// Throw out this mime mapper if we didn't find any useful info about it in prefs
|
|
|
|
|
if (mapper->GetNumChildrenFound() <= 0)
|
|
|
|
|
{
|
|
|
|
|
delete mapper;
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return mapper;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// CreateMapperForRes converts a 3.0-format mime resource
|
|
|
|
|
// into both a mimetype mapper and xp prefs.
|
|
|
|
|
CMimeMapper* CMimeMapper::CreateMapperForRes(Handle res)
|
|
|
|
|
{
|
|
|
|
|
SInt8 flags = ::HGetState(res);
|
|
|
|
|
::HNoPurge(res);
|
|
|
|
|
|
|
|
|
|
CMimeMapper* mapper = new CMimeMapper( res );
|
|
|
|
|
::HSetState(res, flags);
|
|
|
|
|
|
|
|
|
|
if (mapper->fMimeType == HTML_VIEWER_APPLICATION_MIME_TYPE) {
|
|
|
|
|
mapper->SetLoadAction(CPrefs::sViewSourceInline ? Internal : Launch);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mapper->WriteMimePrefs(false); // convert to xp format
|
|
|
|
|
|
|
|
|
|
mapper->SetDefaultDescription();
|
|
|
|
|
|
|
|
|
|
return mapper;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Constructor to build mapper from xp prefs
|
|
|
|
|
CMimeMapper::CMimeMapper( const char* basepref )
|
|
|
|
|
{
|
|
|
|
|
InitMapper();
|
|
|
|
|
|
|
|
|
|
fBasePref = XP_STRDUP(basepref);
|
|
|
|
|
if (strlen(fBasePref) > 200)
|
|
|
|
|
fBasePref[200] = '\0';
|
|
|
|
|
ReadMimePrefs();
|
|
|
|
|
|
|
|
|
|
SetDefaultDescription();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Copies an xp mimetype pref into the mapper
|
|
|
|
|
void CMimeMapper::ReadMimePrefs()
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
int size = 256,
|
|
|
|
|
actualSize;
|
|
|
|
|
char value[256];
|
|
|
|
|
|
|
|
|
|
fAppSig = 0;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
|
|
|
|
|
fNumChildrenFound = 0; // keep track of how many mapper prefs we successfully read in from prefs file
|
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
|
err = PREF_GetCharPref( CPrefs::Concat(fBasePref, Pref_AppSig), value, &size );
|
|
|
|
|
if (PREF_NOERROR == err)
|
|
|
|
|
{
|
1998-06-23 05:36:59 +04:00
|
|
|
|
fNumChildrenFound++;
|
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
|
// values stored as binary (Base64) will always be longer than 4 bytes
|
|
|
|
|
// so if the string is 4 bytes long (or shorter), it's a straight character string
|
|
|
|
|
actualSize = strlen(value);
|
|
|
|
|
if (actualSize <= sizeof(OSType))
|
|
|
|
|
::BlockMoveData(value, (Ptr) &fAppSig, actualSize );
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
err = PREF_GetBinaryPref ( CPrefs::Concat( fBasePref, Pref_AppSig ), value, &size);
|
|
|
|
|
if (PREF_NOERROR == err)
|
|
|
|
|
::BlockMoveData( value, (Ptr) &fAppSig, sizeof(OSType) );
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fFileType = 0;
|
|
|
|
|
err = PREF_GetCharPref( CPrefs::Concat(fBasePref, Pref_FileType), value, &size );
|
|
|
|
|
if (PREF_NOERROR == err)
|
|
|
|
|
{
|
|
|
|
|
// see notes above for fAppSig
|
1998-06-23 05:36:59 +04:00
|
|
|
|
fNumChildrenFound++;
|
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
|
actualSize = strlen(value);
|
|
|
|
|
if (actualSize <= sizeof(OSType))
|
|
|
|
|
::BlockMoveData( value, (Ptr) &fFileType, actualSize );
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
err = PREF_GetBinaryPref ( CPrefs::Concat( fBasePref, Pref_FileType ), value, &size);
|
|
|
|
|
if (PREF_NOERROR == err)
|
|
|
|
|
::BlockMoveData( value, (Ptr) &fFileType, sizeof(OSType) );
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = PREF_GetCharPref( CPrefs::Concat(fBasePref, Pref_AppName), value, &size );
|
|
|
|
|
if (PREF_NOERROR == err)
|
1998-06-23 05:36:59 +04:00
|
|
|
|
{
|
|
|
|
|
fNumChildrenFound++;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
fAppName = value;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
|
|
err = PREF_GetCharPref( CPrefs::Concat(fBasePref, Pref_MimeType), value, &size );
|
|
|
|
|
if (PREF_NOERROR == err)
|
1998-06-23 05:36:59 +04:00
|
|
|
|
{
|
|
|
|
|
fNumChildrenFound++;
|
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
|
fMimeType = value;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
|
|
|
|
|
if (PREF_PrefIsLocked(CPrefs::Concat(fBasePref,Pref_MimeType))) //for mission control - this is a convienient place to check this
|
|
|
|
|
fIsLocked = true;
|
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
|
|
err = PREF_GetCharPref( CPrefs::Concat(fBasePref, Pref_Extension), value, &size );
|
|
|
|
|
if (PREF_NOERROR == err)
|
1998-06-23 05:36:59 +04:00
|
|
|
|
{
|
|
|
|
|
fNumChildrenFound++;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
fExtensions = value;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
|
err = PREF_GetCharPref( CPrefs::Concat(fBasePref, Pref_PluginName), value, &size );
|
|
|
|
|
if (PREF_NOERROR == err)
|
1998-06-23 05:36:59 +04:00
|
|
|
|
{
|
|
|
|
|
fNumChildrenFound++;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
fPluginName = value;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
|
|
err = PREF_GetCharPref( CPrefs::Concat(fBasePref, Pref_Description), value, &size );
|
|
|
|
|
if (PREF_NOERROR == err)
|
1998-06-23 05:36:59 +04:00
|
|
|
|
{
|
|
|
|
|
fNumChildrenFound++;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
fDescription = value;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
|
int32 intvalue;
|
|
|
|
|
err = PREF_GetIntPref( CPrefs::Concat(fBasePref, Pref_LoadAction), &intvalue );
|
|
|
|
|
if (PREF_NOERROR == err)
|
1998-06-23 05:36:59 +04:00
|
|
|
|
{
|
|
|
|
|
fNumChildrenFound++;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
fLoadAction = (LoadAction) intvalue;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
}
|
|
|
|
|
err = PREF_GetIntPref( CPrefs::Concat(fBasePref, Pref_FileFlags), &intvalue );
|
|
|
|
|
if (PREF_NOERROR == err)
|
|
|
|
|
{
|
|
|
|
|
fFileFlags = intvalue;
|
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
|
|
|
|
|
|
XP_Bool boolvalue;
|
|
|
|
|
err = PREF_GetBoolPref( CPrefs::Concat(fBasePref, Pref_LatentPlugin), &boolvalue );
|
|
|
|
|
if (PREF_NOERROR == err)
|
1998-06-23 05:36:59 +04:00
|
|
|
|
{
|
|
|
|
|
fNumChildrenFound++;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
fLatentPlugin = (Boolean) boolvalue;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
}
|
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// -- For 3.0 format compatability --
|
|
|
|
|
// Initializes off a resource handle of one of the mime types.
|
|
|
|
|
// See pref.r for resource definition
|
|
|
|
|
// The memory layout of the resource is very important.
|
|
|
|
|
#define NAME_LENGTH_OFFSET 9
|
|
|
|
|
CMimeMapper::CMimeMapper( Handle resRecord )
|
|
|
|
|
{
|
|
|
|
|
ThrowIfNil_(resRecord);
|
|
|
|
|
Size size = ::GetHandleSize(resRecord);
|
|
|
|
|
InitMapper();
|
|
|
|
|
|
|
|
|
|
char temp[256];
|
|
|
|
|
Ptr resPtr = *resRecord;
|
|
|
|
|
Byte lengthByte = 0;
|
|
|
|
|
long offset = 0;
|
|
|
|
|
|
|
|
|
|
ThrowIf_(size < 9);
|
|
|
|
|
::BlockMoveData( resPtr, (Ptr)&fAppSig, 4 );
|
|
|
|
|
::BlockMoveData( resPtr + 4, (Ptr)&fFileType, 4 );
|
|
|
|
|
uint32 loadAction = *((unsigned char*) (resPtr + 8));
|
|
|
|
|
fLoadAction = (LoadAction) loadAction;
|
|
|
|
|
|
|
|
|
|
offset = NAME_LENGTH_OFFSET;
|
|
|
|
|
ThrowIf_(offset > size);
|
|
|
|
|
// <20> read the application name
|
|
|
|
|
lengthByte = resPtr[ offset ];
|
|
|
|
|
ThrowIf_(lengthByte > 255);
|
|
|
|
|
::BlockMoveData( &resPtr[ offset + 1 ], (Ptr)temp, lengthByte );
|
|
|
|
|
|
|
|
|
|
temp[ lengthByte ] = 0;
|
|
|
|
|
|
|
|
|
|
fAppName = temp;
|
|
|
|
|
|
|
|
|
|
// <20> read in the MIME type
|
|
|
|
|
offset += ( lengthByte + 1 );
|
|
|
|
|
ThrowIf_(offset > size);
|
|
|
|
|
lengthByte = resPtr[ offset ];
|
|
|
|
|
::BlockMoveData( &resPtr[ offset + 1 ], temp, lengthByte );
|
|
|
|
|
|
|
|
|
|
temp[ lengthByte ] = 0;
|
|
|
|
|
|
|
|
|
|
fMimeType = temp;
|
|
|
|
|
|
|
|
|
|
// <20> read in the extensions string
|
|
|
|
|
offset += ( lengthByte + 1 );
|
|
|
|
|
ThrowIf_(offset > size);
|
|
|
|
|
lengthByte = resPtr[ offset ];
|
|
|
|
|
ThrowIf_(lengthByte > 255);
|
|
|
|
|
::BlockMove ( &resPtr[ offset + 1 ], temp, lengthByte );
|
|
|
|
|
|
|
|
|
|
temp[ lengthByte ] = 0;
|
|
|
|
|
|
|
|
|
|
fExtensions = temp;
|
|
|
|
|
|
|
|
|
|
// <20> read in the plug-in name string
|
|
|
|
|
// Since the plug-in name doesn't exist in 2.0-vintage prefs resources, make
|
|
|
|
|
// sure to check that there is still data left in the handle before proceeding.
|
|
|
|
|
offset += ( lengthByte + 1 );
|
|
|
|
|
if (offset < size)
|
|
|
|
|
{
|
|
|
|
|
lengthByte = resPtr[ offset ];
|
|
|
|
|
ThrowIf_(lengthByte > 255);
|
|
|
|
|
::BlockMove ( &resPtr[ offset + 1 ], temp, lengthByte );
|
|
|
|
|
temp[ lengthByte ] = 0;
|
|
|
|
|
fPluginName = temp;
|
|
|
|
|
|
|
|
|
|
// Now read the description string (it too could be non-existant)
|
|
|
|
|
offset += ( lengthByte + 1 );
|
|
|
|
|
if (offset < size)
|
|
|
|
|
{
|
|
|
|
|
lengthByte = resPtr[ offset ];
|
|
|
|
|
ThrowIf_(lengthByte > 255);
|
|
|
|
|
::BlockMove ( &resPtr[ offset + 1 ], temp, lengthByte );
|
|
|
|
|
temp[ lengthByte ] = 0;
|
|
|
|
|
fDescription = temp;
|
|
|
|
|
|
|
|
|
|
// Last, read the "latent plug-in" flag (if it exists)
|
|
|
|
|
offset += ( lengthByte + 1 );
|
|
|
|
|
if (offset < size)
|
|
|
|
|
{
|
|
|
|
|
Boolean latentPlugin = *((unsigned char*) (resPtr + offset));
|
|
|
|
|
XP_ASSERT(latentPlugin == 0 || latentPlugin == 1);
|
|
|
|
|
fLatentPlugin = latentPlugin;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fPluginName = "";
|
|
|
|
|
fFromOldPrefs = true; // No plug-in info in these prefs
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
|
// For old prefs that don't have a description stored in the handle,
|
|
|
|
|
// look up the default description in netlib, defaulting to just the
|
|
|
|
|
// MIME type itself if it can't be found. This description will then
|
|
|
|
|
// get written out to the prefs so it can be edited and saved by the user.
|
|
|
|
|
//
|
|
|
|
|
void CMimeMapper::SetDefaultDescription()
|
|
|
|
|
{
|
|
|
|
|
if (fMimeType == HTML_VIEWER_APPLICATION_MIME_TYPE)
|
|
|
|
|
return;
|
|
|
|
|
|
1998-06-23 05:36:59 +04:00
|
|
|
|
if (fNumChildrenFound <= 0 && fMimeType == CStr255::sEmptyString) // this means the pref did not even come with a mime type, so we ignore it.
|
|
|
|
|
return;
|
|
|
|
|
|
1998-03-28 05:44:41 +03:00
|
|
|
|
CStr255 description;
|
|
|
|
|
char* mimetype = (char*) fMimeType;
|
|
|
|
|
NET_cdataStruct* cdata = NULL;
|
|
|
|
|
XP_List* list_ptr = cinfo_MasterListPointer();
|
|
|
|
|
while ((cdata = (NET_cdataStruct*) XP_ListNextObject(list_ptr)) != NULL)
|
|
|
|
|
if (strcasecomp(mimetype, cdata->ci.type) == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
if (cdata && cdata->ci.desc)
|
|
|
|
|
description = cdata->ci.desc;
|
|
|
|
|
else
|
|
|
|
|
description = fMimeType;
|
|
|
|
|
|
|
|
|
|
if (fDescription == CStr255::sEmptyString) {
|
|
|
|
|
fDescription = description;
|
|
|
|
|
CPrefs::SetModified();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
PREF_SetDefaultCharPref( CPrefs::Concat(fBasePref, Pref_Description), description );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Duplicate
|
|
|
|
|
CMimeMapper::CMimeMapper( const CMimeMapper& clone )
|
|
|
|
|
{
|
|
|
|
|
InitMapper();
|
|
|
|
|
fMimeType = clone.fMimeType;
|
|
|
|
|
fAppName = clone.fAppName;
|
|
|
|
|
fAppSig = clone.fAppSig;
|
|
|
|
|
fFileType = clone.fFileType;
|
|
|
|
|
fLoadAction = clone.fLoadAction;
|
|
|
|
|
fExtensions = clone.fExtensions;
|
|
|
|
|
|
|
|
|
|
fTemporary = clone.fTemporary;
|
|
|
|
|
fRegisteredViewer = clone.fRegisteredViewer;
|
|
|
|
|
fTempAppSig = clone.fTempAppSig; // Application
|
|
|
|
|
fTempFileType = clone.fTempFileType; // File signature
|
|
|
|
|
|
|
|
|
|
fPluginName = clone.fPluginName;
|
|
|
|
|
fFromOldPrefs = clone.fFromOldPrefs;
|
|
|
|
|
fDescription = clone.fDescription;
|
|
|
|
|
fLatentPlugin = clone.fLatentPlugin;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
fFileFlags = clone.fFileFlags;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
fBasePref = clone.fBasePref ? XP_STRDUP(clone.fBasePref) : nil;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
|
|
|
|
|
fIsLocked = clone.fIsLocked;
|
|
|
|
|
|
|
|
|
|
fNumChildrenFound = clone.fNumChildrenFound;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Copies values from the mapper to xp user pref tree.
|
|
|
|
|
void CMimeMapper::WriteMimePrefs( Boolean )
|
|
|
|
|
{
|
|
|
|
|
if (fBasePref == nil) {
|
|
|
|
|
// Convert mime type to a pref-name string with
|
|
|
|
|
// non-alpha chars replaced with underscores
|
|
|
|
|
char typecopy[256];
|
|
|
|
|
strcpy(typecopy, "mime.");
|
|
|
|
|
int start = strlen(typecopy);
|
|
|
|
|
strncat(typecopy, (char*) fMimeType, 200);
|
|
|
|
|
for (int i = start; i < strlen(typecopy); i++)
|
|
|
|
|
if (!isalnum(typecopy[i]))
|
|
|
|
|
typecopy[i] = '_';
|
|
|
|
|
|
|
|
|
|
// Mimetype may be blank, so pick an arbitrary name
|
|
|
|
|
if (fMimeType.Length() == 0)
|
|
|
|
|
strcat(typecopy, "unknown_type_999");
|
|
|
|
|
|
|
|
|
|
fBasePref = XP_STRDUP(typecopy);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char appsig[sizeof(OSType)+1], filetype[sizeof(OSType)+1];
|
|
|
|
|
appsig[sizeof(OSType)] = '\0';
|
|
|
|
|
::BlockMoveData( (Ptr) &fAppSig, appsig, sizeof(OSType) );
|
|
|
|
|
filetype[sizeof(OSType)] = '\0';
|
|
|
|
|
::BlockMoveData( (Ptr) &fFileType, filetype, sizeof(OSType) );
|
|
|
|
|
|
|
|
|
|
PREF_SetCharPref( CPrefs::Concat(fBasePref, Pref_Extension), fExtensions );
|
1998-06-23 05:36:59 +04:00
|
|
|
|
fNumChildrenFound++; // since we are creating children prefs, we should keep this record updated
|
1998-03-28 05:44:41 +03:00
|
|
|
|
if (fDescription.Length() > 0)
|
1998-06-23 05:36:59 +04:00
|
|
|
|
{
|
1998-03-28 05:44:41 +03:00
|
|
|
|
PREF_SetCharPref( CPrefs::Concat(fBasePref, Pref_Description), fDescription );
|
1998-06-23 05:36:59 +04:00
|
|
|
|
fNumChildrenFound++;
|
|
|
|
|
}
|
1998-03-28 05:44:41 +03:00
|
|
|
|
PREF_SetCharPref( CPrefs::Concat(fBasePref, Pref_MimeType), fMimeType );
|
|
|
|
|
PREF_SetCharPref( CPrefs::Concat(fBasePref, Pref_AppName), fAppName );
|
|
|
|
|
PREF_SetCharPref( CPrefs::Concat(fBasePref, Pref_PluginName), fPluginName );
|
1998-06-23 05:36:59 +04:00
|
|
|
|
fNumChildrenFound += 3;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
// store appsig and filetype as 4-byte character strings, if possible.
|
|
|
|
|
// otherwise, store as binary.
|
|
|
|
|
if (PrintableChars( &appsig, sizeof(OSType)))
|
|
|
|
|
PREF_SetCharPref( CPrefs::Concat(fBasePref, Pref_AppSig), appsig );
|
|
|
|
|
else
|
|
|
|
|
PREF_SetBinaryPref( CPrefs::Concat(fBasePref, Pref_AppSig), appsig, sizeof(OSType));
|
|
|
|
|
if (PrintableChars( &filetype, sizeof(OSType)))
|
|
|
|
|
PREF_SetCharPref( CPrefs::Concat(fBasePref, Pref_FileType), filetype );
|
|
|
|
|
else
|
|
|
|
|
PREF_SetBinaryPref( CPrefs::Concat(fBasePref, Pref_FileType), filetype, sizeof(OSType));
|
|
|
|
|
PREF_SetIntPref( CPrefs::Concat(fBasePref, Pref_LoadAction), fLoadAction );
|
|
|
|
|
PREF_SetBoolPref( CPrefs::Concat(fBasePref, Pref_LatentPlugin), (XP_Bool) fLatentPlugin );
|
1998-06-23 05:36:59 +04:00
|
|
|
|
PREF_SetIntPref ( CPrefs::Concat(fBasePref, Pref_FileFlags ), fFileFlags );
|
|
|
|
|
fNumChildrenFound += 4;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CMimeMapper::CMimeMapper(
|
|
|
|
|
LoadAction loadAction,
|
|
|
|
|
const CStr255& mimeType,
|
|
|
|
|
const CStr255& appName,
|
|
|
|
|
const CStr255& extensions,
|
|
|
|
|
OSType appSignature,
|
|
|
|
|
OSType fileType )
|
|
|
|
|
{
|
|
|
|
|
fLoadAction = loadAction;
|
|
|
|
|
fMimeType = mimeType;
|
|
|
|
|
fAppName = appName;
|
|
|
|
|
fAppSig = appSignature;
|
|
|
|
|
fFileType = fileType;
|
|
|
|
|
fExtensions = extensions;
|
|
|
|
|
|
|
|
|
|
fTemporary = false;
|
|
|
|
|
fRegisteredViewer = false;
|
|
|
|
|
fPluginName = "";
|
|
|
|
|
fDescription = "";
|
|
|
|
|
fLatentPlugin = false;
|
|
|
|
|
fBasePref = nil;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Disposes of all allocated structures
|
|
|
|
|
CMimeMapper::~CMimeMapper()
|
|
|
|
|
{
|
|
|
|
|
if (fBasePref)
|
|
|
|
|
free (fBasePref);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CMimeMapper & CMimeMapper::operator= (const CMimeMapper& mapper)
|
|
|
|
|
{
|
|
|
|
|
fMimeType = mapper.fMimeType;
|
|
|
|
|
fAppName = mapper.fAppName;
|
|
|
|
|
fAppSig = mapper.fAppSig;
|
|
|
|
|
fFileType = mapper.fFileType;
|
|
|
|
|
fLoadAction = mapper.fLoadAction;
|
|
|
|
|
fPluginName = mapper.fPluginName;
|
|
|
|
|
fFromOldPrefs = mapper.fFromOldPrefs;
|
|
|
|
|
fDescription = mapper.fDescription;
|
|
|
|
|
fLatentPlugin = mapper.fLatentPlugin;
|
1998-06-23 05:36:59 +04:00
|
|
|
|
fFileFlags = mapper.fFileFlags;
|
1998-03-28 05:44:41 +03:00
|
|
|
|
return *this;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::SetAppName(const CStr255& newName)
|
|
|
|
|
{
|
|
|
|
|
fAppName = newName;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::SetMimeType(const CStr255& newType)
|
|
|
|
|
{
|
|
|
|
|
fMimeType = newType;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::SetAppSig(OSType newSig)
|
|
|
|
|
{
|
|
|
|
|
fAppSig = newSig;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::SetAppSig(FSSpec& appSpec)
|
|
|
|
|
{
|
|
|
|
|
FInfo finderInfo;
|
|
|
|
|
OSErr err = FSpGetFInfo(&appSpec, &finderInfo );
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
fAppSig = finderInfo.fdCreator;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::SetExtensions(const CStr255& newExtensions)
|
|
|
|
|
{
|
|
|
|
|
fExtensions = newExtensions;
|
|
|
|
|
SyncNetlib();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::SetDocType(OSType newType)
|
|
|
|
|
{
|
|
|
|
|
fFileType = newType;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::SetLoadAction(LoadAction newAction)
|
|
|
|
|
{
|
|
|
|
|
//
|
|
|
|
|
// If the user explicitly changed the load action,
|
|
|
|
|
// cancel the latent plug-in setting so their choice
|
|
|
|
|
// is maintained persistently.
|
|
|
|
|
//
|
|
|
|
|
fLatentPlugin = false;
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
|
// If the user explicitly changed the load action,
|
|
|
|
|
// cancel the registration of an external viewer.
|
|
|
|
|
//
|
|
|
|
|
fRegisteredViewer = false;
|
|
|
|
|
|
|
|
|
|
fLoadAction = newAction;
|
|
|
|
|
SyncNetlib();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::SetLatentPlugin()
|
|
|
|
|
{
|
|
|
|
|
fLatentPlugin = true;
|
|
|
|
|
fLoadAction = CMimeMapper::Unknown;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::RegisterViewer(OSType tempAppSig, OSType tempFileType)
|
|
|
|
|
{
|
|
|
|
|
fTempAppSig = tempAppSig; // Application
|
|
|
|
|
fTempFileType = tempFileType; // File signature
|
|
|
|
|
fRegisteredViewer = TRUE;
|
|
|
|
|
CFrontApp::RegisterMimeType(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::UnregisterViewer()
|
|
|
|
|
{
|
|
|
|
|
fRegisteredViewer = FALSE;
|
|
|
|
|
CFrontApp::RegisterMimeType(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Typical Spy apple event creation routine.
|
|
|
|
|
// It creates the event, with two arguments, URL and the MIME type.
|
|
|
|
|
// URL type is stored as attribute urlAttribute, MIME type as AE_spy_viewDocFile_mime
|
|
|
|
|
OSErr CMimeMapper::MakeSpyEvent(AppleEvent & event,
|
|
|
|
|
URL_Struct * request,
|
|
|
|
|
AEEventID id,
|
|
|
|
|
AEKeyword urlAttribute)
|
|
|
|
|
{
|
|
|
|
|
OSErr err;
|
|
|
|
|
Try_
|
|
|
|
|
{
|
|
|
|
|
AEAddressDesc targetApp;
|
|
|
|
|
|
|
|
|
|
// Specify the application, and create the event
|
|
|
|
|
{
|
|
|
|
|
err = ::AECreateDesc(typeApplSignature, &fTempAppSig,
|
|
|
|
|
sizeof(fTempAppSig), &targetApp);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
OSErr err = ::AECreateAppleEvent(AE_spy_send_suite, id,
|
|
|
|
|
&targetApp,
|
|
|
|
|
kAutoGenerateReturnID,
|
|
|
|
|
kAnyTransactionID,
|
|
|
|
|
&event);
|
|
|
|
|
::AEDisposeDesc(&targetApp);
|
|
|
|
|
}
|
|
|
|
|
// URL
|
|
|
|
|
{
|
|
|
|
|
AEDesc urlDesc;
|
|
|
|
|
err = ::AECreateDesc(typeChar, request->address, strlen(request->address), &urlDesc);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
|
|
|
|
|
err = ::AEPutParamDesc(&event, urlAttribute, &urlDesc);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
::AEDisposeDesc(&urlDesc);
|
|
|
|
|
}
|
|
|
|
|
// MIME type
|
|
|
|
|
if (request->content_type)
|
|
|
|
|
{
|
|
|
|
|
AEDesc mimeDesc;
|
|
|
|
|
err = ::AECreateDesc(typeChar, request->content_type, strlen(request->content_type), &mimeDesc);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
err = ::AEPutParamDesc(&event, AE_spy_queryViewer_mime, &mimeDesc);
|
|
|
|
|
::AEDisposeDesc(&mimeDesc);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
Catch_(inErr)
|
|
|
|
|
{ return inErr;
|
|
|
|
|
}
|
|
|
|
|
EndCatch_
|
|
|
|
|
return noErr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Returns whether the contents of inBuffer are all visible, printable characters.
|
|
|
|
|
Actually, that's a misnomer ... it returns whether the contents are printable
|
|
|
|
|
on a Macintosh, which we define to be "not control characters." This is intended
|
|
|
|
|
for determining whether a binary buffer can be stored as a text string, or needs
|
|
|
|
|
to be encoded. */
|
|
|
|
|
Boolean CMimeMapper::PrintableChars(const void *inBuffer, Int32 inLength)
|
|
|
|
|
{
|
|
|
|
|
unsigned char *buffer = (unsigned char *) inBuffer,
|
|
|
|
|
*bufferEnd = buffer + inLength;
|
|
|
|
|
|
|
|
|
|
while (buffer < bufferEnd)
|
|
|
|
|
{
|
|
|
|
|
if (*buffer <= 0x20)
|
|
|
|
|
break;
|
|
|
|
|
buffer++;
|
|
|
|
|
}
|
|
|
|
|
return buffer == bufferEnd;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// if we have a registered viewer, query it for a file spec
|
|
|
|
|
OSErr CMimeMapper::GetFileSpec(URL_Struct * request,
|
|
|
|
|
FSSpec & destination)
|
|
|
|
|
{
|
|
|
|
|
OSErr err = noErr;
|
|
|
|
|
if (!fRegisteredViewer)
|
|
|
|
|
return fnfErr;
|
|
|
|
|
else
|
|
|
|
|
Try_
|
|
|
|
|
{
|
|
|
|
|
AppleEvent queryViewerEvent;
|
|
|
|
|
|
|
|
|
|
err = MakeSpyEvent(queryViewerEvent, request,AE_spy_queryViewer,
|
|
|
|
|
keyDirectObject); // URL is the direct object
|
|
|
|
|
// Send the event
|
|
|
|
|
AppleEvent reply;
|
|
|
|
|
err = ::AESend(&queryViewerEvent,&reply,kAEWaitReply,kAEHighPriority,600,nil, nil);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
// Handle the reply. We want to get out the transaction ID
|
|
|
|
|
{
|
|
|
|
|
DescType realType;
|
|
|
|
|
Size actualSize;
|
|
|
|
|
if (!MoreExtractFromAEDesc::DisplayErrorReply(reply))
|
|
|
|
|
{
|
|
|
|
|
err = ::AEGetParamPtr(&reply, keyAEResult, typeFSS,
|
|
|
|
|
&realType, &destination, sizeof(destination),
|
|
|
|
|
&actualSize);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
Throw_(fnfErr);
|
|
|
|
|
::AEDisposeDesc(&reply);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
Catch_(inErr)
|
|
|
|
|
{
|
|
|
|
|
return inErr;
|
|
|
|
|
} EndCatch_
|
|
|
|
|
return noErr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If we have a registered viewer, use ViewDocFile
|
|
|
|
|
// if anything fails, or we have no viewer, use ordinary launch sequence
|
|
|
|
|
OSErr CMimeMapper::LaunchFile(LFileBufferStream * inFile, URL_Struct * request, Int32 windowID)
|
|
|
|
|
{
|
|
|
|
|
OSErr err;
|
|
|
|
|
if (fRegisteredViewer)
|
|
|
|
|
{
|
|
|
|
|
Try_
|
|
|
|
|
{
|
|
|
|
|
AppleEvent viewDocEvent;
|
|
|
|
|
// AppleEvent(fileSpec, URL, MIME, windowID)
|
|
|
|
|
// Create the event, with MIME and URL arguments
|
|
|
|
|
err = MakeSpyEvent(viewDocEvent, request,AE_spy_viewDocFile,
|
|
|
|
|
AE_spy_viewDocFile_url); // URL is the direct object
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
// Make the file spec
|
|
|
|
|
FSSpec fileSpec;
|
|
|
|
|
inFile->GetSpecifier(fileSpec);
|
|
|
|
|
err = ::AEPutParamPtr(&viewDocEvent,keyDirectObject,typeFSS,&fileSpec,sizeof(fileSpec));
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
// URL
|
|
|
|
|
if (request->address)
|
|
|
|
|
{
|
|
|
|
|
err = ::AEPutParamPtr(&viewDocEvent,AE_spy_viewDocFile_url, typeChar, request->address,strlen(request->address));
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
}
|
|
|
|
|
// MIME type
|
|
|
|
|
{
|
|
|
|
|
StAEDescriptor mimeDesc((StringPtr)fMimeType);
|
|
|
|
|
err = ::AEPutParamDesc(&viewDocEvent,AE_spy_viewDocFile_mime,&mimeDesc.mDesc);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
}
|
|
|
|
|
// WindowID
|
|
|
|
|
{
|
|
|
|
|
StAEDescriptor windowDesc(windowID);
|
|
|
|
|
err = ::AEPutParamDesc(&viewDocEvent,AE_spy_viewDocFile_wind, &windowDesc.mDesc);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
}
|
|
|
|
|
// Send the event
|
|
|
|
|
AppleEvent reply;
|
|
|
|
|
err = ::AESend(&viewDocEvent,&reply,kAEWaitReply,kAEHighPriority,60,nil, nil);
|
|
|
|
|
if (err != errAETimeout)
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
// If we got an error code back, launch as usual
|
|
|
|
|
if (reply.descriptorType != typeNull)
|
|
|
|
|
{
|
|
|
|
|
DescType realType;
|
|
|
|
|
Size actualSize;
|
|
|
|
|
long errNumber;
|
|
|
|
|
err = ::AEGetParamPtr(&reply, keyErrorNumber, typeLongInteger,
|
|
|
|
|
&realType, &errNumber, sizeof(errNumber),
|
|
|
|
|
&actualSize);
|
|
|
|
|
if ((err == noErr) && (errNumber != noErr))
|
|
|
|
|
Throw_(errNumber);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
Catch_(inErr)
|
|
|
|
|
{
|
|
|
|
|
// Launch through ViewDoc failed, use our original creator and launch as usual
|
|
|
|
|
FSSpec fileSpec;
|
|
|
|
|
inFile->GetSpecifier(fileSpec);
|
|
|
|
|
err = CFileMgr::SetFileTypeCreator(fAppSig, fFileType, &fileSpec);
|
|
|
|
|
::LaunchFile(inFile);
|
|
|
|
|
}
|
|
|
|
|
EndCatch_
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
::LaunchFile(inFile);
|
|
|
|
|
return noErr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void CMimeMapper::SyncNetlib()
|
|
|
|
|
{
|
|
|
|
|
CFrontApp::RegisterMimeType(this);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
// class CMimeList
|
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
// <20><> Constructors/destructors
|
|
|
|
|
|
|
|
|
|
CMimeList::CMimeList() : LArray()
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CMimeList::~CMimeList()
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// <20><><EFBFBD>Utility functions
|
|
|
|
|
// Overrode this on the assumption that every time you add a MIME mapper
|
|
|
|
|
// to this list, you want to sync up the netlib
|
|
|
|
|
ArrayIndexT CMimeList::InsertItemsAt(
|
|
|
|
|
Uint32 inCount,
|
|
|
|
|
ArrayIndexT inAtIndex,
|
|
|
|
|
const void *inItem,
|
|
|
|
|
Uint32 inItemSize)
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
ArrayIndexT result = LArray::InsertItemsAt(inCount,inAtIndex,inItem, inItemSize);
|
|
|
|
|
CMimeMapper ** mapperPtr = (CMimeMapper **)inItem;
|
|
|
|
|
(*mapperPtr)->SyncNetlib();
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Deletes all the items in the list
|
|
|
|
|
void CMimeList::DeleteAll(Boolean)
|
|
|
|
|
{
|
|
|
|
|
CMimeMapper* oldMap;
|
|
|
|
|
for ( short i = 1; i <= mItemCount; i++ )
|
|
|
|
|
{
|
|
|
|
|
FetchItemAt( i, &oldMap );
|
|
|
|
|
delete oldMap;
|
|
|
|
|
}
|
|
|
|
|
RemoveItemsAt( mItemCount,1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Finds a CMimeMapper with a given XP pref branch name.
|
|
|
|
|
CMimeMapper* CMimeList::FindBasePref( const char* basepref )
|
|
|
|
|
{
|
|
|
|
|
CMimeMapper* foundMap = NULL;
|
|
|
|
|
for ( Int32 i = mItemCount; i >= 1; i-- )
|
|
|
|
|
{
|
|
|
|
|
CMimeMapper* oldMap;
|
|
|
|
|
FetchItemAt( i, &oldMap );
|
|
|
|
|
if ( oldMap->GetBasePref() != NULL &&
|
|
|
|
|
XP_STRCMP(oldMap->GetBasePref(), basepref) == 0 )
|
|
|
|
|
{
|
|
|
|
|
foundMap = oldMap;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return foundMap;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Finds a CMimeMapper with a given mimeType. NULL if none
|
|
|
|
|
// Search is linear. Might want to make it faster
|
|
|
|
|
CMimeMapper* CMimeList::FindMimeType( char* mimeType )
|
|
|
|
|
{
|
|
|
|
|
if ( mimeType == NULL )
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
CMimeMapper* foundMap = NULL;
|
|
|
|
|
for ( Int32 i = 1; i <= mItemCount; i++ )
|
|
|
|
|
{
|
|
|
|
|
CMimeMapper* oldMap;
|
|
|
|
|
FetchItemAt( i, &oldMap );
|
1998-06-23 05:36:59 +04:00
|
|
|
|
// MIME types are defined to be case insensitive
|
|
|
|
|
if ( XP_STRCASECMP (oldMap->GetMimeName(), mimeType) == 0 )
|
1998-03-28 05:44:41 +03:00
|
|
|
|
{
|
|
|
|
|
foundMap = oldMap;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return foundMap;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Find a "built-in" mime type, which were separate in 3.0
|
|
|
|
|
// but are integrated into the 4.0 mimetype list.
|
|
|
|
|
CMimeMapper* CMimeList::FindMimeType(BuiltIn mimeBuiltin)
|
|
|
|
|
{
|
|
|
|
|
char* mimetype = nil;
|
|
|
|
|
switch (mimeBuiltin) {
|
|
|
|
|
case HTMLViewer:
|
|
|
|
|
mimetype = HTML_VIEWER_APPLICATION_MIME_TYPE;
|
|
|
|
|
break;
|
|
|
|
|
case Telnet:
|
|
|
|
|
mimetype = TELNET_APPLICATION_MIME_TYPE;
|
|
|
|
|
break;
|
|
|
|
|
case Tn3270:
|
|
|
|
|
mimetype = TN3270_VIEWER_APPLICATION_MIME_TYPE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return FindMimeType(mimetype);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// FindMimeType finds a Mime mapper that
|
|
|
|
|
// matches this file's type and creator
|
|
|
|
|
// Algorithm is inexact
|
|
|
|
|
// TEXT files are not typed because netlib figures out the
|
|
|
|
|
// HTML files, and hqx ones have the extension
|
|
|
|
|
// Look for exact match.
|
|
|
|
|
// If not found, look for inexact one
|
|
|
|
|
|
|
|
|
|
// I don't like the above algorithm. There is no way of telling what type of match occured. In
|
|
|
|
|
// cases other than exact or FileType match the results are unsatisfactory.
|
|
|
|
|
// New behavoir is to return NULL and let the caller call CMimeList::FindCreatorFindCreator if
|
|
|
|
|
// needed. Provides a way to hand off to IC if needed.
|
|
|
|
|
CMimeMapper* CMimeList::FindMimeType(const FSSpec& inFileSpec)
|
|
|
|
|
{
|
|
|
|
|
FInfo fndrInfo;
|
|
|
|
|
|
|
|
|
|
OSErr err = FSpGetFInfo( &inFileSpec, &fndrInfo );
|
|
|
|
|
if ((err != noErr) || (fndrInfo.fdType == 'TEXT'))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
|
|
CMimeMapper* fileTypeMatch = NULL;
|
|
|
|
|
|
|
|
|
|
// Find the cinfo (which gives us the MIME type) for this file name
|
|
|
|
|
NET_cinfo* cinfo = NET_cinfo_find_type((CStr255)inFileSpec.name);
|
|
|
|
|
|
|
|
|
|
for (Int32 i = 1; i <= mItemCount; i++)
|
|
|
|
|
{
|
|
|
|
|
CMimeMapper* map;
|
|
|
|
|
FetchItemAt(i, &map);
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
|
// If this MIME type is configured for a plug-in, see if it matches
|
|
|
|
|
// the MIME type of the file (based on the file extension -> MIME
|
|
|
|
|
// type mapping). If not, try for an exact or partial match based
|
|
|
|
|
// on type and/or creator. bing: If we decide to support Mac file
|
|
|
|
|
// types for plug-ins, we should check the file type here.
|
|
|
|
|
//
|
|
|
|
|
if (map->GetLoadAction() == CMimeMapper::Plugin)
|
|
|
|
|
{
|
|
|
|
|
if (cinfo && (map->GetMimeName() == cinfo->type))
|
|
|
|
|
return map;
|
|
|
|
|
}
|
|
|
|
|
else if ((map->GetAppSig() == fndrInfo.fdCreator) &&
|
1998-06-23 05:36:59 +04:00
|
|
|
|
(map->GetDocType() == fndrInfo.fdType) &&
|
|
|
|
|
!(map->GetFileFlags() &ICmap_not_outgoing_mask) )
|
1998-03-28 05:44:41 +03:00
|
|
|
|
return map;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
#if 0
|
|
|
|
|
if (map->GetAppSig() == fndrInfo.fdCreator)
|
|
|
|
|
creatorMatch = map;
|
|
|
|
|
#endif
|
1998-06-23 05:36:59 +04:00
|
|
|
|
if (map->GetDocType() == fndrInfo.fdType && !(map->GetFileFlags() &ICmap_not_outgoing_mask) )
|
1998-03-28 05:44:41 +03:00
|
|
|
|
fileTypeMatch = map;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return fileTypeMatch;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// FindCreator finds a CMimeMapper whose application signature
|
|
|
|
|
// matches appSig
|
|
|
|
|
CMimeMapper* CMimeList::FindCreator(OSType appSig)
|
|
|
|
|
{
|
|
|
|
|
CMimeMapper * foundMap = NULL;
|
|
|
|
|
for (Int32 i = 1; i <= mItemCount; i++)
|
|
|
|
|
{
|
|
|
|
|
CMimeMapper* oldMap;
|
|
|
|
|
FetchItemAt(i, &oldMap);
|
|
|
|
|
if (oldMap->GetAppSig() == appSig)
|
|
|
|
|
{
|
|
|
|
|
foundMap = oldMap;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return foundMap;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ------------------------- Apple Event handling -------------------------------
|
|
|
|
|
|
|
|
|
|
// HandleRegisterViewerEvent
|
|
|
|
|
// registers a viewer.
|
|
|
|
|
// If the MIME type does not exist, we create one on the fly
|
|
|
|
|
void CMimeList::HandleRegisterViewerEvent(const AppleEvent &inAppleEvent,
|
|
|
|
|
AppleEvent &outAEReply,
|
|
|
|
|
AEDesc &/*outResult*/,
|
|
|
|
|
long /*inAENumber*/)
|
|
|
|
|
{
|
|
|
|
|
OSType appSign; // app signature
|
|
|
|
|
OSType fileType = 'TEXT'; // file type to be created
|
|
|
|
|
volatile char * mimeType = NULL; // MIME type
|
|
|
|
|
OSType realType;
|
|
|
|
|
Size realSize;
|
|
|
|
|
CMimeMapper * mapper;
|
|
|
|
|
OSErr err;
|
|
|
|
|
Try_ {
|
|
|
|
|
{ // Get the application signature. Required
|
|
|
|
|
err = ::AEGetParamPtr(&inAppleEvent,keyDirectObject,typeApplSignature,
|
|
|
|
|
&realType, &appSign, sizeof(appSign), &realSize);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
}
|
|
|
|
|
{ // Get the MIME type. Required
|
|
|
|
|
AEDesc mimeDesc;
|
|
|
|
|
err = ::AEGetParamDesc(&inAppleEvent,AE_spy_registerViewer_mime,typeWildCard,&mimeDesc);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
MoreExtractFromAEDesc::TheCString(mimeDesc, mimeType);
|
|
|
|
|
::AEDisposeDesc(&mimeDesc);
|
|
|
|
|
if (mimeType == nil)
|
|
|
|
|
ThrowOSErr_(errAEWrongDataType);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mapper = FindMimeType(mimeType);
|
|
|
|
|
if (mapper)
|
|
|
|
|
fileType = mapper->GetDocType();
|
|
|
|
|
{ // Get the file type. If none is specified, it defaults to already registered type, or 'TEXT'
|
|
|
|
|
AEDesc fileTypeDesc;
|
|
|
|
|
err = ::AEGetParamDesc(&inAppleEvent,AE_spy_registerViewer_ftyp,typeWildCard,&fileTypeDesc);
|
|
|
|
|
if (err == noErr)
|
|
|
|
|
{
|
|
|
|
|
Try_ {
|
|
|
|
|
UExtractFromAEDesc::TheType(fileTypeDesc, fileType);
|
|
|
|
|
} Catch_(inErr)
|
|
|
|
|
{} EndCatch_
|
|
|
|
|
}
|
|
|
|
|
::AEDisposeDesc(&fileTypeDesc);
|
|
|
|
|
}
|
|
|
|
|
// We have all the arguments, set up the new mapper if necessary
|
|
|
|
|
if (mapper == NULL)
|
|
|
|
|
{
|
|
|
|
|
mapper = new CMimeMapper(CMimeMapper::Launch,
|
|
|
|
|
mimeType,
|
|
|
|
|
"-", // I10L - this string is never seen by a user
|
|
|
|
|
CStr255::sEmptyString,
|
|
|
|
|
appSign,
|
|
|
|
|
fileType);
|
|
|
|
|
ThrowIfNil_(mapper);
|
|
|
|
|
mapper->SetTemporary(TRUE);
|
|
|
|
|
InsertItemsAt( 1, LArray::index_Last, &mapper);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// If the type is being handled by a plug-in, don<6F>t let the AE override
|
|
|
|
|
Boolean result = false;
|
|
|
|
|
if (mapper->GetLoadAction() != CMimeMapper::Plugin)
|
|
|
|
|
{
|
|
|
|
|
mapper->RegisterViewer(appSign, fileType);
|
|
|
|
|
result = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Reply success
|
|
|
|
|
// Create the reply, it will automatically be stuck into the outgoing AE by PP
|
|
|
|
|
{
|
|
|
|
|
StAEDescriptor booleanDesc(result);
|
|
|
|
|
err = ::AEPutKeyDesc(&outAEReply,keyAEResult,&booleanDesc.mDesc); /* IM VI chap. 6 pg 91 */
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
Catch_(inErr)
|
|
|
|
|
{
|
|
|
|
|
MoreExtractFromAEDesc::MakeErrorReturn(outAEReply,
|
|
|
|
|
(unsigned char *)GetCString(REG_EVENT_ERR_RESID) , inErr);
|
|
|
|
|
} EndCatch_
|
|
|
|
|
// Dispose
|
|
|
|
|
if (mimeType) XP_FREE(mimeType);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void CMimeList::HandleUnregisterViewerEvent(const AppleEvent &inAppleEvent,
|
|
|
|
|
AppleEvent &outAEReply,
|
|
|
|
|
AEDesc &/*outResult*/,
|
|
|
|
|
long /*inAENumber*/)
|
|
|
|
|
{
|
|
|
|
|
OSType appSign; // app signature
|
|
|
|
|
OSType fileType = 'TEXT'; // file type to be created
|
|
|
|
|
volatile char* mimeType = NULL; // MIME type
|
|
|
|
|
|
|
|
|
|
CMimeMapper * mapper = NULL;
|
|
|
|
|
OSErr err;
|
|
|
|
|
Try_
|
|
|
|
|
{
|
|
|
|
|
{ // Get the application signature. Required
|
|
|
|
|
AEDesc appSignDesc;
|
|
|
|
|
err = ::AEGetParamDesc(&inAppleEvent,keyDirectObject,typeWildCard,&appSignDesc);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
UExtractFromAEDesc::TheType(appSignDesc, appSign);
|
|
|
|
|
::AEDisposeDesc(&appSignDesc);
|
|
|
|
|
}
|
|
|
|
|
{ // Get the MIME type. Required
|
|
|
|
|
AEDesc mimeDesc;
|
|
|
|
|
err = ::AEGetParamDesc(&inAppleEvent,AE_spy_unregisterViewer_mime,typeWildCard,&mimeDesc);
|
|
|
|
|
ThrowIfOSErr_(err);
|
|
|
|
|
MoreExtractFromAEDesc::TheCString(mimeDesc, mimeType);
|
|
|
|
|
::AEDisposeDesc(&mimeDesc);
|
|
|
|
|
if (mimeType == nil)
|
|
|
|
|
ThrowOSErr_(errAEWrongDataType);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mapper = FindMimeType(mimeType);
|
|
|
|
|
|
|
|
|
|
if (mapper == NULL || mapper->IsViewerRegistered() == false)
|
|
|
|
|
{
|
|
|
|
|
//
|
|
|
|
|
// If the type isn<73>t found, or wasn<73>t registered
|
|
|
|
|
// to an external viewer, return an error.
|
|
|
|
|
//
|
|
|
|
|
MoreExtractFromAEDesc::MakeErrorReturn(outAEReply,
|
|
|
|
|
(unsigned char *)GetCString(APP_NOT_REG_RESID), errAEDescNotFound);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
//
|
|
|
|
|
// Otherwise unregister the viewer and remove the
|
|
|
|
|
// temporary mapper if necessary.
|
|
|
|
|
//
|
|
|
|
|
mapper->UnregisterViewer();
|
|
|
|
|
if (mapper->IsTemporary())
|
|
|
|
|
{
|
|
|
|
|
Remove(&mapper);
|
|
|
|
|
delete mapper;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
Catch_(inErr)
|
|
|
|
|
{
|
|
|
|
|
MoreExtractFromAEDesc::MakeErrorReturn(outAEReply,
|
|
|
|
|
(unsigned char *)GetCString(UNREG_EVENT_ERR_RESID), inErr);
|
|
|
|
|
}
|
|
|
|
|
EndCatch_
|
|
|
|
|
if (mimeType) XP_FREE(mimeType);
|
|
|
|
|
}
|
|
|
|
|
|