magickimage.cpp

下载来的一个看图软件的源代码

// MagickImage.cpp : Implementation of CMagickImage
#include "stdafx.h"
#include "ImageMagickObject.h"
#include "MagickImage.h"
#  include "comvector.h"

const LCID lcidDefault = 0;
const DWORD dwErrorBase = 5000;

/////////////////////////////////////////////////////////////////////////////
// CMagickImage

CMagickImage::CMagickImage()
{
  DebugString("ImageMagickObject - new\n");
  SetWarningHandler(warninghandler);
  SetErrorHandler(errorhandler);
  SetFatalErrorHandler(fatalerrorhandler);
  m_bOnStartPageCalled = FALSE;
	m_bOnFirstTime = FALSE;
  AllocateArgs( nDefaultArgumentSize );
}

CMagickImage::~CMagickImage() 
{
	DebugString("ImageMagickObject - delete\n");
  DeleteArgs();
}

STDMETHODIMP CMagickImage::InterfaceSupportsErrorInfo(REFIID riid)
{
	static const IID* arr[] = 
	{
		&IID_IMagickImage,
	};
	for (int i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		if (InlineIsEqualGUID(*arr[i],riid))
			return S_OK;
	}
	return S_FALSE;
}

STDMETHODIMP CMagickImage::OnStartPage (IUnknown* pUnk)  
{
  DebugString("ImageMagickObject - OnStartPage\n");
	if(!pUnk)
		return E_POINTER;

	CComPtr<IScriptingContext> spContext;
	HRESULT hr;

	// Get the IScriptingContext Interface
	hr = pUnk->QueryInterface(IID_IScriptingContext, (void **)&spContext);
	if(FAILED(hr))
		return hr;

	// Get Request Object Pointer
	hr = spContext->get_Request(&m_piRequest);
	if(FAILED(hr))
	{
    DebugString("ImageMagickObject - OnStartPage get Request failed\n");
		//spContext.Release();
		//return hr;
	}

	// Get Response Object Pointer
	hr = spContext->get_Response(&m_piResponse);
	if(FAILED(hr))
	{
    DebugString("ImageMagickObject - OnStartPage get Response failed\n");
		//m_piRequest.Release();
		//return hr;
	}
	
	// Get Server Object Pointer
	hr = spContext->get_Server(&m_piServer);
	if(FAILED(hr))
	{
    DebugString("ImageMagickObject - OnStartPage get Server failed\n");
		//m_piRequest.Release();
		//m_piResponse.Release();
		//return hr;
	}
	
	// Get Session Object Pointer
	hr = spContext->get_Session(&m_piSession);
	if(FAILED(hr))
	{
    DebugString("ImageMagickObject - OnStartPage get Session failed\n");
		//m_piRequest.Release();
		//m_piResponse.Release();
		//m_piServer.Release();
		//return hr;
	}

	// Get Application Object Pointer
	hr = spContext->get_Application(&m_piApplication);
	if(FAILED(hr))
	{
    DebugString("ImageMagickObject - OnStartPage get Application failed\n");
		//m_piRequest.Release();
		//m_piResponse.Release();
		//m_piServer.Release();
		//m_piSession.Release();
		//eturn hr;
	}
	m_bOnStartPageCalled = TRUE;

  {
	  CComPtr<IRequestDictionary>pReadDictionary;
	  CComPtr<IReadCookie>pCookieDictionary;
	  	  
		hr=m_piRequest->get_Cookies(&pReadDictionary);
		if(SUCCEEDED(hr))
    {
		  CComVariant vtIn(_T("MAGICK_DEBUG"));
		  CComVariant vtKey(_T("level"));
		  CComVariant vtOut;
		  CComVariant vtCookieValue;

		  hr=pReadDictionary->get_Item(vtIn,&vtOut);
		  if(SUCCEEDED(hr) && (V_VT(&vtOut)==VT_DISPATCH))
      {
        pCookieDictionary = (IReadCookie*)(vtOut.pdispVal);
		    hr=pCookieDictionary->get_Item(vtKey,&vtCookieValue);
		    if(SUCCEEDED(hr) && (V_VT(&vtCookieValue)==VT_BSTR))
        {
          USES_CONVERSION;
          LPTSTR lpstrVal = W2T(vtCookieValue.bstrVal);
          int level = atoi(lpstrVal);
          DebugLevel(level);
	        DebugString("OnStartPage debug level: %d\n",level);
        }
        else
	        DebugString("OnStartPage - parse error\n");
      }
      else
	      DebugString("OnStartPage - no MAGICK_DEBUG\n");
    }
    else
	    DebugString("OnStartPage - no cookies\n");
  }
	return S_OK;
}

