コード例 #1
0
ファイル: KUIInterfaceElement.cpp プロジェクト: cllpyl/KeshUI
bool UKUIInterfaceElement::IsCursorOver() const
{
	if ( GetInterface() == NULL )
	{
		KUIErrorUO( "Null interface" );
		return false;
	}

	return IsPointOver( GetInterface()->GetCursorLocation() );
}
コード例 #2
0
STDMETHODIMP CAVISplitter::NonDelegatingQueryInterface(REFIID iid, void** ppv)
{
	if (iid == IID_ISpecifyPropertyPages)
		return GetInterface((ISpecifyPropertyPages *) this, ppv);
    else if (iid == IID_ISMMModuleConfig)
        return GetInterface((ISMMModuleConfig*)this, ppv);
	else if (iid == IID_IPersistStream)
		return GetInterface((CPersistStream*)this, ppv);
	return CBaseFilter::NonDelegatingQueryInterface(iid, ppv);
}
コード例 #3
0
ファイル: CCivilianPedSA.cpp プロジェクト: qaisjp/green-candy
/**
 * Constructor for CCivilianPedSA
 */
CCivilianPedSA::CCivilianPedSA( CCivilianPedSAInterface *ped, modelId_t modelID ) : CPedSA( ped )
{
    DEBUG_TRACE("CCivilianPedSA::CCivilianPedSA( CCivilianPedSAInterface *ped, unsigned short modelID )");

    SetType( CIVILIAN_PED );
    SetModelIndex( modelID );

    BOOL_FLAG( GetInterface()->m_entityFlags, ENTITY_DISABLESTREAMING, true );
    BOOL_FLAG( GetInterface()->m_entityFlags, ENTITY_NOSTREAM, true );
}
コード例 #4
0
ファイル: CDemuxSource.cpp プロジェクト: xmoeproject/X-moe
//----------------------------------------------------------------------------
//! @brief	  	要求されたインターフェイスを返す
//! @param		riid : インターフェイスのIID
//! @param		ppv : インターフェイスを返すポインターへのポインタ
//! @return		エラーコード
//----------------------------------------------------------------------------
STDMETHODIMP CDemuxSource::NonDelegatingQueryInterface( REFIID riid, void ** ppv )
{
	if( riid == IID_IMediaSeeking ) {
		return GetInterface( static_cast<IMediaSeeking*>( this ), ppv );
	} else if( riid == IID_IAMFilterMiscFlags ) {
		return GetInterface( static_cast<IAMFilterMiscFlags*>( this ), ppv );
	} else {
		return CSource::NonDelegatingQueryInterface(riid, ppv);
	}
}
コード例 #5
0
ファイル: CamShiftTracker.cpp プロジェクト: JackJone/opencv
HRESULT CamShiftTracker::NonDelegatingQueryInterface(REFIID iid, void **ppv)
{
    if (iid == IID_ICamShiftTracker)
        return GetInterface((IUnknown *)(void *)static_cast<ICamShiftTracker *>(this), ppv);

    if (iid == IID_ITracker)
        return GetInterface((IUnknown *)(void *)static_cast<ITracker *>(this), ppv);

    return CUnknown::NonDelegatingQueryInterface(iid, ppv);
}
コード例 #6
0
STDMETHODIMP CMediaPacketSample::QueryInterface(REFIID riid, void **ppv)
{
    if (riid == __uuidof(ILAVMediaSample)) {
        return GetInterface((ILAVMediaSample *) this, ppv);
    }
    else if (riid == __uuidof(IMediaSideData)) {
        return GetInterface((IMediaSideData *) this, ppv);
    }
    return CMediaSample::QueryInterface(riid, ppv);
}
コード例 #7
0
STDMETHODIMP my12doomImageSource::NonDelegatingQueryInterface(REFIID riid, void ** ppv)
{
	if (riid == IID_IFileSourceFilter) 
		return GetInterface((IFileSourceFilter *) this, ppv);

	if (riid == IID_IStereoLayout) 
		return GetInterface((IStereoLayout *) this, ppv);

	return __super::NonDelegatingQueryInterface(riid, ppv);
}
コード例 #8
0
static struct DevBase *OS4DevInit(struct DevBase *dev_base, APTR seg_list,
   struct ExecIFace *i_exec)
{
   struct DevBase *base;
   BOOL success = TRUE;

   dev_base->i_exec = i_exec;
   base = dev_base;
   base->seg_list = seg_list;
   base->sys_base = (APTR)i_exec->Data.LibBase;

