imagemagickobject.cpp

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

#include "ImageMagickObject_.h"

[ module(dll, name = "ImageMagickObject", helpstring = "ImageMagickObject 1.0 Type Library") ]
// module attribute now applies to this class
class CModuelOverrideClass
{
  public:
  TCHAR m_szAppPath[MAX_PATH];
  BOOL WINAPI DllMain(DWORD dwReason, LPVOID lpReserved)
  {
    //DebugBreak();
    if (dwReason == DLL_PROCESS_ATTACH)
    {
      MagickLib::ExceptionInfo
        exception;

#ifdef _DEBUG
      int tmpDbgFlag;
#endif
      HINSTANCE hModuleInstance = _AtlBaseModule.GetModuleInstance();
      HINSTANCE hMResourceInstance = _AtlBaseModule.GetResourceInstance();
      if (!GetModuleFileName (hModuleInstance, m_szAppPath, MAX_PATH))
        return FALSE;
#ifdef _DEBUG
      tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
      tmpDbgFlag |= _CRTDBG_CHECK_ALWAYS_DF;
      //tmpDbgFlag |= _CRTDBG_DELAY_FREE_MEM_DF;
      tmpDbgFlag |= _CRTDBG_LEAK_CHECK_DF;
      tmpDbgFlag |= _CRTDBG_ALLOC_MEM_DF;
      _CrtSetDbgFlag(tmpDbgFlag);
      _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_DEBUG );
      _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_DEBUG );
      _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_DEBUG );
#endif

      /* The first thing to do is make sure that basic critical sections are
         initialized properly. This should prevent ANY other race conditions
       */
      // MagickLib::InitializeSemaphore();
      /* Next we use a back door to init the path to US so that the logging
         system can find its configuration file log.gk and load it
       */
      (void) MagickLib::DefineClientPathAndName(m_szAppPath);
      //(void) MagickLib::SetLogEventMask("All");
      (void) MagickLib::LogMagickEvent(MagickLib::ResourceEvent,GetMagickModule(),
        "DLL Attach -  path: %s",m_szAppPath);
      // MagickLib::InitializeTracingCriticalSection();
      // MagickLib::DebugString("DLL Attach -  path: %s\n",m_szAppPath);
      MagickLib::InitializeMagick(m_szAppPath);
      MagickLib::RegisterStaticModules();
      MagickLib::GetExceptionInfo(&exception);
      (void) MagickLib::GetMagicInfo((unsigned char *) NULL,0,&exception);
      (void) MagickLib::GetDelegateInfo("*","*",&exception);
      MagickLib::DestroyExceptionInfo(&exception);
    }
    else if (dwReason == DLL_PROCESS_DETACH)
    {
      (void) MagickLib::LogMagickEvent(MagickLib::ResourceEvent,GetMagickModule(),
        "DLL Detach -  path: %s",m_szAppPath);
      MagickLib::DestroyMagick();
#ifdef _DEBUG
      if (_CrtDumpMemoryLeaks())
        {
          /* MagickLib::DebugString("ImageMagickObject - DLL Detach - leaks detected\n"); */
        }
#endif
    }
    return __super::DllMain(dwReason, lpReserved);
  }
};
[ emitidl ];
/////////////////////////////////////////////////////////////////////////////
// IMagickImage
[
  object,
  uuid("7F670536-00AE-4EDF-B06F-13BD22B25624"),
  dual,
  helpstring("IMagickImage Interface"),
  pointer_default(unique)
]
__interface IMagickImage : IDispatch
{
  //Standard Server Side Component Methods
  HRESULT OnStartPage([in] IUnknown* piUnk);
  HRESULT OnEndPage();	
  [propget, id(1)] HRESULT Count([out, retval] long *pVal);
  [vararg, id(2)] HRESULT Add([in, out, satype(VARIANT)] SAFEARRAY** pArrayVar, [out, retval] VARIANT *pVar);
  [id(3)] HRESULT Remove([in] VARIANT varIndex);
  [vararg, id(4)] HRESULT Convert([in, out, satype(VARIANT)] SAFEARRAY** pArrayVar, [out, retval] VARIANT *pVar);
  [vararg, id(5)] HRESULT Composite([in, out, satype(VARIANT)] SAFEARRAY** pArrayVar, [out, retval] VARIANT *pVar);
  [vararg, id(6)] HRESULT Montage([in, out, satype(VARIANT)] SAFEARRAY** pArrayVar, [out, retval] VARIANT *pVar);
  [vararg, id(7)] HRESULT Mogrify([in, out, satype(VARIANT)] SAFEARRAY** pArrayVar, [out, retval] VARIANT *pVar);
  [vararg, id(8)] HRESULT Identify([in, out, satype(VARIANT)] SAFEARRAY** pArrayVar, [out, retval] VARIANT *pVar);
  [vararg, id(9)] HRESULT TestHarness([in, out, satype(VARIANT)] SAFEARRAY** pArrayVar, [out, retval] VARIANT *pVar);
  [propget, id(DISPID_NEWENUM)] HRESULT _NewEnum([out, retval] LPUNKNOWN *pVal);
  [propget, id(DISPID_VALUE)] HRESULT Item([in] VARIANT varIndex, [out, retval] VARIANT *pVal);
  [propget, id(12)] HRESULT Messages([out, retval] VARIANT *pVal);
};