STDMETHODIMP CMagickImage::OnEndPage ()  
{
  DebugString("ImageMagickObject - OnEndPage\n");
	m_bOnStartPageCalled = FALSE;
	// Release all interfaces
  if (m_piRequest)
	  m_piRequest.Release();
  if (m_piResponse)
	  m_piResponse.Release();
  if (m_piServer)
	  m_piServer.Release();
  if (m_piSession)
	  m_piSession.Release();
  if (m_piApplication)
	  m_piApplication.Release();
	return S_OK;
}

// ICollectionOnSTLImpl<> supplies these, but we override and pass through
STDMETHODIMP CMagickImage::get_Count(long *pVal)
{
  HRESULT hr = _baseMagickImage::get_Count(pVal);
	return hr;
}

STDMETHODIMP CMagickImage::get__NewEnum(LPUNKNOWN *pVal)
{
  HRESULT hr = _baseMagickImage::get__NewEnum(pVal);
	return hr;
}

STDMETHODIMP CMagickImage::get_Item(VARIANT varIndex, VARIANT *pVal)
{
  USES_CONVERSION;

  HRESULT hr = E_INVALIDARG;
  VARIANTARG *pvarIndex = &varIndex;
  VARTYPE vt = V_VT(pvarIndex);
  long lIndex = 0;
  CComVariant var;
 
  while (vt == (VT_VARIANT|VT_BYREF))
  {
	  pvarIndex = V_VARIANTREF(pvarIndex);
	  vt = V_VT(pvarIndex);
  }
  if (V_ISARRAY(pvarIndex))
    return hr;
  if ((vt & ~VT_BYREF) == VT_BSTR)
    {
      LPTSTR lpszNext;
      LPTSTR lpszVal = W2T(V_BSTR(pvarIndex));
      var = _T("");
      if (lpszVal)
        {
          Image
            *image;

          ImageInfo
            *image_info;

          ExceptionInfo
            exception;

          long
            id;

				  lpszNext = StrChr(lpszVal, _T('.'));
				  if (lpszNext == NULL)
            lpszNext = _T("%w,%h,%m");
          else
            *lpszNext++ = _T('\0');
          // lookup the registry id using token and pass the image in
          GetExceptionInfo(&exception);
          image=GetImageFromMagickRegistry(lpszVal, &id, &exception);
          if (image != (Image *) NULL)
            {
              TCHAR *text;

              image_info=CloneImageInfo((ImageInfo *) NULL);                
              text=TranslateText(image_info,image,lpszNext);
              DestroyImageList(image);
              DestroyImageInfo(image_info);
              var = text;
              LiberateMemory((void **) &text);
              hr = S_OK;
            }
        }
    }
  else
    {
      Image
        *image;

      ImageInfo
        *image_info;

      ExceptionInfo
        exception;

      long
        id;

      RegistryType
        type;

      size_t
        length;

      id = 0;
      var = _T("");
      switch(vt & ~VT_BYREF)
      {
        case VT_UI1:
          id = V_UI1(pvarIndex);
          break;
        case VT_I2:
          id = V_I2(pvarIndex);
          break;
        case VT_I4:
          id = V_I4(pvarIndex);
          break;
      }
      // lookup the registry id using token and pass the image in
      GetExceptionInfo(&exception);
      image=(Image *)GetMagickRegistry(id,&type,&length,&exception);
      if (image != (Image *) NULL)
        {
          TCHAR *text;

          image_info=CloneImageInfo((ImageInfo *) NULL);                
          text=TranslateText(image_info,image,_T("%w,%h,%m"));
          DestroyImageList(image);
          DestroyImageInfo(image_info);
          var = text;
          LiberateMemory((void **) &text);
          hr = S_OK;
        }
    }
  var.Detach(pVal);
	return hr;
}