   base->device.dd_Library.lib_Node.ln_Type = NT_DEVICE;
   base->device.dd_Library.lib_Node.ln_Name = (TEXT *)device_name;
   base->device.dd_Library.lib_Flags = LIBF_SUMUSED | LIBF_CHANGED;
   base->device.dd_Library.lib_Version = VERSION;
   base->device.dd_Library.lib_Revision = REVISION;
   base->device.dd_Library.lib_IdString = (TEXT *)version_string;


   base->utility_base = (APTR)OpenLibrary(utility_name, UTILITY_VERSION);
   base->expansion_base = OpenLibrary(expansion_name, EXPANSION_VERSION);
   if(base->utility_base == NULL || base->expansion_base == NULL)
      success = FALSE;
   base->card_base = (APTR)OpenResource(card_name);
   base->pccard_base = (APTR)OpenLibrary(pccard_name, PCCARD_VERSION);

   if(OpenDevice(timer_name, UNIT_ECLOCK, (APTR)&base->timer_request, 0) !=
      0)
      success = FALSE;

   NewList((APTR)(&dev_base->pci_units));
   NewList((APTR)(&dev_base->pccard_units));
   base->wrapper_int_code = (APTR)OS4Int;

   if(success)
   {
      base->i_utility =
        (APTR)GetInterface((APTR)UtilityBase, "main", 1, NULL);
      base->i_pci =
        (APTR)GetInterface(ExpansionBase, "pci", 1, NULL);
      base->i_timer =
        (APTR)GetInterface((APTR)TimerBase, "main", 1, NULL);
      if(base->i_utility == NULL || base->i_pci == NULL
         || base->i_timer == NULL)
         success = FALSE;
   }

   if(!success)
   {
      DeleteDevice(base);
      base = NULL;
   }

