void SendPacketEncoder (Ptr<Socket> socket, Time pktInterval)
{
if (!m_recoder->is_complete() ||
(!m_recoding_flag && !m_decoder->is_complete()))
{
uint32_t bytes_used = m_encoder->encode(&m_payload_buffer[0]);
auto packet = Create<Packet> (&m_payload_buffer[0], bytes_used);
std::cout << "+----------------------------------+" << std::endl;
std::cout << "|Sending a combination from ENCODER|" << std::endl;
std::cout << "+----------------------------------+\n" << std::endl;
socket->Send (packet);
m_encoder_transmission_count++;
if (kodo::has_trace<rlnc_encoder>::value)
{
std::cout << "Trace encoder:" << std::endl;
kodo::trace(m_encoder, std::cout);
}
Simulator::Schedule (pktInterval, &KodoSimulation::SendPacketEncoder,
this, socket, pktInterval);
}
else
{
socket->Close ();
}
}
void GenerateTraffic (Ptr<Socket> socket, Time pktInterval )
{
if (!m_decoder_1->is_complete() || !m_decoder_2->is_complete())
{
std::cout << "Sending a combination" << std::endl;
uint32_t bytes_used = m_encoder->encode(&m_payload_buffer[0]);
auto packet = Create<Packet> (&m_payload_buffer[0], bytes_used);
socket->Send (packet);
m_transmission_count++;
if (kodo::has_trace<rlnc_encoder>::value)
{
std::cout << "Trace encoder:" << std::endl;
kodo::trace(m_encoder, std::cout);
}
Simulator::Schedule (pktInterval, &KodoSimulation::GenerateTraffic,
this, socket, pktInterval);
}
else
{
std::cout << "Decoding completed! Total transmissions: "
<< m_transmission_count << std::endl;
socket->Close ();
}
}
void MyApp::StopApplication (void)
{
m_running = false;
if (m_sendEvent.IsRunning ())
Simulator::Cancel (m_sendEvent);
if (m_socket)
m_socket->Close ();
}
void SendPacketRecoder (Ptr<Socket> socket, Time pktInterval)
{
if (!m_decoder->is_complete())
{
if (m_recoding_flag)
{
// Recode a new packet and send
uint32_t bytes_used = m_recoder->recode(&m_payload_buffer[0]);
auto packet = Create<Packet> (&m_payload_buffer[0], bytes_used);
std::cout << "+----------------------------------+" << std::endl;
std::cout << "|Sending a combination from RECODER|" << std::endl;
std::cout << "+----------------------------------+\n" << std::endl;
socket->Send (packet);
m_recoder_transmission_count++;
}
else
{
if(!m_recoder->rank ())
{
std::cout << "No packet from ENCODER to forward!" << std::endl;
}
else
{
auto packet = m_previous_packet;
// Remove all packet tags in order to the callback retag them to avoid
// ~/ns-3-dev/src/common/packet-tag-list.cc, line=139 assert failure.
// Tag removal is shown in ~/ns-3-dev/src/applications/udp-echo/
// udp-echo-server.cc for packet forwarding
packet->RemoveAllPacketTags ();
socket->Send (packet);
m_recoder_transmission_count++;
std::cout << "Forwarding a previous packet from RECODER...\n"
<< std::endl;
}
}
Simulator::Schedule (pktInterval, &KodoSimulation::SendPacketRecoder,
this, socket, pktInterval);
}
else
{
socket->Close ();
std::cout << "*** Decoding completed! ***" << std::endl;
std::cout << "Encoder transmissions: " << m_encoder_transmission_count
<< std::endl;
std::cout << "Recoder transmissions: " << m_recoder_transmission_count
<< std::endl;
std::cout << "Total transmissions: "
<< m_encoder_transmission_count + m_recoder_transmission_count
<< std::endl;
}
}
static void GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize,
uint32_t pktCount, Time pktInterval )
{
if (pktCount > 0)
{
socket->Send (Create<Packet> (pktSize));
Simulator::Schedule (pktInterval, &GenerateTraffic,
socket, pktSize,pktCount-1, pktInterval);
}
else
{
socket->Close ();
}
}
/// load record
void TemplateLoader::LoadRecord(const IO::URI &uri, TemplateContainer& container){
Ptr<Stream> stream = IO::IoServer::Instance()->CreateStream(uri);
if (stream.isvalid() && stream->Open()){
Ptr<IO::XmlReader> xmlReader = IO::XmlReader::Create();
xmlReader->SetStream(stream);
if (xmlReader->Open()) {
if(xmlReader->SetToFirstChild()) do {
Util::StringAtom nodeName = xmlReader->GetCurrentNodeName();
if (nodeName.IsValid()) {
TemplateRecordPtr ptr = NULL;
Load(xmlReader, nodeName, ptr, container);
if (ptr) {
container.AddRecord(ptr);
}
}
} while (xmlReader->SetToNextChild());
xmlReader->Close();
}
stream->Close();
}
}
c_RestResponse_HttpData* c_RestResponse::PrepareHttpData(c_RestRequest* RestRequest)
{
try
{
char tempHeader[4096];
//string sResponseHeader;
Ptr<MgByteReader> outputReader;
Ptr<c_RestResult> result = GetResult();
STATUS status = result->GetStatusCode();
STRING statusMessage = result->GetHttpStatusMessage();
if (status != 200)
{
if (statusMessage == MapAgentStrings::FailedAuth1 ||
statusMessage == MapAgentStrings::FailedAuth2
)
{
RequestAuth(RestRequest);
}
else
{
//TODO: Use a resource for the HTML error message
char content[4096];
STRING shortError = result->GetErrorMessage();
STRING longError = result->GetDetailedErrorMessage();
sprintf(content,"\r\n"
"<html>\n<head>\n"
"<title>%s</title>\n"
"<meta http-equiv=\"Content-type\" content=\"text/html; charset=utf-8\">\n"
"</head>\n"
"<body>\n<h2>%s</h2>\n%s\n</body>\n</html>\n",
MG_WCHAR_TO_CHAR(statusMessage),
MG_WCHAR_TO_CHAR(shortError),
MG_WCHAR_TO_CHAR(longError));
DWORD content_length = strlen(content);
/*
sprintf(tempHeader, MapAgentStrings::StatusHeader, status, MG_WCHAR_TO_CHAR(statusMessage));
sResponseHeader.append(tempHeader);
sprintf(tempHeader, MapAgentStrings::ContentLengthHeader, (int)content_length);
sResponseHeader.append(tempHeader);
sprintf(tempHeader, MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextHtml, "");
sResponseHeader.append(tempHeader);
*/
m_HttpData.SetStatusAndReason(status,MG_WCHAR_TO_CHAR(statusMessage));
m_HttpData.AddHeader(MapAgentStrings::ContentTypeKey,MapAgentStrings::TextHtml);
sprintf(tempHeader, "%d", (int)content_length);
m_HttpData.AddHeader(MapAgentStrings::ContentLengthKey,tempHeader);
m_HttpData.SetContent(content);
}
}
else
{
// Status was ok. Send the real result back.
STRING result_contentType = result->GetResultContentType();
STRING response_contentType = GetContentType();
std::string stringval_utf8;
//sprintf(tempHeader, MapAgentStrings::StatusOkHeader);
//sResponseHeader.append(tempHeader);
m_HttpData.SetStatusAndReason(200,"OK");
if (response_contentType.length() > 0)
{
// If we are returning text, state that it is utf-8.
STRING mime = response_contentType;
if( response_contentType == RestMimeType::JsonP )
{
mime = L"text/plain";
}
else
{
if( response_contentType == RestMimeType::Json )
{
mime = L"text/plain";
}
}
string charSet = "";
if (mime.find(L"text") != mime.npos) //NOXLATE
{
charSet = MapAgentStrings::Utf8Text;
}
//sprintf(tempHeader, MapAgentStrings::ContentTypeHeader, MG_WCHAR_TO_CHAR(response_contentType), charSet.c_str());
//sResponseHeader.append(tempHeader);
sprintf(tempHeader, "%s%s", MG_WCHAR_TO_CHAR(mime), charSet.c_str());
m_HttpData.AddHeader(MapAgentStrings::ContentTypeKey,tempHeader);
}
else
{
//sprintf(tempHeader, MapAgentStrings::ContentTypeHeader, MapAgentStrings::TextPlain, MapAgentStrings::Utf8Text);
//sResponseHeader.append(tempHeader);
sprintf(tempHeader, "%s%s", MapAgentStrings::TextPlain, MapAgentStrings::Utf8Text);
m_HttpData.AddHeader(MapAgentStrings::ContentTypeKey,tempHeader);
}
Ptr<MgDisposable> resultObj = result->GetResultObject();
MgDisposable* pResultObj = (MgDisposable*)resultObj;
// Test type of response needed
Ptr<c_RestDataReader> restreader = NULL;
MgProxyFeatureReader* proxyfreader = dynamic_cast<MgProxyFeatureReader*>(pResultObj);
if( proxyfreader )
{
restreader = new c_RestDataReader_MgFeatureReader(proxyfreader);
}
else
{
restreader = SAFE_ADDREF(dynamic_cast<c_RestDataReader*>(pResultObj));
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_Template)
{
if( response_contentType == RestMimeType::Html )
{
c_FeatureReaderToHtml::ToHtml(restreader,RestRequest,RestRequest->GetOriginalFullUri(),RestRequest->GetBaseUri(),stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
else
{
if( response_contentType == RestMimeType::Kml )
{
c_FeatureReaderToHtml::ToKml(restreader.p,RestRequest,RestRequest->GetOriginalFullUri(),RestRequest->GetBaseUri(),stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
else
{
if( response_contentType == RestMimeType::Kmz )
{
outputReader = c_FeatureReaderToHtml::ToKmz(restreader.p,RestRequest,RestRequest->GetOriginalFullUri(),RestRequest->GetBaseUri(),result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
else
{
c_FeatureReaderToHtml::ToTemplate(false,restreader,RestRequest,RestRequest->GetOriginalFullUri(),RestRequest->GetBaseUri(),stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
}
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_FeaturesXML)
{
if( restreader.p )
{
c_FeatureReaderToXML::ToXml(restreader.p,stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_Sitemap)
{
if( restreader.p )
{
c_FeatureReaderToXML::ToSitemapXml(restreader.p,RestRequest,RestRequest->GetBaseUri(),stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_FeaturesJSON)
{
if( restreader.p )
{
c_FeatureReaderToGeoJson::ToGeoJson(restreader.p,stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
if( RestRequest->m_CfgRepresentation && RestRequest->m_CfgRepresentation->GetType() == c_CfgRepresentation::e_Custom)
{
if( restreader.p )
{
//std::stringstream strs;
c_CfgRepresentation_Custom *customrep = (c_CfgRepresentation_Custom *)RestRequest->m_CfgRepresentation;
Ptr<c_StreamResponse_FReader2Custom> streamout = new c_StreamResponse_FReader2Custom(restreader.p,customrep);
m_HttpData.SetContent(streamout);
return &m_HttpData; // need to go out here - bellow is closing featuer reader - setting hhtp header for content length etc..
///(*(customrep->m_CustomRenderer->m_FuncContent2Stream))(restreader.p,&strs);
//stringval_utf8 = strs.str();
//c_FeatureReaderToGeoJson::ToGeoJson(restreader.p,stringval_utf8,result->m_FeatureReader_StartIndex,result->m_FeatureReader_Count);
}
}
if( restreader.p )
{
restreader->Close();
}
if (NULL != dynamic_cast<c_RestPrimitiveValue*>(pResultObj))
{
stringval_utf8 = ((c_RestPrimitiveValue*)pResultObj)->ToStringUTF8();;
}
else if (NULL != dynamic_cast<MgByteReader*>(pResultObj))
{
outputReader = (MgByteReader*) SAFE_ADDREF(pResultObj);
}
else if (NULL != dynamic_cast<MgStringCollection*>(pResultObj))
{
outputReader = ((MgStringCollection*)pResultObj)->ToXml();
}
else if (NULL != dynamic_cast<MgSqlDataReader*>(pResultObj))
{
outputReader = ((MgSqlDataReader*)pResultObj)->ToXml();
}
else if (NULL != dynamic_cast<MgDataReader*>(pResultObj))
{
outputReader = ((MgDataReader*)pResultObj)->ToXml();
}
if (stringval_utf8.length() > 0)
{
if( response_contentType == RestMimeType::JsonP ||
( response_contentType == RestMimeType::Json && (GetJsonpCallbackName().length()>0))
)
{
//utf8 = response->GetJsonpCallbackName() + "( \"" + utf8 + "\" )"; ...
std::string jsonp;
CreateJsonpCallbackString(GetJsonpCallbackName(),stringval_utf8,jsonp);
stringval_utf8 = jsonp;
}
sprintf(tempHeader, "%d", stringval_utf8.length());
m_HttpData.AddHeader(MapAgentStrings::ContentLengthKey,tempHeader);
m_HttpData.SetContent(stringval_utf8);
}
else if (outputReader != NULL)
{
if( response_contentType == RestMimeType::Json || response_contentType == RestMimeType::JsonP )
{
MgXmlJsonConvert convert;
convert.ToJson(outputReader);
if( response_contentType == RestMimeType::JsonP )
{
string json;
// set read back to text from Jason so it can be converted to string with function 'ToStringUtf8'
outputReader->GetByteSource()->SetMimeType(RestMimeType::Text);
outputReader->ToStringUtf8(json);
string jsonp;
CreateJsonpCallbackString(GetJsonpCallbackName(),json,jsonp);
Ptr<MgByteSource> byteSource = new MgByteSource(
(unsigned char*)jsonp.c_str(), (INT32)jsonp.length());
byteSource->SetMimeType(RestMimeType::JsonP);
outputReader.Attach(byteSource->GetReader());
}
}
INT64 outLen = outputReader->GetLength();
sprintf(tempHeader, "%d", (INT32)outLen);
m_HttpData.AddHeader(MapAgentStrings::ContentLengthKey,tempHeader);
m_HttpData.SetContent(outputReader);
// Tell IIS to keep the connection open
//DWORD dwState = HSE_STATUS_SUCCESS_AND_KEEP_CONN;
//m_pECB->ServerSupportFunction(m_pECB->ConnID, HSE_REQ_DONE_WITH_SESSION, &dwState, NULL, 0);
}
else
{
sprintf(tempHeader, "%d", 0);
m_HttpData.AddHeader(MapAgentStrings::ContentLengthKey,tempHeader);
// Tell IIS to keep the connection open
//DWORD dwState = HSE_STATUS_SUCCESS_AND_KEEP_CONN;
//m_pECB->ServerSupportFunction(m_pECB->ConnID, HSE_REQ_DONE_WITH_SESSION, &dwState, NULL, 0);
}
}
return &m_HttpData;
}
catch (MgException* exc)
{
SendError(exc);
exc->Release();
}
catch (exception& e)
{
Ptr<MgException> mgException = MgSystemException::Create(e, L"c_RestResponse::PrepareHttpData", __LINE__, __WFILE__);
SendError(mgException);
}
catch (...)
{
Ptr<MgException> mgException = new MgUnclassifiedException(L"c_RestResponse::PrepareHttpData", __LINE__, __WFILE__, NULL, L"", NULL);
SendError(mgException);
}
}//end of c_RestResponse::PrepareHttpData
MgByteReader* c_RestFetchImage::FetchImage(c_RestUri* HttpRequest,c_CfgDataSource_MapGuide* MapGuideSource
, const std::wstring& MapDefId,MgEnvelope* ZoomTo, const std::wstring& ZoomFactor
, const std::wstring& MapSelectionLayer, const std::wstring& FeatureSource, const std::wstring& FdoClassName
, MgFeatureQueryOptions *QueryOptions
)
{
Ptr<c_RestUriRequestParam> query_params = HttpRequest-> GetRequestParam();
//Ptr<c_RestUriPathParam> path_params = HttpRequest-> GetUriPathParameters();
//STRING filter = path_params->GetParameterValue(D_REST_URI_SEGMENT_MAP_IMAGE_PNG);
//Ptr<c_RestRequestParam> filterparams = new c_RestRequestParam();
//RestUriFilterParser::Parse(filter, filterparams);
Ptr<c_RestMgSiteConnection> mgsiteconn = c_RestMgSiteConnection::Open(MapGuideSource->GetUsername(),MapGuideSource->GetPassword(),MapGuideSource->GetServerIP(),MapGuideSource->GetServerPort());
//MgHtmlController controller(mgsiteconn);
// Get the map view commands
//Ptr<c_RestRequestParam> params = m_hRequest->GetRequestParam();
//Ptr<MgPropertyCollection> mapViewCommands = params->GetParameters()->GetPropertyCollection();
//Ptr<MgPropertyCollection> mapViewCommands = filterparams->GetParameters()->GetPropertyCollection();
STRING map_resid;
STRING mapname;
Ptr<MgMap> map;
Ptr<MgSelection> selection;
Ptr<MgPropertyCollection> mapviewcommands = new MgPropertyCollection();
{
STRING sessionid;
Ptr<MgSite> mgSite = mgsiteconn->GetSite();
sessionid = mgSite->CreateSession();
//-------------------------------------------------------
// Create a new Map from MapDefinition in a Session
//-------------------------------------------------------
map = new MgMap();
Ptr<MgResourceIdentifier> resid_mapdef = new MgResourceIdentifier(MapDefId);
mapname = L"KINGREST";
Ptr<MgResourceService> resourceService = dynamic_cast<MgResourceService*>(mgsiteconn->CreateService(MgServiceType::ResourceService));
map->Create(resourceService, resid_mapdef, mapname );
// Save the MgMap state
map_resid = L"Session:" + sessionid + L"//" + mapname + L"." + MgResourceType::Map;
Ptr<MgResourceIdentifier> resid_map = new MgResourceIdentifier(map_resid);
map->Save(resourceService,resid_map);
selection = new MgSelection(map);
if( MapSelectionLayer.length()>0 )
{
MgResourceIdentifier resId(FeatureSource);
Ptr<MgFeatureService> service = (MgFeatureService*)(mgsiteconn->CreateService(MgServiceType::FeatureService));
Ptr<MgFeatureReader> featureReader = service->SelectFeatures(&resId, FdoClassName, QueryOptions);
//Ptr<MgResourceIdentifier> layerresidid = new MgResourceIdentifier(HttpRequest->m_DataLayerConfig->m_MapSelectionLayer);
//Ptr<MgLayer> layerdef = new MgLayer(layerid,resourceService);
Ptr<MgLayerBase> layer;
Ptr<MgLayerCollection> layers = map->GetLayers();
int layerid =layers->IndexOf(MapSelectionLayer);
if( layerid >= 0 )
{
layer = layers->GetItem(layerid);
}
//auto_ptr<MdfModel::LayerDefinition> layerdef( MgLayerBase::GetLayerDefinition(resourceService, layerid));
selection->AddFeatures(layer,featureReader,0);
featureReader->Close();
}
selection->Save(resourceService, mapname);
Ptr<MgReadOnlyLayerCollection> selLayers = selection->GetLayers();
int sel_layercount = selLayers ? selLayers->GetCount() : 0;
MgStringPropertyCollection* coll_params = query_params->GetParameters();
int dwidth=260;
int dheight=260;
int dpi = 96;
STRING strval;
Ptr<MgStringProperty> prop;
if( coll_params->Contains(L"SETDISPLAYWIDTH" ) )
{
STRING val = coll_params->GetValue(L"SETDISPLAYWIDTH");
dwidth = MgUtil::StringToDouble(val);
if( dwidth <= 0 ) dwidth=260;
}
{
MgUtil::Int32ToString(dwidth,strval);
prop = new MgStringProperty(L"SETDISPLAYWIDTH",strval);
mapviewcommands->Add(prop);
}
if( coll_params->Contains(L"SETDISPLAYHEIGHT" ) )
{
STRING val = coll_params->GetValue(L"SETDISPLAYHEIGHT");
dheight = MgUtil::StringToDouble(val);
if( dheight <= 0 ) dheight=260;
}
{
MgUtil::Int32ToString(dheight,strval);
prop = new MgStringProperty(L"SETDISPLAYHEIGHT",strval);
mapviewcommands->Add(prop);
}
if( coll_params->Contains(L"SETDISPLAYDPI" ) )
{
STRING val = coll_params->GetValue(L"SETDISPLAYDPI");
dpi = MgUtil::StringToDouble(val);
if( dpi <= 0 ) dpi=96;
}
{
MgUtil::Int32ToString(dpi,strval);
prop = new MgStringProperty(L"SETDISPLAYDPI",strval);
mapviewcommands->Add(prop);
}
Ptr<MgCoordinate> xy1 = ZoomTo->GetLowerLeftCoordinate();
Ptr<MgCoordinate> xy2 = ZoomTo->GetUpperRightCoordinate();
double cx = ((double)xy1->GetX() + (double)xy2->GetX()) / 2.0;
double cy = ((double)xy1->GetY() + (double)xy2->GetY()) / 2.0;
MgUtil::DoubleToString(cx,strval);
prop = new MgStringProperty(L"SETVIEWCENTERX",strval);
mapviewcommands->Add(prop);
MgUtil::DoubleToString(cy,strval);
prop = new MgStringProperty(L"SETVIEWCENTERY",strval);
mapviewcommands->Add(prop);
double zoomfactor=1.3;
if( coll_params->Contains(L"ZOOMFACTOR" ) )
{
STRING val = coll_params->GetValue(L"ZOOMFACTOR");
zoomfactor = MgUtil::StringToDouble(val);
if( zoomfactor <= 0.0 ) zoomfactor = 1.3;
}
else
{
if( ZoomFactor.length() > 0 )
{
zoomfactor = MgUtil::StringToDouble(ZoomFactor);
if( zoomfactor <= 0.0 ) zoomfactor = 1.3;
}
}
double scale;
double mcsH = xy2->GetY() - xy1->GetY();
double mcsW = xy2->GetX() - xy1->GetX();
mcsH = mcsH * zoomfactor;
mcsW = mcsW * zoomfactor;
double metersperpixel = 0.0254 / dpi;
if (dheight * mcsW > dwidth * mcsH)
scale = mcsW * map->GetMetersPerUnit() / (dwidth * metersperpixel); // width-limited
else
scale = mcsH * map->GetMetersPerUnit() / (dheight * metersperpixel); // height-limited
MgUtil::DoubleToString(scale,strval);
prop = new MgStringProperty(L"SETVIEWSCALE",strval);
mapviewcommands->Add(prop);
}
Ptr<MgByteReader> mapimage = GetDynamicMapOverlayImage_ViewCommands(mgsiteconn,mapname, MgImageFormats::Png, true,mapviewcommands);
//Ptr<MgByteReader> mapimage = controller.GetMapImage(map,selection, MgImageFormats::Png, mapviewcommands,true,true);
// Set the result
//Ptr<c_RestResult> result;
//result = HttpResponse.GetResult();
//result->SetResultObject(mapimage, mapimage->GetMimeType());
return mapimage;
}//end of c_RestFetchImage::FetchImage
bool DoTests() override
{
//only test GetInstance and Update here. Do Thread methods at SubThread.
Ptr<IApplication> app = IApplication::GetInstance();
if(!app) return Fail("IApplication::GetInstance() returned nullptr.");
{
Ptr<IApplication> app2 = IApplication::GetInstance();
if(app != app2) return Fail("IApplication::GetInstance() returned different values.");
}
Ptr<IConfigFile> cfg = IConfigFile::GetInstance(PREFIX"ctest.cfg");
if(!cfg) return Fail("IConfigFile::GetInstance() returned nullptr.");
if(!cfg->IsValid()) return Fail("Config file is invalid.");
Ptr<WECTWindow> win = new WECTWindow(cfg->GetObject("wectWin"), this);
//at this point, all ConfigFile methods have been tested.
if(!win) return Fail("WECTWindow creation failed.");
if(!win->GetExtended()) return Fail("WECTWindow::GetExtended() returned nullptr.");
{
//Rectangle testing not done here; need to test setters, but GetRect returns a const*.
Ptr<const TRectangle<s16,u16>> winrect = win->GetRect();
if(!winrect) return Fail("win->GetRect() returned nullptr.");
}
win->Move(30,30);
win->Resize(640,480);
win->Show(false);
win->Show(true);
//synthesize the many combinations of Mouse
win->Mouse(EMouseButton::Left, EMouseButtonState::Down, 0, 0);
win->Mouse(EMouseButton::Left, EMouseButtonState::Up, 0, 0);
win->Mouse(EMouseButton::Left, EMouseButtonState::DoubleClick, 0, 0);
win->Mouse(EMouseButton::Right, EMouseButtonState::Down, 0, 0);
win->Mouse(EMouseButton::Right, EMouseButtonState::Up, 0, 0);
win->Mouse(EMouseButton::Right, EMouseButtonState::DoubleClick, 0, 0);
win->Mouse(EMouseButton::Middle, EMouseButtonState::Down, 0, 0);
win->Mouse(EMouseButton::Middle, EMouseButtonState::Up, 0, 0);
win->Mouse(EMouseButton::Middle, EMouseButtonState::DoubleClick, 0, 0);
win->Mouse(EMouseButton::X1, EMouseButtonState::Down, 0, 0);
win->Mouse(EMouseButton::X1, EMouseButtonState::Up, 0, 0);
win->Mouse(EMouseButton::X1, EMouseButtonState::DoubleClick, 0, 0);
win->Mouse(EMouseButton::X2, EMouseButtonState::Down, 0, 0);
win->Mouse(EMouseButton::X2, EMouseButtonState::Up, 0, 0);
win->Mouse(EMouseButton::X2, EMouseButtonState::DoubleClick, 0, 0);
win->Mouse(EMouseButton::Null, EMouseButtonState::Null, 30, 30);
win->Key(EKeyMap::A, EKeyState::Down);
win->Key(EKeyMap::A, EKeyState::Up);
win->Scroll(EMouseScrollDirection::Down, 1);
win->Scroll(EMouseScrollDirection::Up, 1);
//For some reason, X11 processes the close message when debugging, but not when just running.
win->Close();
//if no equivalent to SendMessage (Win32) / NSApplication -sendEvent: (Cocoa) on X11,
// event synthesizers will always go to event queue
// using PostMessage (Win32) / NSApplication -postEvent:atStart: (Cocoa) / XSendEvent (X11)
// In that case, GetHandlerState should report 0 before the application loop.
if(win->GetHandlerState() != 0) return Fail("Handlers called before mainloop. (Event queue short-circuit?)");
//should process all events in order, and immediately break.
while(app->Update())
{
//app->Update should return false, and not enter this block.
return Fail("app->Update() did not return false.");
}
if(win->GetHandlerState() != 0x1ffffff) return Fail("Not all handlers called on WECTWindow.");
return Success();
}