/////////////////////////////////////////////////////////////////////////////
// MagickImage
[
  coclass,
  threading("both"),
  support_error_info("IMagickImage"),
  vi_progid("ImageMagickObject.MagickImage"),
  progid("ImageMagickObject.MagickImage.1"),
  version(1.0),
  uuid("5630BE5A-3F5F-4BCA-A511-AD6A6386CAC1"),
  helpstring("MagickImage Class")
]
class ATL_NO_VTABLE MagickImage : 
  public IObjectControl,
  public IObjectConstruct,
  public IObjectWithSiteImpl<MagickImage>,
  public IMagickImage
{
public:
  MagickImage()
  {
#ifdef _DEBUG
    //DebugBreak();
#endif
    MagickLib::SetWarningHandler(warninghandler);
    MagickLib::SetErrorHandler(errorhandler);
    MagickLib::SetFatalErrorHandler(fatalerrorhandler);
    (void) MagickLib::LogMagickEvent(MagickLib::ResourceEvent,GetMagickModule(),
      "MagickImage constructor");
    m_bOnStartPageCalled = FALSE;
  }
  HRESULT TestHarness(SAFEARRAY **pArrayVar, VARIANT *pVar);
  HRESULT Convert(SAFEARRAY **pArrayVar, VARIANT *pVar);
  HRESULT Composite(SAFEARRAY **pArrayVar, VARIANT *pVar);
  HRESULT Montage(SAFEARRAY **pArrayVar, VARIANT *pVar);
  HRESULT Mogrify(SAFEARRAY **pArrayVar, VARIANT *pVar);
  HRESULT Identify(SAFEARRAY **pArrayVar, VARIANT *pVar);
  HRESULT Execute(unsigned int (*func)(MagickLib::ImageInfo *image_info,
    const int argc,char **argv,char **text,MagickLib::ExceptionInfo *exception),
      char **text,MagickLib::ImageInfo *info,MagickLib::ExceptionInfo *exception);
  HRESULT Perform(unsigned int (*func)(MagickLib::ImageInfo *image_info,
  const int argc,char **argv,char **text,MagickLib::ExceptionInfo *exception),
    SAFEARRAY **pArrayVar,VARIANT *pVar2,MagickLib::ExceptionInfo *exception);
private:
  char **m_argv;
  char **m_argv_t;
  int m_argc;
  int m_argvIndex;
public:
  HRESULT AllocateArgs(int iArgs);
  HRESULT ReAllocateArgs(int iArgs);
  void DeleteArgs(void);
  char **GetArgv(void);
  char **GetArgvT(void);
  int GetArgc(void);
  void EmptyArgs(void);
  //HRESULT AddArgs(VARIANTARG *arg);
  HRESULT AddArgs(BSTR arg);
  HRESULT AddArgs(LPTSTR arg);

  static void warninghandler(const MagickLib::ExceptionType warning,const char *message,
    const char *qualifier);

  static void errorhandler(const MagickLib::ExceptionType error,const char *message,
    const char *qualifier);

  static void fatalerrorhandler(const MagickLib::ExceptionType error,const char *message,
    const char *qualifier);

  DECLARE_PROTECT_FINAL_CONSTRUCT()
  HRESULT FinalConstruct()
  {
    (void) MagickLib::LogMagickEvent(MagickLib::ResourceEvent,GetMagickModule(),
      "FinalConstruct");
    AllocateArgs( nDefaultArgumentSize );
    //MagickLib::InitializeMagick(NULL);
    return S_OK;
  }
  
  void FinalRelease() 
  {
     (void) MagickLib::LogMagickEvent(MagickLib::ResourceEvent,GetMagickModule(),
        "FinalRelease");
    DeleteArgs();
  }

  // Support for ASP page notifications methods
public:
  //Active Server Pages Methods
  STDMETHOD(OnStartPage)(IUnknown* IUnk);
  STDMETHOD(OnEndPage)();
	STDMETHOD(get_Item)(/*[in]*/ VARIANT varIndex, /*[out, retval]*/ VARIANT *pVar);
	STDMETHOD(get__NewEnum)(/*[out, retval]*/ LPUNKNOWN *pVal);
	STDMETHOD(get_Count)(/*[out, retval]*/ long *pVal);
	STDMETHOD(get_Messages)(/*[out, retval]*/ VARIANT *pVar);
	STDMETHOD(Remove)(/*[in]*/ VARIANT varIndex);
	STDMETHOD(Add)(/*[in,out]*/ SAFEARRAY **pArrayVar, /*[out, retval]*/ VARIANT *pVar);

private:
  CComPtr<IRequest> m_piRequest; //Request Object
  CComPtr<IResponse> m_piResponse; //Response Object
  CComPtr<ISessionObject> m_piSession; //Session Object
  CComPtr<IServer> m_piServer; //Server Object
  CComPtr<IApplicationObject> m_piApplication; //Application Object
  BOOL m_bOnStartPageCalled; //OnStartPage successful?

public:
  // Support for COM+ activation and deactivation
  STDMETHOD(Activate)();
  STDMETHOD_(BOOL, CanBePooled)();
  STDMETHOD_(void, Deactivate)();
  STDMETHOD(Construct)(IDispatch * pCtorObj);

  CComPtr<IObjectContext> m_spObjectContext;
};

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";
    case EXCEPTION_FLT_DENORMAL_OPERAND:
      return "float denormal operand";
    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
      return "float devide by zero";
    case EXCEPTION_FLT_INEXACT_RESULT:
      return "float inexact result";
    case EXCEPTION_FLT_INVALID_OPERATION:
      return "float invalid operation";
    case EXCEPTION_FLT_OVERFLOW:
      return "float overflow";
    case EXCEPTION_FLT_STACK_CHECK:
      return "float stack check";
    case EXCEPTION_FLT_UNDERFLOW:
      return "float underflow";
    case EXCEPTION_INT_DIVIDE_BY_ZERO:
      return "integer divide by zero";
    case EXCEPTION_INT_OVERFLOW:
      return "integer overflow";
    case EXCEPTION_PRIV_INSTRUCTION:
      return "privleged instruction";
    case EXCEPTION_IN_PAGE_ERROR:
      return "page error";
    case EXCEPTION_ILLEGAL_INSTRUCTION:
      return "illegal instruction";
    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
      return "noncontinuable instruction";
    case EXCEPTION_STACK_OVERFLOW:
      return "stack overflow";
    case EXCEPTION_INVALID_DISPOSITION:
      return "invalid disosition";
    case EXCEPTION_GUARD_PAGE:
      return "guard page";
    case EXCEPTION_INVALID_HANDLE:
      return "invalid handle";
    default:
      return "operating system exception";
  }
}

