RTDECL(bool) RTManifestEntryExists(RTMANIFEST hManifest, const char *pszEntry)
{
RTMANIFESTINT *pThis = hManifest;
AssertPtrReturn(pThis, false);
AssertReturn(pThis->u32Magic == RTMANIFEST_MAGIC, false);
AssertPtr(pszEntry);
bool fNeedNormalization;
size_t cchEntry;
int rc = rtManifestValidateNameEntry(pszEntry, &fNeedNormalization, &cchEntry);
AssertRCReturn(rc, false);
/*
* Check if it exists.
*/
PRTMANIFESTENTRY pEntry;
rc = rtManifestGetEntry(pThis, pszEntry, fNeedNormalization, cchEntry, &pEntry);
return RT_SUCCESS_NP(rc);
}
DECLCALLBACK(int) VBoxClipboardInit(const PVBOXSERVICEENV pEnv, void **ppInstance)
{
LogFlowFuncEnter();
PVBOXCLIPBOARDCONTEXT pCtx = &g_Ctx; /* Only one instance for now. */
AssertPtr(pCtx);
if (pCtx->pEnv)
{
/* Clipboard was already initialized. 2 or more instances are not supported. */
return VERR_NOT_SUPPORTED;
}
if (VbglR3AutoLogonIsRemoteSession())
{
/* Do not use clipboard for remote sessions. */
LogRel(("Clipboard: Clipboard has been disabled for a remote session\n"));
return VERR_NOT_SUPPORTED;
}
RT_BZERO(pCtx, sizeof(VBOXCLIPBOARDCONTEXT));
pCtx->pEnv = pEnv;
/* Check that new Clipboard API is available */
vboxClipboardInitNewAPI(pCtx);
int rc = VbglR3ClipboardConnect(&pCtx->u32ClientID);
if (RT_SUCCESS(rc))
{
rc = vboxClipboardCreateWindow(pCtx);
if (RT_SUCCESS(rc))
{
*ppInstance = pCtx;
}
else
{
VbglR3ClipboardDisconnect(pCtx->u32ClientID);
}
}
LogFlowFuncLeaveRC(rc);
return rc;
}
/**
* Logs a verbose message.
*
* @param pszFormat The message text.
* @param va Format arguments.
*/
void VGSvcLogV(const char *pszFormat, va_list va)
{
#ifdef DEBUG
int rc = RTCritSectEnter(&g_csLog);
if (RT_SUCCESS(rc))
{
#endif
char *psz = NULL;
RTStrAPrintfV(&psz, pszFormat, va);
AssertPtr(psz);
LogRel(("%s", psz));
RTStrFree(psz);
#ifdef DEBUG
RTCritSectLeave(&g_csLog);
}
#endif
}
RTDECL(void) RTSpinlockAcquire(RTSPINLOCK Spinlock)
{
PRTSPINLOCKINTERNAL pThis = (PRTSPINLOCKINTERNAL)Spinlock;
RT_ASSERT_PREEMPT_CPUID_VAR();
AssertPtr(pThis);
Assert(pThis->u32Magic == RTSPINLOCK_MAGIC);
if (pThis->fFlags & RTSPINLOCK_FLAGS_INTERRUPT_SAFE)
{
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
uint32_t fIntSaved = ASMIntDisableFlags();
#endif
mutex_enter(&pThis->Mtx);
/*
* Solaris 10 doesn't preserve the interrupt flag, but since we're at PIL_MAX we should be
* fine and not get interrupts while lock is held. Re-disable interrupts to not upset
* assertions & assumptions callers might have.
*/
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
ASMIntDisable();
#endif
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
Assert(!ASMIntAreEnabled());
#endif
pThis->fIntSaved = fIntSaved;
}
else
{
#if defined(RT_STRICT) && (defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86))
bool fIntsOn = ASMIntAreEnabled();
#endif
mutex_enter(&pThis->Mtx);
#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
AssertMsg(fIntsOn == ASMIntAreEnabled(), ("fIntsOn=%RTbool\n", fIntsOn));
#endif
}
RT_ASSERT_PREEMPT_CPUID_SPIN_ACQUIRED(pThis);
}
/**
* Invokes the write-MSR handler for the GIM provider configured for the VM.
*
* @returns Strict VBox status code like CPUMSetGuestMsr.
* @retval VINF_CPUM_R3_MSR_WRITE
* @retval VERR_CPUM_RAISE_GP_0
*
* @param pVCpu Pointer to the VMCPU.
* @param idMsr The MSR to write.
* @param pRange The range this MSR belongs to.
* @param uValue The value to set, ignored bits masked.
* @param uRawValue The raw value with the ignored bits not masked.
*/
VMM_INT_DECL(VBOXSTRICTRC) GIMWriteMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uValue, uint64_t uRawValue)
{
AssertPtr(pVCpu);
NOREF(uValue);
PVM pVM = pVCpu->CTX_SUFF(pVM);
Assert(GIMIsEnabled(pVM));
VMCPU_ASSERT_EMT(pVCpu);
switch (pVM->gim.s.enmProviderId)
{
case GIMPROVIDERID_HYPERV:
return GIMHvWriteMsr(pVCpu, idMsr, pRange, uRawValue);
default:
AssertMsgFailed(("GIMWriteMsr: for unknown provider %u idMsr=%#RX32 -> #GP(0)", pVM->gim.s.enmProviderId, idMsr));
return VERR_CPUM_RAISE_GP_0;
}
}
void VBoxSeamlessDestroy(void *pInstance)
{
LogFlowFuncEnter();
PVBOXSEAMLESSCONTEXT pCtx = (PVBOXSEAMLESSCONTEXT)pInstance;
AssertPtr(pCtx);
VBoxSeamlessSetSupported(FALSE);
/* Inform the host that we no longer support the seamless window mode. */
if (pCtx->pfnVBoxHookRemoveWindowTracker)
pCtx->pfnVBoxHookRemoveWindowTracker();
if (pCtx->hModHook != NIL_RTLDRMOD)
{
RTLdrClose(pCtx->hModHook);
pCtx->hModHook = NIL_RTLDRMOD;
}
return;
}
/**
* Internal worker for the RTMpOn* APIs using KeIpiGenericCall.
*
* @returns IPRT status code.
* @param pfnWorker The callback.
* @param pvUser1 User argument 1.
* @param pvUser2 User argument 2.
* @param enmCpuid What to do / is idCpu valid.
* @param idCpu Used if enmCpuid RT_NT_CPUID_SPECIFIC, otherwise ignored.
*/
static int rtMpCallUsingBroadcastIpi(PFNRTMPWORKER pfnWorker, void *pvUser1, void *pvUser2,
PKIPI_BROADCAST_WORKER pfnNativeWrapper, RTCPUID idCpu)
{
RTMPARGS Args;
Args.pfnWorker = pfnWorker;
Args.pvUser1 = pvUser1;
Args.pvUser2 = pvUser2;
Args.idCpu = idCpu;
Args.cRefs = 0;
Args.cHits = 0;
AssertPtr(g_pfnrtKeIpiGenericCall);
g_pfnrtKeIpiGenericCall(pfnNativeWrapper, (uintptr_t)&Args);
if ( pfnNativeWrapper != rtmpNtOnSpecificBroadcastIpiWrapper
|| Args.cHits > 0)
return VINF_SUCCESS;
return VERR_CPU_OFFLINE;
}
/**
* Destroys a DBGC instance created by dbgcCreate.
*
* @param pDbgc Pointer to the debugger console instance data.
*/
void dbgcDestroy(PDBGC pDbgc)
{
AssertPtr(pDbgc);
/* Disable log hook. */
if (pDbgc->fLog)
{
}
/* Unload all plug-ins. */
dbgcPlugInUnloadAll(pDbgc);
/* Detach from the VM. */
if (pDbgc->pVM)
DBGFR3Detach(pDbgc->pVM);
/* finally, free the instance memory. */
RTMemFree(pDbgc);
}
bool DevAssetManager::ContainsAsset( const char* filePath ) const
{
AssertPtr(filePath);
VRET_FALSE_IF_NIL(filePath);
String fileName( filePath );
// check if the file is located in source assets folder and extract its name
{
const bool casesensitive = true;
const INT pos = String::FindText( filePath, m_pathToSrcAssets, casesensitive );
if( pos != INDEX_NONE )
{
// get file name relative to base folder
fileName.StripLeadingOnce( m_pathToSrcAssets );
}
}
return m_assetIDs.FindGuidByName( fileName ) != nil;
}
/*----------------------------------------------------------------------------------------------
Open a key, which is the name of a Graphite font, and return a handle to it.
@param pszFontKey - the name of the font
@param pszStyle - regular, bold, italic, bolditalic;
ignored here--caller opens string value
@param at - access
@param phkey - handle to return
----------------------------------------------------------------------------------------------*/
bool GrUtil::OpenFontKey(const utf16 * pszFontKey, const utf16 * pszStyle,
AccessType at, HKEY * phkey)
{
AssertPsz((const wchar_t*)pszFontKey);
AssertPsz((const wchar_t*)pszStyle);
AssertPtr(phkey);
//#ifdef GR_FW
// StrApp str;
// str.Format(_T("Software\\SIL\\GraphiteFonts\\%s"), pszFontKey);
//#else
OLECHAR str[260];
_stprintf_s(str, _T("Software\\SIL\\GraphiteFonts\\%s"), (wchar_t*)pszFontKey);
//#endif
if (at == katRead)
return ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, str, 0, at, phkey) == ERROR_SUCCESS;
return ::RegCreateKeyEx(HKEY_LOCAL_MACHINE, str, 0, NULL, 0, at, NULL, phkey,
NULL) == ERROR_SUCCESS;
}
/**
* Checks if receive is possible and increases busy and ref counters if so.
*
* @param pThis The instance.
*/
DECLHIDDEN(bool) vboxNetAdpPrepareToReceive(PVBOXNETADP pThis)
{
bool fCanReceive = false;
/*
* Input validation.
*/
AssertPtr(pThis);
Assert(pThis->MyPort.u32Version == INTNETTRUNKIFPORT_VERSION);
RTSpinlockAcquire(pThis->hSpinlock);
if (vboxNetAdpGetState(pThis) == kVBoxNetAdpState_Active)
{
fCanReceive = true;
vboxNetAdpRetain(pThis);
vboxNetAdpBusy(pThis);
}
RTSpinlockRelease(pThis->hSpinlock);
Log(("vboxNetAdpPrepareToReceive: fCanReceive=%d.\n", fCanReceive));
return fCanReceive;
}
/*----------------------------------------------------------------------------------------------
Get the empty string for this thread.
----------------------------------------------------------------------------------------------*/
void TextServGlobals::GetEmptyString(ITsString ** pptss)
{
AssertPtr(pptss);
Assert(!*pptss);
TextServGlobals * ptsg = GetTsGlobals();
if (!ptsg->m_qtssEmpty)
{
if (ptsg->m_cactActive <= 0)
{
Warn("Empty string requested with no active clients");
TsStrSingle::Create((OLECHAR *)NULL, 0, NULL, pptss);
}
TsStrSingle::Create((OLECHAR *)NULL, 0, NULL, &ptsg->m_qtssEmpty);
}
*pptss = ptsg->m_qtssEmpty;
AddRefObj(*pptss);
}
/***********************************************************************************************
IUnknown Methods
***********************************************************************************************/
STDMETHODIMP AfFwTool::QueryInterface(REFIID riid, void **ppv)
{
AssertPtr(ppv);
if (!ppv)
return WarnHr(E_POINTER);
*ppv = NULL;
if (riid == IID_IUnknown)
*ppv = static_cast<IUnknown *>(this);
else if (riid == IID_IFwTool)
*ppv = static_cast<IFwTool *>(this);
else
// Note: When we use the ROT, we get numerous calls here, including IID_IProxyManager,
// IID_IMarshal, IID_IStdMarshalInfo, IID_IExternalConnection, etc. We should not be
// using a WarnHr.
return E_NOINTERFACE;
AddRef();
return NOERROR;
}
RTDECL(int) RTThreadCtxHooksDeregister(RTTHREADCTX hThreadCtx)
{
/*
* Validate input.
*/
PRTTHREADCTXINT pThis = hThreadCtx;
if (pThis == NIL_RTTHREADCTX)
return VERR_INVALID_HANDLE;
AssertPtr(pThis);
AssertMsgReturn(pThis->u32Magic == RTTHREADCTXINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
VERR_INVALID_HANDLE);
Assert(pThis->hOwner == RTThreadNativeSelf());
Assert(pThis->fRegistered);
/*
* Deregister the callback.
*/
rtThreadCtxHooksDeregister(pThis);
return VINF_SUCCESS;
}
/**
* Reads a guest property as a 32-bit value.
*
* @returns VBox status code, fully bitched.
*
* @param u32ClientId The HGCM client ID for the guest property session.
* @param pszPropName The property name.
* @param pu32 Where to store the 32-bit value.
*
*/
int VBoxServiceReadPropUInt32(uint32_t u32ClientId, const char *pszPropName, uint32_t *pu32, uint32_t u32Min, uint32_t u32Max)
{
char *pszValue;
int rc = VBoxServiceReadProp(u32ClientId, pszPropName, &pszValue,
NULL /* ppszFlags */, NULL /* puTimestamp */);
if (RT_SUCCESS(rc))
{
AssertPtr(pu32);
char *pszNext;
rc = RTStrToUInt32Ex(pszValue, &pszNext, 0, pu32);
if ( RT_SUCCESS(rc)
&& (*pu32 < u32Min || *pu32 > u32Max))
{
rc = VBoxServiceError("The guest property value %s = %RU32 is out of range [%RU32..%RU32].\n",
pszPropName, *pu32, u32Min, u32Max);
}
RTStrFree(pszValue);
}
return rc;
}
static void pdmNsBwGroupUnlink(PPDMNSBWGROUP pBwGroup)
{
PPDMNETSHAPER pShaper = pBwGroup->pShaper;
LOCK_NETSHAPER(pShaper);
if (pBwGroup == pShaper->pBwGroupsHead)
pShaper->pBwGroupsHead = pBwGroup->pNext;
else
{
PPDMNSBWGROUP pPrev = pShaper->pBwGroupsHead;
while ( pPrev
&& pPrev->pNext != pBwGroup)
pPrev = pPrev->pNext;
AssertPtr(pPrev);
pPrev->pNext = pBwGroup->pNext;
}
UNLOCK_NETSHAPER(pShaper);
}
static void pdmNsBwGroupUnlink(PPDMNSBWGROUP pBwGroup)
{
PPDMNETSHAPER pShaper = pBwGroup->pShaper;
int rc = RTCritSectEnter(&pShaper->cs); AssertRC(rc);
if (pBwGroup == pShaper->pBwGroupsHead)
pShaper->pBwGroupsHead = pBwGroup->pNext;
else
{
PPDMNSBWGROUP pPrev = pShaper->pBwGroupsHead;
while ( pPrev
&& pPrev->pNext != pBwGroup)
pPrev = pPrev->pNext;
AssertPtr(pPrev);
pPrev->pNext = pBwGroup->pNext;
}
rc = RTCritSectLeave(&pShaper->cs); AssertRC(rc);
}
/**
* @interface_method_impl{PDMIVMMDEVCONNECTOR,pfnUpdateGuestInfo2}
*/
DECLCALLBACK(void) vmmdevUpdateGuestInfo2(PPDMIVMMDEVCONNECTOR pInterface, uint32_t uFullVersion,
const char *pszName, uint32_t uRevision, uint32_t fFeatures)
{
PDRVMAINVMMDEV pDrv = RT_FROM_MEMBER(pInterface, DRVMAINVMMDEV, Connector);
AssertPtr(pszName);
Assert(uFullVersion);
/* Store that information in IGuest. */
Guest *pGuest = pDrv->pVMMDev->getParent()->i_getGuest();
AssertPtrReturnVoid(pGuest);
/* Just pass it on... */
pGuest->i_setAdditionsInfo2(uFullVersion, pszName, uRevision, fFeatures);
/*
* No need to tell the console interface about the update;
* vmmdevUpdateGuestInfo takes care of that when called as the
* last event in the chain.
*/
}
/**
* Creates our provider. This happens *before* CTRL-ALT-DEL was pressed!
*/
HRESULT
VBoxCredProvProviderCreate(REFIID interfaceID, void **ppvInterface)
{
HRESULT hr;
try
{
VBoxCredProvProvider *pProvider = new VBoxCredProvProvider();
AssertPtr(pProvider);
hr = pProvider->QueryInterface(interfaceID, ppvInterface);
pProvider->Release();
}
catch (std::bad_alloc &ex)
{
NOREF(ex);
hr = E_OUTOFMEMORY;
}
return hr;
}
RTDECL(int) RTPipeWriteBlocking(RTPIPE hPipe, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten)
{
RTPIPEINTERNAL *pThis = hPipe;
AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
AssertReturn(pThis->u32Magic == RTPIPE_MAGIC, VERR_INVALID_HANDLE);
AssertReturn(!pThis->fRead, VERR_ACCESS_DENIED);
AssertPtr(pvBuf);
AssertPtrNull(pcbWritten);
int rc = rtPipeTryBlocking(pThis);
if (RT_SUCCESS(rc))
{
size_t cbTotalWritten = 0;
while (cbToWrite > 0)
{
ssize_t cbWritten = write(pThis->fd, pvBuf, RT_MIN(cbToWrite, SSIZE_MAX));
if (cbWritten < 0)
{
rc = RTErrConvertFromErrno(errno);
break;
}
/* advance */
pvBuf = (char const *)pvBuf + cbWritten;
cbTotalWritten += cbWritten;
cbToWrite -= cbWritten;
}
if (pcbWritten)
{
*pcbWritten = cbTotalWritten;
if ( RT_FAILURE(rc)
&& cbTotalWritten
&& rc != VERR_INVALID_POINTER)
rc = VINF_SUCCESS;
}
ASMAtomicDecU32(&pThis->u32State);
}
return rc;
}
/**
* Adds a line number to the module.
*
* @returns IPRT status code.
* @retval VERR_NOT_SUPPORTED if the module interpret doesn't support adding
* custom symbols. This should be consider a normal response.
* @retval VERR_INVALID_HANDLE if hDbgMod is invalid.
* @retval VERR_DBG_FILE_NAME_OUT_OF_RANGE if the file name is too longer or
* empty.
* @retval VERR_DBG_INVALID_RVA if an image relative address is specified and
* it's not inside any of the segments defined by the module.
* @retval VERR_DBG_INVALID_SEGMENT_INDEX if the segment index isn't valid.
* @retval VERR_DBG_INVALID_SEGMENT_OFFSET if the segment offset is beyond the
* end of the segment.
* @retval VERR_INVALID_PARAMETER if the line number flags sets undefined bits.
*
* @param hDbgMod The module handle.
* @param pszFile The file name.
* @param uLineNo The line number.
* @param iSeg The segment index.
* @param off The segment offset.
* @param piOrdinal Where to return the line number ordinal on
* success. If the interpreter doesn't do ordinals,
* this will be set to UINT32_MAX. Optional.
*/
RTDECL(int) RTDbgModLineAdd(RTDBGMOD hDbgMod, const char *pszFile, uint32_t uLineNo,
RTDBGSEGIDX iSeg, RTUINTPTR off, uint32_t *piOrdinal)
{
/*
* Validate input.
*/
PRTDBGMODINT pDbgMod = hDbgMod;
RTDBGMOD_VALID_RETURN_RC(pDbgMod, VERR_INVALID_HANDLE);
AssertPtr(pszFile);
size_t cchFile = strlen(pszFile);
AssertReturn(cchFile, VERR_DBG_FILE_NAME_OUT_OF_RANGE);
AssertReturn(cchFile < RTDBG_FILE_NAME_LENGTH, VERR_DBG_FILE_NAME_OUT_OF_RANGE);
AssertMsgReturn( iSeg <= RTDBGSEGIDX_LAST
|| iSeg == RTDBGSEGIDX_RVA,
("%#x\n", iSeg),
VERR_DBG_INVALID_SEGMENT_INDEX);
AssertReturn(uLineNo > 0 && uLineNo < UINT32_MAX, VERR_INVALID_PARAMETER);
RTDBGMOD_LOCK(pDbgMod);
/*
* Convert RVAs.
*/
if (iSeg == RTDBGSEGIDX_RVA)
{
iSeg = pDbgMod->pDbgVt->pfnRvaToSegOff(pDbgMod, off, &off);
if (iSeg == NIL_RTDBGSEGIDX)
{
RTDBGMOD_UNLOCK(pDbgMod);
return VERR_DBG_INVALID_RVA;
}
}
/*
* Get down to business.
*/
int rc = pDbgMod->pDbgVt->pfnLineAdd(pDbgMod, pszFile, cchFile, uLineNo, iSeg, off, piOrdinal);
RTDBGMOD_UNLOCK(pDbgMod);
return rc;
}
/*----------------------------------------------------------------------------------------------
Check the requirments of the FldSpec, and verify that data in the field meets the
requirement. It returns:
kFTReqNotReq if the all requirements are met.
kFTReqWs if data is missing, but it is encouraged.
kFTReqReq if data is missing, but it is required.
----------------------------------------------------------------------------------------------*/
FldReq AfDeFeSt::HasRequiredData()
{
if (m_qfsp->m_fRequired == kFTReqNotReq)
return kFTReqNotReq;
CustViewDaPtr qcvd;
GetDataAccess(&qcvd);
AssertPtr(qcvd);
bool fEmpty = true;
ITsStringPtr qtss;
int cch = 0;
HVO hvoPara;
int iPara;
if (!m_hvoText)
goto LExit;
int cPara;
CheckHr(qcvd->get_VecSize(m_hvoText, kflidStText_Paragraphs, &cPara));
if (!cPara)
goto LExit;
// Make sure at least some paragraph has data.
for (iPara = 0; iPara < cPara; ++iPara)
{
CheckHr(qcvd->get_VecItem(m_hvoText, kflidStText_Paragraphs, iPara, &hvoPara));
// At some point we may need to handle something other than StTxtPara.
CheckHr(qcvd->get_StringProp(hvoPara, kflidStTxtPara_Contents, &qtss));
if (qtss)
CheckHr(qtss->get_Length(&cch));
if (cch)
break; // Have a valid string
}
fEmpty = iPara == cPara;
LExit:
if (fEmpty)
return m_qfsp->m_fRequired;
else
return kFTReqNotReq;
}
/**
* Get the real name of a shared folder.
*
* @returns VBox status code.
* @param u32ClientId The client id returned by VbglR3InvsSvcConnect().
* @param u32Root Root ID of shared folder to get the name for.
* @param ppszName Where to return the name string. This shall be
* freed by calling RTStrFree.
*/
VBGLR3DECL(int) VbglR3SharedFolderGetName(uint32_t u32ClientId, uint32_t u32Root, char **ppszName)
{
AssertPtr(ppszName);
VBoxSFQueryMapName Msg;
Msg.callInfo.result = VERR_WRONG_ORDER;
Msg.callInfo.u32ClientID = u32ClientId;
Msg.callInfo.u32Function = SHFL_FN_QUERY_MAP_NAME;
Msg.callInfo.cParms = 2;
int rc;
uint32_t cbString = SHFLSTRING_HEADER_SIZE + SHFL_MAX_LEN;
PSHFLSTRING pString = (PSHFLSTRING)RTMemAlloc(cbString);
if (pString)
{
if (!ShflStringInitBuffer(pString, cbString))
{
RTMemFree(pString);
return VERR_INVALID_PARAMETER;
}
VbglHGCMParmUInt32Set(&Msg.root, u32Root);
VbglHGCMParmPtrSet(&Msg.name, pString, cbString);
rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
if (RT_SUCCESS(rc))
{
rc = Msg.callInfo.result;
if (RT_SUCCESS(rc))
{
*ppszName = NULL;
rc = RTUtf16ToUtf8(&pString->String.ucs2[0], ppszName);
}
}
RTMemFree(pString);
}
else
rc = VERR_INVALID_PARAMETER;
return rc;
}
QWidget* GetPropertyEditor( AEditableProperty* theProperty )
{
if (theProperty->Is<EdProperty_Bool>())
{
return static_cast< BoolPropertyEditor*>( theProperty->editor.Ptr );
}
else if (theProperty->Is<EdProperty_UInt32>())
{
return static_cast< UInt32PropertyEditor*>( theProperty->editor.Ptr );
}
else if (theProperty->Is<EdProperty_Float>())
{
return static_cast< FloatPropertyEditor*>( theProperty->editor.Ptr );
}
else if (theProperty->Is<EdProperty_Vector3D>())
{
return static_cast< Vec3DPropertyEditor*>( theProperty->editor.Ptr );
}
else if (theProperty->Is<EdProperty_Quat>())
{
return static_cast< QuaternionPropertyEditor*>( theProperty->editor.Ptr );
}
else if (theProperty->Is<EdProperty_Array>())
{
// each item of the array will have a separate editor
return nil;
}
//else if (theProperty->Is<EdProperty_AssetReference>())
//{
// return static_cast< ResourceRefPropertyEditor*>( theProperty->editor.Ptr );
//}
else
{
APropertyEditor* pEditor = theProperty->editor;
AssertPtr(pEditor);
return static_cast<QWidget*>(static_cast<void*>(pEditor));
/*DBGOUT("Unknown property: '%s'\n",theProperty->edToChars(0));
Unimplemented;
return nil;*/
}
}
DEFINE_THIS_FILE
//:End Ignore
//:>********************************************************************************************
//:> PropertiesDlg Implementation
//:>********************************************************************************************
/*----------------------------------------------------------------------------------------------
Process notifications for this dialog from some event on a control. This method is called
by the framework.
@param ctid Id of the control that issued the windows command.
@param pnmh Windows command that is being passed.
@param lnRet return value to be returned to the windows command.
@return true if command is handled.
See ${AfWnd#OnNotifyChild}
----------------------------------------------------------------------------------------------*/
bool PropertiesDlg::OnNotifyChild(int ctid, NMHDR * pnmh, long & lnRet)
{
AssertPtr(pnmh);
int itab;
switch (pnmh->code)
{
case TCN_SELCHANGE:
// Make sure we can move to the current tab.
itab = TabCtrl_GetCurSel(m_hwndTab);
Assert((uint)itab < (uint)m_vqdlgv.Size());
ShowChildDlg(itab);
return true;
case TCN_SELCHANGING:
// Make sure that we can move off of the current tab.
itab = TabCtrl_GetCurSel(m_hwndTab);
Assert((uint)itab < (uint)m_vqdlgv.Size());
lnRet = !m_vqdlgv[itab]->QueryClose(AfDialogView::kqctChange);
return true;
}
return SuperClass::OnNotifyChild(ctid, pnmh, lnRet);
}
/**
* Send a byte (keystroke or command response) to the keyboard controller.
*
* @returns VINF_SUCCESS or VINF_TRY_AGAIN.
* @param pThis The PS/2 auxiliary device instance data.
* @param pb Where to return the byte we've read.
* @remarks Caller must have entered the device critical section.
*/
int PS2MByteFromAux(PPS2M pThis, uint8_t *pb)
{
int rc;
AssertPtr(pb);
/* Anything in the command queue has priority over data
* in the event queue. Additionally, keystrokes are //@todo: true?
* blocked if a command is currently in progress, even if
* the command queue is empty.
*/
//@todo: Probably should flush/not fill queue if stream mode reporting disabled?!
rc = ps2kRemoveQueue((GeneriQ *)&pThis->cmdQ, pb);
if (rc != VINF_SUCCESS && !pThis->u8CurrCmd && (pThis->u8State & AUX_STATE_ENABLED))
rc = ps2kRemoveQueue((GeneriQ *)&pThis->evtQ, pb);
LogFlowFunc(("mouse sends 0x%02x (%svalid data)\n", *pb, rc == VINF_SUCCESS ? "" : "not "));
//if (rc == VINF_SUCCESS) LogRel(("aux: sends 0x%02X\n", *pb));
return rc;
}
/** @copydoc VBOXHDDBACKEND::pfnSetParentModificationUuid */
static DECLCALLBACK(int) rawSetParentModificationUuid(void *pBackendData, PCRTUUID pUuid)
{
LogFlowFunc(("pBackendData=%#p Uuid=%RTuuid\n", pBackendData, pUuid));
PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
int rc;
AssertPtr(pImage);
if (pImage)
{
if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
rc = VERR_NOT_SUPPORTED;
else
rc = VERR_VD_IMAGE_READ_ONLY;
}
else
rc = VERR_VD_NOT_OPENED;
LogFlowFunc(("returns %Rrc\n", rc));
return rc;
}
RTDECL(void) RTThreadPreemptRestore(PRTTHREADPREEMPTSTATE pState)
{
AssertPtr(pState);
Assert(pState->u32Reserved == 42);
pState->u32Reserved = 0;
RT_ASSERT_PREEMPT_CPUID_RESTORE(pState);
RTCPUID idCpu = RTMpCpuId();
if (RT_UNLIKELY(idCpu < RT_ELEMENTS(g_aPreemptHacks)))
{
Assert(g_aPreemptHacks[idCpu].cRecursion > 0);
if (--g_aPreemptHacks[idCpu].cRecursion == 0)
{
lck_spin_t *pSpinLock = g_aPreemptHacks[idCpu].pSpinLock;
if (pSpinLock)
lck_spin_unlock(pSpinLock);
else
AssertFailed();
}
}
}
/** @copydoc VBOXHDDBACKEND::pfnSetComment */
static DECLCALLBACK(int) rawSetComment(void *pBackendData, const char *pszComment)
{
LogFlowFunc(("pBackendData=%#p pszComment=\"%s\"\n", pBackendData, pszComment));
PRAWIMAGE pImage = (PRAWIMAGE)pBackendData;
int rc;
AssertPtr(pImage);
if (pImage)
{
if (pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY)
rc = VERR_VD_IMAGE_READ_ONLY;
else
rc = VERR_NOT_SUPPORTED;
}
else
rc = VERR_VD_NOT_OPENED;
LogFlowFunc(("returns %Rrc\n", rc));
return rc;
}
int GuestObject::callbackRemoveAll(void)
{
int vrc = VINF_SUCCESS;
/*
* Cancel all callbacks + waiters.
* Note: Deleting them is the job of the caller!
*/
for (GuestCtrlCallbacks::iterator itCallbacks = mObject.mCallbacks.begin();
itCallbacks != mObject.mCallbacks.end(); ++itCallbacks)
{
GuestCtrlCallback *pCallback = itCallbacks->second;
AssertPtr(pCallback);
int rc2 = pCallback->Cancel();
if (RT_SUCCESS(vrc))
vrc = rc2;
}
mObject.mCallbacks.clear();
return vrc;
}