   return base;
}
コード例 #9
0
STDMETHODIMP VMRSurfaceAllocator::NonDelegatingQueryInterface( REFIID refiid, void **lplpInterface )
{
	if ( IsEqualIID( refiid, IID_IVMRSurfaceAllocator9 ) )
	{
		return GetInterface( static_cast<IVMRSurfaceAllocator9 *>( this ), lplpInterface );
	} else if ( IsEqualIID( refiid, IID_IVMRImagePresenter9 ) )
	{
		return GetInterface( static_cast<IVMRImagePresenter9 *>( this ), lplpInterface );
	}

	return CUnknown::NonDelegatingQueryInterface( refiid, lplpInterface );
}
コード例 #10
0
ファイル: SyncClock.cpp プロジェクト: Azpidatziak/mpc-hc
STDMETHODIMP CSyncClockFilter::NonDelegatingQueryInterface(REFIID riid, void** ppv)
{
    CheckPointer(ppv, E_POINTER);

    if (riid == IID_IReferenceClock) {
        return GetInterface(static_cast<IReferenceClock*>(&m_Clock), ppv);
    } else if (riid == IID_ISyncClock) {
        return GetInterface(static_cast<ISyncClock*>(this), ppv);
    } else {
        return CBaseFilter::NonDelegatingQueryInterface(riid, ppv);
    }
}
コード例 #11
0
STDMETHODIMP CDXVA2MediaSample::QueryInterface(REFIID riid, void **ppv)
{
	CheckPointer(ppv, E_POINTER);

	if (riid == __uuidof(IDXVA2MediaSample)) {
		return GetInterface(static_cast<IDXVA2MediaSample*>(this), ppv);
	}
	if (riid == IID_IMFGetService) {
		return GetInterface(static_cast<IMFGetService*>(this), ppv);
	}

	return CMediaSample::QueryInterface(riid, ppv);
}
コード例 #12
0
ファイル: BasePin.cpp プロジェクト: EnoroF/easygamelibs
STDMETHODIMP
CBasePin::NonDelegatingQueryInterface(REFIID riid, void ** ppv)
{
	/* Do we have this interface */

	if (riid == IID_IPin) {
		return GetInterface((IPin *) this, ppv);
	} else if (riid == IID_IQualityControl) {
		return GetInterface((IQualityControl *) this, ppv);
	} else {
		return CUnknown::NonDelegatingQueryInterface(riid, ppv);
	}
}
コード例 #13
0
ファイル: Kalman.cpp プロジェクト: mikanradojevic/sdkpub
//
// NonDelegatingQueryInterface
//
// Reveals ICKalmTrack and ISpecifyPropertyPages
//
STDMETHODIMP CKalmTrack::NonDelegatingQueryInterface(REFIID riid, void **ppv)
{
    CheckPointer(ppv,E_POINTER);

    if (riid == IID_ICKalmTrack) {
        return GetInterface((ICKalmTrack *) this, ppv);
    } else if (riid == IID_ISpecifyPropertyPages) {
        return GetInterface((ISpecifyPropertyPages *) this, ppv);
    } else {
        return CTransInPlaceFilter::NonDelegatingQueryInterface(riid, ppv);
    }

} // NonDelegatingQueryInterface
コード例 #14
0
ファイル: M4M3DS.cpp プロジェクト: mojo-codec/M4M3-H265-Codec
STDMETHODIMP CM4M3DS::NonDelegatingQueryInterface(REFIID riid, void **ppv)
{
	CheckPointer(ppv, E_POINTER);

	if (riid == IID_IM4M3decoder)
	{
		return GetInterface((IM4M3decoder *) this, ppv);
	} 
	if (riid == IID_ISpecifyPropertyPages)
	{
		return GetInterface((ISpecifyPropertyPages *) this, ppv); 
	} 
	return CVideoTransformFilter::NonDelegatingQueryInterface(riid, ppv);
}
コード例 #15
0
STDMETHODIMP CDXVA2Sample::QueryInterface(REFIID riid, __deref_out void **ppv)
{
  CheckPointer(ppv,E_POINTER);
  ValidateReadWritePtr(ppv,sizeof(PVOID));

  if (riid == __uuidof(IMFGetService)) {
    return GetInterface((IMFGetService*) this, ppv);
  }
  if (riid == __uuidof(ILAVDXVA2Sample)) {
    return GetInterface((ILAVDXVA2Sample*) this, ppv);
  } else {
    return CMediaSample::QueryInterface(riid, ppv);
  }
}
コード例 #16
0
ファイル: AllocPresenter.cpp プロジェクト: grakidov/Render3D
//----------------------------------------------------------------------------
// NonDelegatingQueryInterface
//
//----------------------------------------------------------------------------
STDMETHODIMP
CMpegMovie::NonDelegatingQueryInterface(
    REFIID riid,
    void** ppv
    )
{
    if (riid == __uuidof(IVMRSurfaceAllocator)) {
        return GetInterface((IVMRSurfaceAllocator*)this, ppv);
    }
    else if (riid == __uuidof(IVMRImagePresenter)) {
        return GetInterface((IVMRImagePresenter*)this, ppv);
    }

    return CUnknown::NonDelegatingQueryInterface(riid,ppv);
}
コード例 #17
0
ファイル: OggDemuxFilter.cpp プロジェクト: John-He-928/krkrz
STDMETHODIMP OggDemuxFilter::NonDelegatingQueryInterface(REFIID riid, void **ppv)
{
    LOG(logDEBUG4) << L"NonDelegatingQueryInterface: " << riid;

    if (riid == IID_IOggBaseTime) 
    {
        return GetInterface((IOggBaseTime*)this, ppv);
    }
    else if (riid == IID_IOggSeekTable)
    {
        return GetInterface((IOggSeekTable*)this, ppv);
    }

    return CBaseFilter::NonDelegatingQueryInterface(riid, ppv); 
}
コード例 #18
0
STDMETHODIMP CSynthFilter::NonDelegatingQueryInterface(REFIID riid, void **ppv)
{
    if (riid == IID_ISynth2) {
        return GetInterface((ISynth2 *) this, ppv);
    }
    else if (riid == IID_IPersistStream) {
        return GetInterface((IPersistStream *) this, ppv);
    }
    else if (riid == IID_ISpecifyPropertyPages) {
        return GetInterface((ISpecifyPropertyPages *) this, ppv);
    } 
    else {
        return CDynamicSource::NonDelegatingQueryInterface(riid, ppv);
    }
}
コード例 #19
0
STDMETHODIMP CVideoSpringSendInputPin::NonDelegatingQueryInterface(REFIID riid, void **ppv)
{
	if(riid == IID_IVideoSpringSend)
	{
		return GetInterface(static_cast<IVideoSpringSend*>(this), ppv);
	}
	else if(riid == IID_IStream)
	{
		return GetInterface(static_cast<IStream*>(this), ppv);
	}
	else
	{
		return CBaseInputPin::NonDelegatingQueryInterface(riid, ppv);
	}
}
コード例 #20
0
ファイル: BCGPWnd.cpp プロジェクト: iclosure/jframework
LRESULT CBCGPWnd::OnGetObject(WPARAM wParam, LPARAM lParam)
{
	if (globalData.IsAccessibilitySupport () &&
		IsAccessibilityCompatible ())
	{

#if _MSC_VER >= 1300
		return CWnd::OnGetObject (wParam, lParam);
#else
        if ((DWORD)lParam == OBJID_CLIENT)
		{
			LPUNKNOWN pUnknown = GetInterface(&IID_IAccessible);
			if (!pUnknown)
			{
				return E_FAIL;
			}

			m_pStdObject = (IAccessible*)pUnknown;

			return LresultFromObject(IID_IAccessible, wParam, pUnknown);
		}
#endif
	}

	return (LRESULT)0L;
}	
コード例 #21
0
STDMETHODIMP CPageSite::NonDelegatingQueryInterface(REFIID riid, void **ppv)
{
	if (riid == IID_IPropertyPageSite) {
		return GetInterface((IPropertyPageSite*)this, ppv);
	} else
		return __super::NonDelegatingQueryInterface(riid, ppv);
}
コード例 #22
0
	//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
	// DeviceRemoved()
	//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
	void PlugIn::DeviceRemoved(Device& device)
	{
		// Suspend the device
		device.Unplug();

		// Save it's settings if necessary
		if (DALA::System::IsMaster())
			DP::DeviceSettings::SaveToPrefs(device, DP::DeviceSettings::sStandardControlsToSave, DP::DeviceSettings::kStandardNumberControlsToSave);

		{
			// Unlock the mutex since CMIOObjectsPublishedAndDied() can callout to property listeners
			CAMutex::Unlocker unlocker(GetStateMutex());

			// Tell the DAL that the device has gone away
			CMIOObjectID objectID = device.GetObjectID();
			OSStatus err = CMIOObjectsPublishedAndDied(GetInterface(), kCMIOObjectSystemObject, 0, 0, 1, &objectID);
			AssertNoError(err, "CMIO::DP::Sample::PlugIn::Teardown: got an error telling the DAL a device died");
		}
						
		// Remove it from the device list
		RemoveDevice(device);

		// Get rid of the device object
		device.Teardown();
		delete &device;
	}
