gecko-dev/cmd/winfe/cxmeta.cpp

175 lines
5.9 KiB
C++
Raw Normal View History

1998-03-28 02:44:41 +00: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.
*/
#include "stdafx.h"
#include "cxmeta.h"
// The purpose of this file is to output a load to a DC.
// The name MetaFile is just a term, the DC need not be a MetaFileDC.
// If however, the DC passed in is a MetaFile DC, then all setup of DC
// must occur outside of this code.
// Further, the DC must remain valid throughout the course of the load.
// It may be more easier for you to derive from this class and handle creation
// and destruction of your DC therein.
// Indirect construction of the Class which loads a URL and
// returns the context ID, 0 on failure.
// Calling code can track when the MetaFile is finished, by realizing
// when the context ID is no longer found in the context list.
DWORD CMetaFileCX::MetaFileAnchorObject(CDC * pMetaFileDC, SIZE& pSize, URL_Struct *pUrl)
{
// Create a new object.
CMetaFileCX *pDontCare = new CMetaFileCX(pMetaFileDC, pSize, pUrl);
if(pDontCare != NULL) {
// The return value is!
DWORD dwID = pDontCare->GetContextID();
// Load the URL.
pDontCare->GetUrl(pUrl, FO_CACHE_AND_PRESENT);
// Success as far as we are concerned.
return(dwID);
}
// Failure.
return(0);
}
// Construct the class.
CMetaFileCX::CMetaFileCX(CDC* pMetaFileDC, SIZE& pSize, URL_Struct *pUrl)
{
TRACE("Creating CMetaFileCX %p\n", this);
// Set the context type.
m_cxType = MetaFile;
GetContext()->type = MWContextMetaFile;
// this is a hack to save the layout data for embedlist. For embed layout will
// make a copy of the pSavedData. We need to free the memory here.
m_embedList = (lo_SavedEmbedListData*)pUrl->savedData.EmbedList;
// Initialize the class members.
m_pMetaFileDC = NULL;
m_csViewport.cx = m_csViewport.cy = 0;
// Set them.
m_pMetaFileDC = pMetaFileDC;
ASSERT(m_pMetaFileDC);
m_csViewport = pSize;
ASSERT(m_csViewport.cx != 0 && m_csViewport.cy != 0);
// Should be able to initialize ourselves safely now.
Initialize(TRUE);
}
// We are now destroyed.
// Callers can tell when we've gone away by checking for our context ID
// in the list of all contexts -- Returned by MetaFileAnchorObject.
CMetaFileCX::~CMetaFileCX()
{
TRACE("Destroying CMetaFileCX %p\n", this);
// MWH - this is a hack to free the embed list that layout make copy from the original
// SavedData. I removed the freeing from lib\layout\layfree.c lo_FreeDocumentEmbedListData.
// and free the data here. This will fix an OLE printing problem. The problem is when a .doc file
// is on the net, i.e. http://....//xxx.doc. When layout free the EmbedList in
// lo_FreeDocumentEmbedListData will cause the page not printed. Since for printing we need
// to use the cached data.
if (m_embedList && (m_embedList->embed_data_list != NULL)) {
int32 i;
lo_EmbedDataElement* embed_data_list;
PA_LOCK(embed_data_list, lo_EmbedDataElement*, m_embedList->embed_data_list);
for (i=0; i < m_embedList->embed_count; i++)
{
if (embed_data_list[i].freeProc && embed_data_list[i].data)
(*(embed_data_list[i].freeProc))(GetContext(), embed_data_list[i].data);
}
PA_UNLOCK(m_embedList->embed_data_list);
PA_FREE(m_embedList->embed_data_list);
m_embedList->embed_count = 0;
m_embedList->embed_data_list = NULL;
}
}
// Returns the DC for this context.
HDC CMetaFileCX::GetContextDC()
{
return(m_pMetaFileDC->GetSafeHdc());
}
// Releases the DC for this context.
// Since the DC is static, there is no need to really do anything fancy here.
void CMetaFileCX::ReleaseContextDC(HDC pDC)
{
}
// Initializes the context for work after all the members are set.
// We leave the DC as persistant, as it doesn't really change while we're doing
// this (it better!).
void CMetaFileCX::Initialize(BOOL bOwnDC, RECT *pRect, BOOL bInitialPalette, BOOL bNewMemDC)
{
// We're going to use MM_TEXT for simplicity sake.
// Another reason, is simply, that on 16 bit windows, all the GDI functions
// take 16 bit ints, which wrap if the page gets too long.
// The page will be increadibly long, since this is a metafile, and this
// will prolong the wrapping.
m_MM = MM_TEXT;
// Set our width and height to that specified in the constructor.
m_lWidth = Twips2PixX(Metric2TwipsX(m_csViewport.cx));
m_lHeight = Twips2PixY(Metric2TwipsY(m_csViewport.cy));
TRACE("Metafile width is %ld\n", m_lWidth);
TRACE("Metafile height is %ld\n", m_lHeight);
// Call the base.
CDCCX::Initialize(bOwnDC, pRect, bInitialPalette, bNewMemDC);
}
// A new document is starting to be laid out.
// Inform layout of our dimensions, etc.
void CMetaFileCX::LayoutNewDocument(MWContext *pContext, URL_Struct *pURL, int32 *pWidth, int32 *pHeight, int32 *pmWidth, int32 *pmHeight)
{
// Turn off all display blocking, since we allow the metafile to
// be the full representation of a document.
DisableDisplayBlocking();
// Call the base
CDCCX::LayoutNewDocument(pContext, pURL, pWidth, pHeight, pmWidth, pmHeight);
}
// The load is finished for all intents and purposes.
// Get rid of ourselves.
void CMetaFileCX::AllConnectionsComplete(MWContext *pContext)
{
// Call the base.
CDCCX::AllConnectionsComplete(pContext);
// We're done.
DestroyContext();
}
// Do not allow incremental image display.
PRBool CMetaFileCX::ResolveIncrementalImages()
{
return(PR_FALSE);
}