STDMETHODIMP CMagickImage::Remove(VARIANT varIndex)
{
  USES_CONVERSION;

  HRESULT hr = E_INVALIDARG;
  VARIANTARG *pvarIndex = &varIndex;
  VARTYPE vt = V_VT(pvarIndex);
 
  while (vt == (VT_VARIANT|VT_BYREF))
  {
	  pvarIndex = V_VARIANTREF(pvarIndex);
	  vt = V_VT(pvarIndex);
  }
  if (V_ISARRAY(pvarIndex))
    return hr;
  switch(vt & ~VT_BYREF)
  {
    case VT_BSTR:
    {
      if (!V_ISBYREF(pvarIndex))
      {
        CComVariant var;
        LPTSTR lpszNext;
        LPTSTR lpszVal = W2T(V_BSTR(pvarIndex));
        var = _T("");
        if (lpszVal)
          {
            Image
              *image;

            ExceptionInfo
              exception;

            long
              id;

				    lpszNext = StrChr(lpszVal, _T('.'));
				    if (lpszNext == NULL)
              lpszNext = _T("%w,%h,%m");
            else
              *lpszNext++ = _T('\0');
            // lookup the registry id using token and pass the image in
            GetExceptionInfo(&exception);
            image=GetImageFromMagickRegistry(lpszVal, &id, &exception);
            if (image != (Image *) NULL)
              {
                DestroyImageList(image);
                if (DeleteMagickRegistry(id))
                  hr = S_OK;
              }
          }
      }
      break;
    }
    case VT_UI1:
    {
      long id = V_UI1(pvarIndex);
      if (DeleteMagickRegistry(id))
        hr = S_OK;
    }
    case VT_I2:
    {
      long id = V_I2(pvarIndex);
      if (DeleteMagickRegistry(id))
        hr = S_OK;
    }
    case VT_I4:
    {
      long id = V_I4(pvarIndex);
      if (DeleteMagickRegistry(id))
        hr = S_OK;
    }
  }
	return hr;
}

STDMETHODIMP CMagickImage::Add(SAFEARRAY **pArrayVar, VARIANT *pVar)
{
  return S_OK;
}

#include <exdisp.h>

static long SafeArraySize(SAFEARRAY *psa)
{
  HRESULT hr;
	long lBoundl, lBoundu;

	hr = ::SafeArrayGetLBound(psa, 1, &lBoundl);
  if (FAILED(hr))
    return 0;
	hr = ::SafeArrayGetUBound(psa, 1, &lBoundu);
  if (FAILED(hr))
    return 0;
  return (lBoundu - lBoundl + 1);
}

#ifdef USETHIS_CODE
int COMMagickFifoBuffer(const Image *image,const void *data,const size_t length)
{
  SAFEARRAYBOUND NewArrayBounds[1];  // 1 Dimension
  size_t tlen=length;
  CMagickImage *pMagickImage = (CMagickImage *)image->client_data;
  if ((pMagickImage != NULL) && (pMagickImage->pSafeArray != NULL))
  {
	  DWORD dwSizeOfChunk;
	  unsigned char	*pReturnBuffer = NULL;
	  HRESULT hr = S_OK;
		long lBoundl, lBoundu, lCount;

	  dwSizeOfChunk = (DWORD)length;
    /* is this the signal that says we are all done? */
    if ((dwSizeOfChunk == 0) && (data == (void *) NULL))
    {
      if (pMagickImage->m_bOnFirstTime == FALSE)
        {
          //pMagickImage->m_piResponse->End();
        }
    }
	  if ((dwSizeOfChunk == 0) || (dwSizeOfChunk == 0xFFFFFFFF))
		  return tlen;

		hr = ::SafeArrayGetLBound(pMagickImage->pSafeArray, 1, &lBoundl);
    if (FAILED(hr))
      return tlen;
		hr = ::SafeArrayGetUBound(pMagickImage->pSafeArray, 1, &lBoundu);
    if (FAILED(hr))
      return tlen;

		lCount = lBoundu - lBoundl + 1;
    NewArrayBounds[0].lLbound = 0;   // Start-Index 0
    NewArrayBounds[0].cElements = dwSizeOfChunk+lCount;  // # Elemente
    hr = SafeArrayRedim(pMagickImage->pSafeArray, NewArrayBounds);
    if (FAILED(hr))
      return tlen;

    hr = SafeArrayAccessData(pMagickImage->pSafeArray, (void**)&pReturnBuffer);
	  if( FAILED(hr) )
		  return tlen;
	  memcpy( pReturnBuffer, (unsigned char *)data+lCount, dwSizeOfChunk );
    hr = SafeArrayUnaccessData(pMagickImage->pSafeArray);
	  if( FAILED(hr) )
		  return tlen;
  }
  return(tlen);
}
#endif