コード例 #23
0
ファイル: tcpip.c プロジェクト: sba1/simplemail
/**
 * Open the AmiSSL3 library for the given thread.
 *
 * @param thread
 * @return 1 on success, 0 on failure.
 */
static int open_amissl3(struct thread_s *thread)
{
	thread->amisslmasterlib = NULL;
	thread->amissllib = NULL;

#ifdef __AMIGAOS4__
	thread->iamisslmaster = NULL;
	thread->iamissl =  NULL;
#endif

	if (!(thread->amisslmasterlib = OpenLibraryInterface("amisslmaster.library",AMISSLMASTER_MIN_VERSION, &thread->iamisslmaster)))
		goto bailout;

	if (!InitAmiSSLMaster(AMISSL_CURRENT_VERSION, TRUE))
		goto bailout;

	if (!(thread->amissllib = OpenAmiSSL()))
		goto bailout;

#ifdef __AMIGAOS4__
	if (!(thread->iamissl = (struct AmiSSLIFace *)GetInterface(thread->amissllib,"main",1,NULL)))
		goto bailout;
#endif
	if (InitAmiSSL(AmiSSL_SocketBase, (ULONG)SocketBase, TAG_DONE) != 0)
		goto bailout;

	return 1;
bailout:
	close_amissl3(thread);
	return 0;
}
コード例 #24
0
ファイル: SubPicImpl.cpp プロジェクト: Cyberbeing/xy-VSFilter
STDMETHODIMP CSubPicExImpl::NonDelegatingQueryInterface( REFIID riid, void** ppv )
{
    return
        QI(ISubPicEx)
        (riid == __uuidof(ISubPic)) ? GetInterface( static_cast<ISubPicEx*>(this), ppv) :
        __super::NonDelegatingQueryInterface(riid, ppv);
}
コード例 #25
0
ファイル: ami-rexx.c プロジェクト: diablodiab/libretro-uae
int rexx_init (void)
{
    RexxSysBase = (REXXBASE *) OpenLibrary ("rexxsyslib.library", 0L);
    if (!RexxSysBase) {
	write_log ("Can't find rexxsyslib.library!\n");
	return 0;
    }
#ifdef __amigaos4__
    IRexxSys = (struct RexxSysIFace *) GetInterface (RexxSysBase, "main", 1, NULL);
    if (!IRexxSys) {
	CloseLibrary (RexxSysBase);
	RexxSysBase = 0;
	return 0;
    }
#endif

    if (FindPort(UAE_PORTNAME)) {
	write_log ("Port \"%s\" already exists!\n", UAE_PORTNAME);
	return 0;
    }
    ARexxPort = CreatePort (UAE_PORTNAME, 0);
    if (!ARexxPort) {
	write_log ("Failed to open AREXX port \"%s\"!\n", UAE_PORTNAME);
	return 0;
    }
    write_log ("Rexx port \"%s\" installed.\n", UAE_PORTNAME);
    rexx_handle_events ();
    return 1;
}
コード例 #26
0
ファイル: RFS.cpp プロジェクト: Underground78/rarfilesource
STDMETHODIMP CRARFileSource::NonDelegatingQueryInterface (REFIID riid, void **ppv)
{
	if (riid == IID_IFileSourceFilter)
		return GetInterface ((IFileSourceFilter *) this, ppv);
	else
		return CBaseFilter::NonDelegatingQueryInterface (riid, ppv);
}
コード例 #27
0
ファイル: InviteChatDlg.cpp プロジェクト: alex765022/IBN
void CInviteChatDlg::InitMpaWebEvent()
{
	IConnectionPointContainer* pCPContainer = NULL;
	CComPtr<IConnectionPoint>  m_pSessionConnectionPoint;
	HRESULT hr = m_pWebCustomizer->QueryInterface(IID_IConnectionPointContainer,(void**)&pCPContainer);
	
	if (pCPContainer)
	{
		hr = pCPContainer->FindConnectionPoint(__uuidof(_IMpaWebCustomizerEvents),&m_pSessionConnectionPoint);
		if(SUCCEEDED(hr))
		{
			LPUNKNOWN pInterEvent = GetInterface(&IID_IUnknown);
			hr = m_pSessionConnectionPoint->Advise(pInterEvent ,&m_dwSessionCookie);
			pCPContainer->Release();
		}
		else
		{
			ASSERT(FALSE);
		}
	}
	else
	{
		ASSERT(FALSE);
	}
}
コード例 #28
0
ファイル: FW_Cmd.cpp プロジェクト: KnowNo/backup
// Once a command is new up, it will be added into FW_Cmds that will 
// manage the life cycle of this command
FW_Cmd::FW_Cmd(const CString& strDisplayName,
			   const CString& strTooltip,
			   CImageList& imageList,
			   const CString& strInternalName,
			   const int& iCmdId)
