bool GraphicsServerCommunication::GetCurrentFrameInfo(gtASCIIString& frameInfoAsXML, unsigned char*& pImageBuffer, unsigned long& imageSize)
{
bool retVal = true;
OS_DEBUG_LOG_TRACER_WITH_RETVAL(retVal);
gtASCIIString httpRtnString;
gtASCIIString commandPrefix = m_strApiHttpCommand;
retVal = SendCommandPid(commandPrefix.append("/PushLayer=FrameDebugger"), httpRtnString, "");
GT_ASSERT(retVal);
if (retVal)
{
commandPrefix = m_strApiHttpCommand;
// Send a request to get the current frame info
retVal = SendCommandPid(commandPrefix.append("/FD/GetCurrentFrameInfo.xml"), frameInfoAsXML, "");
GT_ASSERT(retVal);
if (retVal)
{
commandPrefix = m_strApiHttpCommand;
// Send a request to get the current frame thumbnail
retVal = SendCommandWithBinaryData(commandPrefix.append("/FD/GetFrameBufferImage.png?width=512?height=512"), pImageBuffer, imageSize);
if (retVal)
{
PopLayer();
}
}
}
return retVal;
}
void UILayerManager::PopAllLayers()
{
while(m_kLayerStack.Size())
{
PopLayer();
}
}
void CSDLStateHandler::Think( const int& iElapsedTime )
{
while ( iDelayedPop > 0 && m_vpLayers.size() > 0 )
{
PopLayer();
--iDelayedPop;
}
iDelayedPop = 0;
while ( m_vpPopLayers.size() > 0 ) {
for ( unsigned int i = 0; i < m_vpLayers.size(); ++i ) {
if ( m_vpLayers[i] == m_vpPopLayers.back() ) {
m_vpLayers.erase( m_vpLayers.begin() + i ); // erase the i'th element
m_vpPopLayers.pop_back();
break;
}
}
}
if ( bNewLayerNextFrame ) {
CSDLObjectQueueList* pNewLayer = m_vpLayers.back();
m_vpLayers.pop_back();
NewLayer( pNewLayer );
bNewLayerNextFrame = false;
}
Validate();
if ( m_vpLayers.size() > 0 ) {
m_vpLayers.back()->Think( iElapsedTime );
}
}
// ---------------------------------------------------------------------------
// Name: GraphicsServerCommunication::GetObjectDatabase
// Description: Retrieve captured object database from Graphics server
// Arguments: strFullObjDBase(return) - Object database from current 3D application
// Return Val: bool - Success / failure
// ---------------------------------------------------------------------------
bool GraphicsServerCommunication::GetObjectDatabase(gtASCIIString& strFullObjDBase)
{
bool retVal = false;
OS_DEBUG_LOG_TRACER_WITH_RETVAL(retVal);
gtASCIIString httpRtnString;
// Get database
gtASCIIString objDBPushlayer = m_strApiHttpCommand;
retVal = SendCommandPid(objDBPushlayer.append("/PushLayer=ObjectDatabase"), httpRtnString, "");
if (true == retVal)
{
gtASCIIString dbObjDBPushlayer = m_strApiHttpCommand;
retVal = SendCommandPid(dbObjDBPushlayer.append("/DB/ObjectDatabase.xml"), httpRtnString, "");
if (true == retVal)
{
// assign object string
strFullObjDBase = httpRtnString;
PopLayer();
}
}
return retVal;
}
void CSDLStateHandler::Validate()
{
// Remove all layers that have been destroyed (NULL pointers)
while ( m_vpLayers.size() > 0 && m_vpLayers.back() == 0 ) {
PopLayer();
}
}
void SnippingWindow::OnRender()
{
if (screenshot != nullptr)
{
auto fullRect = D2D1::RectF(0.f, 0.f,
PixelsToDipsX<float>(resolutionX),
PixelsToDipsY<float>(resolutionY));
auto rt = GetRenderTarget();
rt->DrawBitmap(screenshot, fullRect);
rt->PushLayer(D2D1::LayerParameters(),
topLayer);
rt->FillRectangle(fullRect, whiteBrush);
rt->PopLayer();
rt->PushLayer(D2D1::LayerParameters(toolbarCtrl->manager->RectangleToShot), shownLayer);
rt->DrawBitmap(screenshot, fullRect);
rt->PopLayer();
}
}
// ---------------------------------------------------------------------------
// Name: GraphicsServerCommunication::GetLinkedTrace
// Description: Retrieve captured Linked Trace from Graphics server
// Arguments: strLinkedTrace(return) - collection of linked trace from current 3D application
// Return Val: bool - Success / failure
// ---------------------------------------------------------------------------
bool GraphicsServerCommunication::GetLinkedTrace(gtASCIIString& strLinkedTrace)
{
bool retVal = false;
gtASCIIString httpRtnString;
retVal = PushLogger(httpRtnString);
if (true == retVal)
{
// linked trace, always
gtASCIIString linkedTrace = m_strApiHttpCommand;
retVal = SendCommandPid(linkedTrace.append("/LOG/LinkedTrace.txt"), strLinkedTrace, "");
if (retVal)
{
PopLayer();
}
}
return retVal;
}
// CodeXL's capture frame function
// ---------------------------------------------------------------------------
// Name: GraphicsServerCommunication::CaptureFrame
// Description: Capture all available frame information to disk, trace and objects
// Arguments: frameInfoAsXML(return) - path that contains captured metadata file
// Return Val: bool - Success / failure
// ---------------------------------------------------------------------------
bool GraphicsServerCommunication::CaptureFrame(gtASCIIString& frameInfoAsXML)
{
bool retVal = false;
OS_DEBUG_LOG_TRACER_WITH_RETVAL(retVal);
gtASCIIString httpRtnString;
retVal = PushLogger(httpRtnString);
if (retVal == true)
{
// Capture the frame, =3 is includes the save XML frame data, need object database active to include the object database.
gtASCIIString commandPrefix = m_strApiHttpCommand;
retVal = SendCommandPid(commandPrefix.append("/FrameCaptureWithSave.txt=3"), frameInfoAsXML, "");
if (retVal)
{
// Pop the logger layer
PopLayer();
}
}
return retVal;
}
bool GraphicsServerCommunication::GetCounters(gtASCIIString& returnedPage)
{
bool retVal = false;
OS_DEBUG_LOG_TRACER_WITH_RETVAL(retVal);
gtASCIIString httpRtnString;
gtASCIIString commandPrefix = m_strApiHttpCommand;
retVal = SendCommandPid(commandPrefix.append("/PushLayer=FrameProfiler"), httpRtnString, "");
if (retVal)
{
commandPrefix = m_strApiHttpCommand;
retVal = SendCommandPid(commandPrefix.append("/FP/CounterInfo.xml"), httpRtnString, "");
if (retVal)
{
returnedPage = httpRtnString;
PopLayer();
}
}
return retVal;
}
bool GraphicsServerCommunication::SetCounters(const gtVector<int>& selectedCounters, gtASCIIString& returnedPage)
{
bool retVal = false;
gtASCIIString httpRtnString;
gtASCIIString commandPrefix = m_strApiHttpCommand;
retVal = SendCommandPid(commandPrefix.append("/PushLayer=FrameProfiler"), httpRtnString, "");
if (retVal)
{
commandPrefix = m_strApiHttpCommand;
gtASCIIString sendCommand(commandPrefix.append("/FP/CounterSelect.txt="));
int numCounters = (int)selectedCounters.size();
for (int nCounter = 0; nCounter < numCounters; nCounter++)
{
sendCommand.appendFormattedString("%d", selectedCounters[nCounter]);
if (nCounter != numCounters - 1)
{
sendCommand.append(",");
}
}
retVal = SendCommandPid(sendCommand.asCharArray(), httpRtnString, "");
if (retVal)
{
returnedPage = httpRtnString;
PopLayer();
}
}
return retVal;
}
// ---------------------------------------------------------------------------
// Name: GraphicsServerCommunication::GetObjectTree
// Description: Retrieve captured Objects from Graphics server
// Arguments: strObjects(return) - collection of Objects from current 3D application
// Return Val: bool - Success / failure
// ---------------------------------------------------------------------------
bool GraphicsServerCommunication::GetObjectTree(gtASCIIString& strObjectTree)
{
bool retVal = false;
OS_DEBUG_LOG_TRACER_WITH_RETVAL(retVal);
gtASCIIString httpRtnString;
// Object tree
gtASCIIString command = m_strApiHttpCommand;
retVal = SendCommandPid(command.append("/PushLayer=ObjectDatabase"), httpRtnString, "");
if (true == retVal)
{
command = m_strApiHttpCommand;
retVal = SendCommandPid(command.append("/DB/ObjectTree.xml"), httpRtnString, "");
if (true == retVal)
{
strObjectTree = httpRtnString;
PopLayer();
}
}
return retVal;
}
int main(int argc, char **argv)
{
PRStatus rv;
PLOptStatus os;
PRFileDesc *client, *service;
PRNetAddr any_address;
const char *server_name = NULL;
const PRIOMethods *stubMethods;
PRThread *client_thread, *server_thread;
PRThreadScope thread_scope = PR_LOCAL_THREAD;
PRSocketOptionData socket_noblock, socket_nodelay;
PLOptState *opt = PL_CreateOptState(argc, argv, "dqGC:c:p:");
while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
{
if (PL_OPT_BAD == os) continue;
switch (opt->option)
{
case 0:
server_name = opt->value;
break;
case 'd': /* debug mode */
if (verbosity < noisy)
verbosity = ChangeVerbosity(verbosity, 1);
break;
case 'q': /* debug mode */
if (verbosity > silent)
verbosity = ChangeVerbosity(verbosity, -1);
break;
case 'G': /* use global threads */
thread_scope = PR_GLOBAL_THREAD;
break;
case 'C': /* number of threads waiting */
major_iterations = atoi(opt->value);
break;
case 'c': /* number of client threads */
minor_iterations = atoi(opt->value);
break;
case 'p': /* default port */
default_port = atoi(opt->value);
break;
default:
break;
}
}
PL_DestroyOptState(opt);
PR_STDIO_INIT();
logFile = PR_GetSpecialFD(PR_StandardError);
identity = PR_GetUniqueIdentity("Dummy");
stubMethods = PR_GetDefaultIOMethods();
/*
** The protocol we're going to implement is one where in order to initiate
** a send, the sender must first solicit permission. Therefore, every
** send is really a send - receive - send sequence.
*/
myMethods = *stubMethods; /* first get the entire batch */
myMethods.accept = MyAccept; /* then override the ones we care about */
myMethods.recv = MyRecv; /* then override the ones we care about */
myMethods.send = MySend; /* then override the ones we care about */
myMethods.close = MyClose; /* then override the ones we care about */
myMethods.poll = MyPoll; /* then override the ones we care about */
if (NULL == server_name)
rv = PR_InitializeNetAddr(
PR_IpAddrLoopback, default_port, &server_address);
else
{
rv = PR_StringToNetAddr(server_name, &server_address);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_InitializeNetAddr(
PR_IpAddrNull, default_port, &server_address);
}
PR_ASSERT(PR_SUCCESS == rv);
socket_noblock.value.non_blocking = PR_TRUE;
socket_noblock.option = PR_SockOpt_Nonblocking;
socket_nodelay.value.no_delay = PR_TRUE;
socket_nodelay.option = PR_SockOpt_NoDelay;
/* one type w/o layering */
while (major_iterations-- > 0)
{
if (verbosity > silent)
PR_fprintf(logFile, "Beginning non-layered test\n");
client = PR_NewTCPSocket(); PR_ASSERT(NULL != client);
service = PR_NewTCPSocket(); PR_ASSERT(NULL != service);
rv = PR_SetSocketOption(client, &socket_noblock);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_SetSocketOption(service, &socket_noblock);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_SetSocketOption(client, &socket_nodelay);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_SetSocketOption(service, &socket_nodelay);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv);
server_thread = PR_CreateThread(
PR_USER_THREAD, Server, service,
PR_PRIORITY_HIGH, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != server_thread);
client_thread = PR_CreateThread(
PR_USER_THREAD, Client, client,
PR_PRIORITY_NORMAL, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != client_thread);
rv = PR_JoinThread(client_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_JoinThread(server_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(client); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(service); PR_ASSERT(PR_SUCCESS == rv);
if (verbosity > silent)
PR_fprintf(logFile, "Ending non-layered test\n");
/* with layering */
if (verbosity > silent)
PR_fprintf(logFile, "Beginning layered test\n");
client = PR_NewTCPSocket(); PR_ASSERT(NULL != client);
service = PR_NewTCPSocket(); PR_ASSERT(NULL != service);
rv = PR_SetSocketOption(client, &socket_noblock);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_SetSocketOption(service, &socket_noblock);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_SetSocketOption(client, &socket_nodelay);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_SetSocketOption(service, &socket_nodelay);
PR_ASSERT(PR_SUCCESS == rv);
PushLayer(client);
PushLayer(service);
rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv);
server_thread = PR_CreateThread(
PR_USER_THREAD, Server, service,
PR_PRIORITY_HIGH, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != server_thread);
client_thread = PR_CreateThread(
PR_USER_THREAD, Client, client,
PR_PRIORITY_NORMAL, thread_scope,
PR_JOINABLE_THREAD, 16 * 1024);
PR_ASSERT(NULL != client_thread);
rv = PR_JoinThread(client_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_JoinThread(server_thread);
PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(PopLayer(client)); PR_ASSERT(PR_SUCCESS == rv);
rv = PR_Close(PopLayer(service)); PR_ASSERT(PR_SUCCESS == rv);
if (verbosity > silent)
PR_fprintf(logFile, "Ending layered test\n");
}
return 0;
} /* main */
void CSDLStateHandler::ClearLayers()
{
while ( m_vpLayers.size() > 0 ) {
PopLayer();
}
}