HRESULT CMagickImage::DispatchToImage(IDispatch* pdisp,CComObject<CMagickImage>** ppMagickImage)
{
  // Given an IDispatch*, convert it (if possible) to a CComObject<CMagickImage>*
  IMagickImage* pinterface;
  if(FAILED(pdisp->QueryInterface(IID_IMagickImage,
        reinterpret_cast<void**>(&pinterface))))
  {
    return DISP_E_TYPEMISMATCH;
  }
  *ppMagickImage = static_cast<CComObject<CMagickImage>*>(pinterface);
  pinterface->Release();
  return S_OK;
}

HRESULT CMagickImage::UnknownToImage(IUnknown* punk,CComObject<CMagickImage>** ppMagickImage)
{
  // Given an IUnknown*, convert it (if possible) to a CComObject<CMagickImage>*
  IMagickImage* pinterface;
  if(FAILED(punk->QueryInterface(IID_IMagickImage,
        reinterpret_cast<void**>(&pinterface))))
  {
    return DISP_E_TYPEMISMATCH;
  }
  *ppMagickImage = static_cast<CComObject<CMagickImage>*>(pinterface);
  pinterface->Release();
  return S_OK;
}

STDMETHODIMP CMagickImage::get_Messages(VARIANT *pVar)
{
  HRESULT hr = S_OK;

  if (m_coll.size())
  {
    CComVector<VARIANT> v(m_coll.size());
    if( !v )
    {
      //m_coll.clear();
      return E_OUTOFMEMORY;
    }
    else
    {
      // WARNING: This nested code block is required because
      // CComVectorData ctor performs a SafeArrayAccessData
      // and you have to make sure the SafeArrayUnaccessData
      // is called (which it is in the CComVectorData dtor)
      // before you use the CComVector::DetachTo(...).
      CComVectorData<VARIANT> msgs(v);
      if( !msgs )
      {
        //m_coll.clear();
        return E_OUTOFMEMORY;
      }
      else
      {
        for(int index = 0; index < m_coll.size(); ++index)
        {
          CComVariant vt(m_coll[index]);
          HRESULT hr = vt.Detach(&msgs[index]);
        }
      }
    }    
    V_VT(pVar) = VT_ARRAY | VT_VARIANT;
    V_ARRAY(pVar) = v.Detach();
    //m_coll.clear();
  }
  return hr;
}

#ifdef SUPPORT_OBJECTS
HRESULT CMagickImage::FormatRequest(BSTR *pVal)
{
  HRESULT hr = E_INVALIDARG;
  TCHAR sz[128];
  CComBSTR bstrResult;

  if (m_bstrIOType == L"xtrnfile")
  {
    wsprintf(sz, _T("xtrnfile:%S"),m_bstrName);
    bstrResult = sz;
    bstrResult.CopyTo(pVal);
    hr = S_OK;
  }
  else if (m_bstrIOType == L"xtrnimage")
  {
    wsprintf(sz, _T("xtrnimage:0x%lx,0x%lx"),
      (unsigned long)(&pImage_info),(unsigned long)(&pImage));
    bstrResult = sz;
    bstrResult.CopyTo(pVal);
    hr = S_OK;
  }
  else if (m_bstrIOType == L"xtrnblob")
  {
    wsprintf(sz, _T("xtrnblob:0x%lx,0x%lx,%S"),
      (unsigned long)(&pBlob_data),(unsigned long)(&iBlob_length),
        m_bstrName);
    bstrResult = sz;
    bstrResult.CopyTo(pVal);
    hr = S_OK;
  }
  else if (m_bstrIOType == L"xtrnstream")
  {
    wsprintf(sz, _T("xtrnstream:0x%lx,0x%lx,%S"),
      (unsigned long)(&COMMagickFifoBuffer),(unsigned long)this,m_bstrName);
    bstrResult = sz;
    bstrResult.CopyTo(pVal);
    hr = S_OK;
  }
  else if (m_bstrIOType == L"xtrnarray")
  {
    wsprintf(sz, _T("xtrnarray:0x%lx,%S"),
      (unsigned long)(pSafeArray), m_bstrName);
    bstrResult = sz;
    bstrResult.CopyTo(pVal);
    hr = S_OK;
  }
	return hr;
}
#endif

static char *translate_exception(DWORD code)
{
  switch (code)
  {
    case EXCEPTION_ACCESS_VIOLATION:
      return "access violation";
    case EXCEPTION_DATATYPE_MISALIGNMENT:
      return "data misalignment";
    case EXCEPTION_BREAKPOINT:
      return "debug breakpoint";
    case EXCEPTION_SINGLE_STEP:
      return "debug single step";
    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
      return "array out of bounds";