MenuBar(Component* component) : Menu(new MenuAdapter(::CreateMenu())), _component(component)
{
if (component != App::getInstance())
throw UserInterfaceException("Only the App component can currently have a MenuBar.");
::SetMenu(HWND(component->getAdapter()->getHandle()), HMENU(getAdapter()->getHandle()));
}
/*
* Class: java_net_NetworkInterface
* Method: supportsMulticast0
* Signature: (Ljava/lang/String;I)Z
*/
JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_supportsMulticast0_XP
(JNIEnv *env, jclass cls, jstring name, jint index) {
IP_ADAPTER_ADDRESSES *ptr;
jboolean val = JNI_TRUE;
ptr = getAdapter(env, index);
if (ptr != NULL) {
val = ptr->Flags & IP_ADAPTER_NO_MULTICAST ? JNI_FALSE : JNI_TRUE;
free(ptr);
}
return val;
}
/*
* Class: java_net_NetworkInterface
* Method: isUp0
* Signature: (Ljava/lang/String;I)Z
*/
JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_isUp0_XP
(JNIEnv *env, jclass cls, jstring name, jint index) {
IP_ADAPTER_ADDRESSES *ptr;
jboolean val = JNI_FALSE;
ptr = getAdapter(env, index);
if (ptr != NULL) {
val = ptr->OperStatus == IfOperStatusUp ? JNI_TRUE : JNI_FALSE;
free(ptr);
}
return val;
}
/*
* Class: java_net_NetworkInterface
* Method: getMTU0
* Signature: ([bLjava/lang/String;I)I
*/
JNIEXPORT jint JNICALL Java_java_net_NetworkInterface_getMTU0_XP
(JNIEnv *env, jclass cls, jstring name, jint index) {
IP_ADAPTER_ADDRESSES *ptr;
jint ret = -1;
ptr = getAdapter(env, index);
if (ptr != NULL) {
ret = ptr->Mtu;
free(ptr);
}
return ret;
}
/*
* Class: java_net_NetworkInterface
* Method: isLoopback0
* Signature: (Ljava/lang/String;I)Z
*/
JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_isLoopback0_XP
(JNIEnv *env, jclass cls, jstring name, jint index) {
IP_ADAPTER_ADDRESSES *ptr;
jboolean val = JNI_FALSE;
ptr = getAdapter(env, index);
if (ptr != NULL) {
val = ptr->IfType == IF_TYPE_SOFTWARE_LOOPBACK ? JNI_TRUE : JNI_FALSE;
free(ptr);
}
return val;
}
StructAdapter::StructAdapter( RC::ConstHandle<Manager> const &manager, RC::ConstHandle<RT::StructDesc> const &structDesc )
: Adapter( manager, structDesc, FL_PASS_BY_REFERENCE )
, m_structDesc( structDesc )
, m_isShallow( structDesc->isShallow() )
{
size_t numMembers = m_structDesc->getNumMembers();
m_memberAdapters.reserve( numMembers );
for ( size_t i=0; i<numMembers; ++i )
{
RC::ConstHandle<Adapter> memberAdapter = getAdapter( m_structDesc->getMemberInfo( i ).desc );
m_memberAdapters.push_back( memberAdapter );
}
}
void OptionsMenu::populate(const jni::Object& menu)
{
auto children = getChildren();
// Set up the adapter if we don't have one.
if (!getAdapter())
setAdapter(new MenuAdapter(new jni::Object(menu)));
IMenuAdapter* adapter = getAdapter();
// Parse the tree hierarchy, instantiating system resources.
for (size_t i = 0; i < children.getLength(); ++i) {
auto& child = children[i];
if (child.type == MenuItemType::Menu) {
adapter->insert(i, *child.menu);
}
else if (child.type == MenuItemType::Action) {
adapter->insert(i, *child.action);
}
}
}
/**
* \brief add a servant to the adapter
*/
Ice::Identity CommunicatorSingleton::add(Ice::ObjectPtr servant) {
// create a new identity for the servant
Ice::Identity identity;
identity.name = IceUtil::generateUUID();
identity.category = "";
// add the servant to the adapter
getAdapter()->add(servant, identity);
debug(LOG_DEBUG, DEBUG_LOG, 0, "registered %s as %s",
astro::demangle(typeid(*servant).name()).c_str(),
identity.name.c_str());
// return the identity to the caller
return identity;
}
/*
* Class: java_net_NetworkInterface
* Method: isP2P0
* Signature: (Ljava/lang/String;I)Z
*/
JNIEXPORT jboolean JNICALL Java_java_net_NetworkInterface_isP2P0_XP
(JNIEnv *env, jclass cls, jstring name, jint index) {
IP_ADAPTER_ADDRESSES *ptr;
jboolean val = JNI_FALSE;
ptr = getAdapter(env, index);
if (ptr != NULL) {
if (ptr->IfType == IF_TYPE_PPP || ptr->IfType == IF_TYPE_SLIP ||
ptr->IfType == IF_TYPE_TUNNEL) {
val = JNI_TRUE;
}
free(ptr);
}
return val;
}
/*
* Class: java_net_NetworkInterface
* Method: getMacAddr0
* Signature: (Ljava/lang/String;I)Z
*/
JNIEXPORT jbyteArray JNICALL Java_java_net_NetworkInterface_getMacAddr0_XP
(JNIEnv *env, jclass cls, jstring name, jint index) {
IP_ADAPTER_ADDRESSES *ptr;
jbyteArray ret = NULL;
int len;
ptr = getAdapter(env, index);
if (ptr != NULL) {
len = ptr->PhysicalAddressLength;
ret = (*env)->NewByteArray(env, len);
if (!IS_NULL(ret)) {
(*env)->SetByteArrayRegion(env, ret, 0, len,
(jbyte*) ptr->PhysicalAddress);
}
free(ptr);
}
return ret;
}
bool MessageRouter::sendMessage(
const Message& message)
{
bool sentMessage = false;
// Retrieve the adapter.
Adapter* adapter = getAdapter(message.getDestination());
if (adapter == 0)
{
Logger::logDebug("Failed to send " + toString(message.getMessageId()) +
". No adapter specified for destination \"" + message.getDestination() + "\"\n");
}
else
{
// Send the message over the adapter.
sentMessage = adapter->sendMessage(message);
}
}
void TvideoCodecLibavcodecDxva::detectVideoCard(HWND hwnd)
{
IDirect3D9* pD3D9;
nPCIVendor = 0;
nPCIDevice = 0;
videoDriverVersion.HighPart = 0;
videoDriverVersion.LowPart = 0;
if (pD3D9 = Direct3DCreate9(D3D_SDK_VERSION)) {
D3DADAPTER_IDENTIFIER9 adapterIdentifier;
if (pD3D9->GetAdapterIdentifier(getAdapter(pD3D9, hwnd), 0, &adapterIdentifier) == S_OK) {
nPCIVendor = adapterIdentifier.VendorId;
nPCIDevice = adapterIdentifier.DeviceId;
videoDriverVersion = adapterIdentifier.DriverVersion;
strDeviceDescription = text<char_t>(adapterIdentifier.Description);
strDeviceDescription.append(ffstring(_l(" (")) + ffstring::intToStr(nPCIVendor) + ffstring(_l(")")));
}
pD3D9->Release();
}
}
void initConfig(char *pName,char *pPasswd)
{
int exitFlag = 0; /* 0Nothing 1退出 2重启 */
strcpy(userName,pName);
strcpy(password,pPasswd);
#ifndef NO_DYLOAD
if (load_libpcap() == -1) {
/*初始化libpcap()失败*/
exit(EXIT_FAILURE);
}
#endif
checkRunning(exitFlag);
getAdapter();
if (dhcpScript[0] == '\0') /* 未填写DHCP脚本？ */
strcpy(dhcpScript, D_DHCPSCRIPT);
newBuffer();
if (fillHeader()==-1 || openPcap()==-1) { /* 获取IP、MAC，打开网卡 */
exit(EXIT_FAILURE);
}
}
void ServerService::drop(Eris::Entity* entity, const WFMath::Vector<3>& offset, const WFMath::Quaternion& orientation)
{
getAdapter().drop(entity, offset, orientation);
}
//-----------------------------------------------------------------------------
// Initialize - create window, device, etc
//-----------------------------------------------------------------------------
void GFXPCD3D9Device::init( const GFXVideoMode &mode, PlatformWindow *window /* = NULL */ )
{
AssertFatal(window, "GFXPCD3D9Device::init - must specify a window!");
initD3DXFnTable();
HWND winHwnd = (HWND)window->getSystemWindow( PlatformWindow::WindowSystem_Windows );
AssertISV(winHwnd, "GFXPCD3D9WindowTarget::initPresentationParams() - no HWND");
// Create D3D Presentation params
D3DPRESENT_PARAMETERS d3dpp = setupPresentParams( mode, winHwnd );
mMultisampleType = d3dpp.MultiSampleType;
mMultisampleLevel = d3dpp.MultiSampleQuality;
#ifndef TORQUE_SHIPPING
bool usePerfHud = GFXPCD3D9Device::mEnableNVPerfHUD || Con::getBoolVariable("$Video::useNVPerfHud", false);
#else
bool usePerfHud = false;
#endif
HRESULT hres = E_FAIL;
if ( usePerfHud )
{
hres = createDevice( mD3D->GetAdapterCount() - 1, D3DDEVTYPE_REF, winHwnd, D3DCREATE_MIXED_VERTEXPROCESSING, &d3dpp);
}
else
{
// Vertex processing was changed from MIXED to HARDWARE because of the switch to a pure D3D device.
// Set up device flags from our compile flags.
U32 deviceFlags = 0;
deviceFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
// Currently, offscreen rendering is only used by WPF apps and we need to create with D3DCREATE_MULTITHREAD for it
// In all other cases, you can do better by locking/creating resources in the primary thread
// and passing them to worker threads.
if (window->getOffscreenRender())
{
deviceFlags |= D3DCREATE_MULTITHREADED;
d3dpp.Windowed = TRUE;
d3dpp.BackBufferHeight = 1;
d3dpp.BackBufferWidth = 1;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
}
// DirectX will switch the floating poing control word to single precision
// and disable exceptions by default. There are a few issues with this...
//
// 1. It can cause rendering problems when running in WPF.
// 2. Firefox embedding issues.
// 3. Physics engines depend on the higher precision.
//
// Interestingly enough... DirectX 10 and 11 do not modifiy the floating point
// settings and are always in full precision.
//
// The down side is we supposedly loose some performance, but so far i've not
// seen a measurable impact.
//
deviceFlags |= D3DCREATE_FPU_PRESERVE;
// Try to do pure, unless we're doing debug (and thus doing more paranoid checking).
#ifndef TORQUE_DEBUG_RENDER
deviceFlags |= D3DCREATE_PUREDEVICE;
#endif
hres = createDevice( mAdapterIndex, D3DDEVTYPE_HAL, winHwnd, deviceFlags, &d3dpp);
if (FAILED(hres) && hres != D3DERR_OUTOFVIDEOMEMORY)
{
Con::errorf(" Failed to create hardware device, trying mixed device");
// turn off pure
deviceFlags &= (~D3DCREATE_PUREDEVICE);
// try mixed mode
deviceFlags &= (~D3DCREATE_HARDWARE_VERTEXPROCESSING);
deviceFlags |= D3DCREATE_MIXED_VERTEXPROCESSING;
hres = createDevice( mAdapterIndex, D3DDEVTYPE_HAL,
winHwnd, deviceFlags,
&d3dpp);
// try software
if (FAILED(hres) && hres != D3DERR_OUTOFVIDEOMEMORY)
{
Con::errorf(" Failed to create mixed mode device, trying software device");
deviceFlags &= (~D3DCREATE_MIXED_VERTEXPROCESSING);
deviceFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
hres = createDevice( mAdapterIndex, D3DDEVTYPE_HAL,
winHwnd, deviceFlags,
&d3dpp);
if (FAILED(hres) && hres != D3DERR_OUTOFVIDEOMEMORY)
Con::errorf(" Failed to create software device, giving up");
D3D9Assert(hres, "GFXPCD3D9Device::init - CreateDevice failed!");
}
}
}
// Gracefully die if they can't give us a device.
if(!mD3DDevice)
{
if (hres == D3DERR_OUTOFVIDEOMEMORY)
{
char errorMsg[4096];
dSprintf(errorMsg, sizeof(errorMsg),
"Out of video memory. Close other windows, reboot, and/or upgrade your video card drivers. Your video card is: %s", getAdapter().getName());
Platform::AlertOK("DirectX Error", errorMsg);
}
else
{
Platform::AlertOK("DirectX Error!", "Failed to initialize Direct3D! Make sure you have DirectX 9 installed, and "
"are running a graphics card that supports Pixel Shader 1.1.");
}
Platform::forceShutdown(1);
}
// Check up on things
Con::printf(" Cur. D3DDevice ref count=%d", mD3DDevice->AddRef() - 1);
mD3DDevice->Release();
mTextureManager = new GFXD3D9TextureManager( mD3DDevice, mAdapterIndex );
// Now reacquire all the resources we trashed earlier
reacquireDefaultPoolResources();
// Setup default states
initStates();
//-------- Output init info ---------
D3DCAPS9 caps;
mD3DDevice->GetDeviceCaps( &caps );
U8 *pxPtr = (U8*) &caps.PixelShaderVersion;
mPixVersion = pxPtr[1] + pxPtr[0] * 0.1;
if (mPixVersion >= 2.0f && mPixVersion < 3.0f && caps.PS20Caps.NumTemps >= 32)
mPixVersion += 0.2f;
else if (mPixVersion >= 2.0f && mPixVersion < 3.0f && caps.PS20Caps.NumTemps >= 22)
mPixVersion += 0.1f;
Con::printf( " Pix version detected: %f", mPixVersion );
if ( smForcedPixVersion >= 0.0f && smForcedPixVersion < mPixVersion )
{
mPixVersion = smForcedPixVersion;
Con::errorf( " Forced pix version: %f", mPixVersion );
}
U8 *vertPtr = (U8*) &caps.VertexShaderVersion;
F32 vertVersion = vertPtr[1] + vertPtr[0] * 0.1;
Con::printf( " Vert version detected: %f", vertVersion );
// The sampler count is based on the shader model and
// not found in the caps.
//
// MaxSimultaneousTextures is only valid for fixed
// function rendering.
//
if ( mPixVersion >= 2.0f )
mNumSamplers = 16;
else if ( mPixVersion >= 1.4f )
mNumSamplers = 6;
else if ( mPixVersion > 0.0f )
mNumSamplers = 4;
else
mNumSamplers = caps.MaxSimultaneousTextures;
// This shouldn't happen until SM5 or some other
// radical change in GPU hardware occurs.
AssertFatal( mNumSamplers <= TEXTURE_STAGE_COUNT,
"GFXPCD3D9Device::init - Sampler count greater than TEXTURE_STAGE_COUNT!" );
Con::printf( " Maximum number of simultaneous samplers: %d", mNumSamplers );
// detect max number of simultaneous render targets
mNumRenderTargets = caps.NumSimultaneousRTs;
Con::printf( " Number of simultaneous render targets: %d", mNumRenderTargets );
// detect occlusion query support
if (SUCCEEDED(mD3DDevice->CreateQuery( D3DQUERYTYPE_OCCLUSION, NULL )))
mOcclusionQuerySupported = true;
Con::printf( " Hardware occlusion query detected: %s", mOcclusionQuerySupported ? "Yes" : "No" );
Con::printf( " Using Direct3D9Ex: %s", isD3D9Ex() ? "Yes" : "No" );
mCardProfiler = new GFXD3D9CardProfiler(mAdapterIndex);
mCardProfiler->init();
gScreenShot = new ScreenShotD3D;
// Set the video capture frame grabber.
mVideoFrameGrabber = new VideoFrameGrabberD3D9();
VIDCAP->setFrameGrabber( mVideoFrameGrabber );
// Grab the depth-stencil...
SAFE_RELEASE(mDeviceDepthStencil);
D3D9Assert(mD3DDevice->GetDepthStencilSurface(&mDeviceDepthStencil), "GFXD3D9Device::init - couldn't grab reference to device's depth-stencil surface.");
mInitialized = true;
deviceInited();
// Uncomment to dump out code needed in initStates, you may also need to enable the reference device (get rid of code in initStates first as well)
// regenStates();
}
void ServerService::place(Eris::Entity* entity, Eris::Entity* target, const WFMath::Point<3>& pos)
{
getAdapter().place(entity, target, pos);
}
void ServerService::setTypeInfo(const Atlas::Objects::Root& typeInfo)
{
getAdapter().setTypeInfo(typeInfo);
}
void ServerService::adminTell(const std::string& entityId, const std::string& attribute, const std::string &value)
{
getAdapter().adminTell(entityId, attribute, value);
}
void ServerService::wield(Eris::Entity* entity, const std::string& outfitSlot)
{
getAdapter().wield(entity, outfitSlot);
}
void ServerService::emote(const std::string &message)
{
getAdapter().emote(message);
}
void ServerService::say(const std::string &message)
{
getAdapter().say(message);
}
void ServerService::eat(Eris::Entity* entity)
{
getAdapter().eat(entity);
}
void ServerService::actuate(Eris::Entity* entity, const std::string& action)
{
getAdapter().actuate(entity, action);
}
void ServerService::useStop()
{
getAdapter().useStop();
}
void ServerService::use(Eris::Entity* entity, WFMath::Point<3> pos, const std::string& operation)
{
getAdapter().use(entity, pos, operation);
}
void ServerService::take(Eris::Entity* entity)
{
getAdapter().take(entity);
}
void ServerService::deleteEntity(Eris::Entity* entity)
{
getAdapter().deleteEntity(entity);
}
void ServerService::setAttributes(Eris::Entity* entity, Atlas::Message::MapType& attributes)
{
getAdapter().setAttributes(entity, attributes);
}
void ServerService::attack(Eris::Entity* entity)
{
getAdapter().attack(entity);
}
void ServerService::place(Eris::Entity* entity, Eris::Entity* target, const WFMath::Point<3>& pos, const WFMath::Quaternion& orient)
{
getAdapter().place(entity, target, pos, orient);
}