:m_strDisplayName(strDisplayName),
m_strTooltip(strTooltip),
m_strInternalName(strInternalName),
m_iCmdId(iCmdId),
m_bActive(false),
m_pView(NULL),
m_pDoc(NULL)
{
	FW_Cmds* pCmds = FW_WinApp::GetWinApp()->GetCmdManager()->GetCmds();
	ASSERT(pCmds);
	pCmds->Add(this);

	// Create an image list
	m_imageList.Create(&imageList);

	// If we have not specified the command id, generate one
	if(iCmdId==-1)
		m_iCmdId = pCmds->GenerateCmdId();

	// Create cmd object
	GetInterface();
}
コード例 #29
0
ファイル: pstream.cpp プロジェクト: kenygia/xy-vsfilter
SAMPLE CODE TO COPY - not active at the moment

//
// NonDelegatingQueryInterface
//
// This object supports IPersist & IPersistStream
STDMETHODIMP CPersistStream::NonDelegatingQueryInterface(REFIID riid, void** ppv)
{
    if (riid == IID_IPersist) {
        return GetInterface((IPersist*) this, ppv);
    } else if (riid == IID_IPersistStream) {
        return GetInterface((IPersistStream*) this, ppv);
    } else {
        return CUnknown::NonDelegatingQueryInterface(riid, ppv);
    }
}
コード例 #30
0
ファイル: amigasupport.c プロジェクト: sba1/simplemail
/* Opens URL */
VOID OpenURL(STRPTR uri)
{
#ifdef HAVE_OPENURL
	struct Library *OpenURLBase;

	if ((OpenURLBase = OpenLibrary("openurl.library",0)))
	{
#ifdef __AMIGAOS4__
		struct OpenURLIFace *IOpenURL = (struct OpenURLIFace *)GetInterface(OpenURLBase,"main",1,NULL);
		if (IOpenURL)
		{
			URL_OpenA(uri,NULL);
			DropInterface((struct Interface*)IOpenURL);
		} else
		{
			/* No interface, so call it manualy */
			EmulateTags(OpenURLBase,
					ET_Offset, -30,
					ET_RegisterA0, uri,
					ET_RegisterA1, NULL,
					ET_RegisterA6, OpenURLBase,
					ET_SaveRegs, TRUE,
					TAG_DONE);
		}
#else
		URL_OpenA(uri,NULL);
#endif
		CloseLibrary(OpenURLBase);
	}
#endif
}