static LPTSTR StrChr(LPTSTR lpsz, TCHAR ch)
{
  LPTSTR p = NULL;
  while (*lpsz)
  {
    if (*lpsz == ch)
    {
      p = lpsz;
      break;
    }
    lpsz = CharNext(lpsz);
  }
  return p;
}

const char *objName = "ImageMagickObject";

#define ThrowPerformException(exception,code,reason,description) \
{ \
  (void) MagickLib::LogMagickEvent(MagickLib::ResourceEvent,GetMagickModule(), \
    "%s - %s %s",objName,reason,description); \
  MagickLib::ThrowException(exception,code,reason,description); \
  return E_INVALIDARG; \
}

#define LogInformation(reason,description) \
{ \
  (void) MagickLib::LogMagickEvent(MagickLib::ResourceEvent,GetMagickModule(), \
    "%s - %s %s",objName,reason,description); \
}

const char *methodName = "Perform";

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);
}

STDMETHODIMP MagickImage::get_Count(long *pVal)
{
  HRESULT hr = S_OK;
  return hr;
}

STDMETHODIMP MagickImage::get__NewEnum(LPUNKNOWN *pVal)
{
  HRESULT hr = S_OK;
  return hr;
}

STDMETHODIMP MagickImage::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)
        {
          MagickLib::Image
            *image;

          MagickLib::ImageInfo
            *image_info;

          MagickLib::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
          MagickLib::GetExceptionInfo(&exception);
          image=MagickLib::GetImageFromMagickRegistry(lpszVal, &id, &exception);
          if (image != (MagickLib::Image *) NULL)
            {
              TCHAR *text;

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

      MagickLib::ImageInfo
        *image_info;

      MagickLib::ExceptionInfo
        exception;

      long
        id;

      MagickLib::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
      MagickLib::GetExceptionInfo(&exception);
      image=(MagickLib::Image *)MagickLib::GetMagickRegistry(id,&type,&length,&exception);
      if (image != (MagickLib::Image *) NULL)
        {
          TCHAR *text;

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

STDMETHODIMP MagickImage::get_Messages(VARIANT *pVar)
{
  HRESULT hr = S_OK;
#ifdef PERFORM_MESSAGE_CACHING
  if (m_coll.size())
  {