void TailWin::Save(const char *cFileName) // From AEdit
{
static std::string cBuffer;
TextView::buffer_type vLines;
int iLineNo, iLineTotal=0;
vLines=m_TextView->GetBuffer();
iLineTotal=vLines.size();
ofstream foutfile(cFileName);
if(foutfile){
for(iLineNo=0;iLineNo<iLineTotal;iLineNo++){
cBuffer=m_TextView->GetBuffer()[iLineNo];
foutfile << cBuffer << endl;
}
}
else{
//Open an error window
Alert* sFileAlert = new Alert(STR_ERROR_SAVEFILE_TITLE, STR_ERROR_SAVEFILE_TEXT, 0x00, STR_ERROR_SAVEFILE_OKBUTTON.c_str(), NULL);
sFileAlert->Go();
}
foutfile.close();
}
void LoginView::PopulateIcons()
{
try
{
FILE* fp = fopen("/etc/passwd","r");
struct passwd* psPwd;
int nIcon = 0;
while((psPwd = fgetpwent( fp )) != NULL )
{
// Let's remove users that don't need to be there and then add them to the iconview
// System users (eg "www", "mail") have uids between 1 and 99. Filter them out.
if( psPwd->pw_uid >= 100 || psPwd->pw_uid == 0 )
{
pcUserIconView->AddIcon(GetImageFromIcon(psPwd->pw_name),new IconData());
pcUserIconView->AddIconString(nIcon,psPwd->pw_name);
nIcon++;
}
}
pcUserIconView->Layout();
}
catch (...)
{
Alert* pcError = new Alert("Unable to load users","I am unable to load users, please contact the Syllable development group.",0x00,"Oh no!!!",NULL);
pcError->Go(new Invoker());
}
}
QString AlertSubscription::reminderMessage(Alert alert) const {
const AlertSubscriptionData *d = data();
QString rawMessage = d ? d->_reminderMessage : QString();
if (rawMessage.isEmpty())
rawMessage = "alert still raised: "+alert.idWithCount();
AlertPseudoParamsProvider ppp = alert.pseudoParams();
return d->_params.evaluate(rawMessage, &ppp);
}
void IFaceWin::ApplyChanges( void )
{
IFaceType_t nType = m_pcDdmType->GetCurrentString() == MSG_IFWIN_TYPE_STATIC ? Static : DHCP;
bool bDefault = m_pcIFace->IsDefault();
bool bError = false;
switch ( nType )
{
case Static:
{
IPAddress_t nIP, nNM, nGW;
String cError;
if( !ParseIPAddress( m_pcTxtAddress->GetValue().AsString( ), &nIP ) )
{
bError = true;
cError = MSG_IFWIN_ERR_IP_ADDRESS;
}
else if( !ParseIPAddress( m_pcTxtNetmask->GetValue().AsString( ), &nNM ) )
{
bError = true;
cError = MSG_IFWIN_ERR_NETMASK;
}
else if( !ParseIPAddress( m_pcTxtGateway->GetValue().AsString( ), &nGW ) )
{
bError = true;
cError = MSG_IFWIN_ERR_GATEWAY;
}
if( bError )
{
Alert *pcAlert = new Alert( MSG_IFWIN_ERR_TITLE, cError, Alert::ALERT_WARNING, 0, MSG_IFWIN_ERR_CLOSE.c_str(), NULL );
pcAlert->Go( new Invoker( new Message() ) );
}
else
{
m_pcIFace->SetAddress( nIP );
m_pcIFace->SetNetmask( nNM );
m_pcIFace->SetGateway( nGW );
}
break;
}
case DHCP:
break;
}
if( !bError )
{
m_pcIFace->SetType( nType );
m_pcIFace->SetEnabled( m_pcCbEnabled->GetValue().AsBool( ) );
m_pcIFace->SetDefault( bDefault );
Messenger cMsnger( m_pcParent );
cMsnger.SendMessage( new Message( ApplyInterfaceChanges ) );
}
}
QDebug operator<<(QDebug debug, const Alert &alert)
{
if (alert.isValid()) {
debug << "Snore::Alert(" << alert.name() << ")" ;
} else {
debug << "Snore::Alert(0x00)" ;
}
return debug.maybeSpace();
}
Alert* Alert::create(std::string header_msg, std::string sub_header_msg, std::string body_msg)
{
Alert* alert = Alert::create();
alert->set_header_str(header_msg);
alert->set_sub_header_str(sub_header_msg);
alert->set_body_str(body_msg);
return alert;
};
void Address::DisplayAbout()
{
String cTitle = (String)"About " + (String)PLUGIN_NAME + (String)"...";
String cInfo = (String)"Version: " + (String)PLUGIN_VERSION + (String)"\n\nAuthor: " + (String)PLUGIN_AUTHOR + (String)"\n\nDesc: " + (String)PLUGIN_DESC;
Alert* pcAlert = new Alert(cTitle.c_str(),cInfo.c_str(),m_pcIcon->LockBitmap(),0,"_OK",NULL);
m_pcIcon->UnlockBitmap();
pcAlert->Go(new Invoker());
pcAlert->MakeFocus();
}
void MainView::ShowAbout(void)
{
Alert* sAbout = new Alert("sIRC 0.03",
"sIRC 0.01\n\n"
"Syllable Internet Relay Chat Client\n"
"By James Coxon 2006\n"
"*****@*****.**"
,
0x00, "Close", NULL);
sAbout->Go(new Invoker);
}
/*
* Processes the initialization response. Returns 0 in case of success, an
* error code in case of error.
*
* @param msg the response from the server
*/
int SyncMLProcessor::processServerAlert(SyncSource& source, SyncML* syncml) {
int ret = -1;
int iterator = 0;
AbstractCommand* a = NULL;
bool found = false;
ret = 0;
do {
a = getCommand(syncml->getSyncBody(), ALERT, iterator);
if (a == NULL) {
// This happens with the Synthesis server's reply:
// instead of sending SyncBody/Alert we get SyncBody/Put
// with device infos and a SyncBody/Get requesting our own
// device infos. Ignoring the request is not correct, but
// allows synchronization to proceed and complete eventually
// without any further errors. For that to work we must not
// set lastErrorCode here, as it will be checked at the end of
// the sync.
//
// lastErrorCode = ERR_REPRESENTATION;
// sprintf(lastErrorMsg, "SyncBody/Alert not found!");
goto finally;
}
Alert* alert = (Alert*)a;
Item* item = NULL;
ArrayList* itemList = alert->getItems();
for (int i = 0; i < itemList->size(); i++) {
item = (Item*)getArrayElement(itemList, i);
const char *locURI = ((Target*)item->getTarget())->getLocURI();
if (strcmp( locURI, _wcc(source.getName()) ) == 0) {
if ( !alert->getData() ) {
setError(ERR_REPRESENTATION, "SyncBody/Alert/Data not found!");
goto finally;
}
source.setSyncMode((SyncMode)alert->getData());
ret = 0;
found = true;
break;
}
}
iterator++;
if (found)
break;
} while(a);
finally:
return ret;
}
void DockCamera::HandleMessage(Message* pcMessage)
{
switch (pcMessage->GetCode())
{
case M_CAMERA_ABOUT:
{
String cTitle = (String)"About " + (String)PLUGIN_NAME + (String)"...";
String cInfo = (String)"Version: " + (String)PLUGIN_VERSION + (String)"\n\nAuthor: " + (String)PLUGIN_AUTHOR + (String)"\n\nDesc: " + (String)PLUGIN_DESC;
Alert* pcAlert = new Alert(cTitle.c_str(),cInfo.c_str(),m_pcIcon->LockBitmap(),0,"OK",NULL);
pcAlert->Go(new Invoker());
pcAlert->MakeFocus();
break;
}
case M_PREFS:
{
ShowPrefs(m_pcPlugin->GetPath());
break;
}
case M_PREFS_SEND_TO_PARENT:
{
pcMessage->FindFloat("click",&vClick);
pcMessage->FindFloat("key/instant",&vInstant);
pcMessage->FindFloat("key/delay",&vDelay);
pcMessage->FindFloat("delay",&vDelayTime);
SaveSettings();
LoadSettings();
pcPrefsWin->Close();
pcPrefsWin = NULL;
break;
}
case M_PRINT_SCREEN:
{
if (bFirst)
{
bFirst = false;
}
else
{
pcCameraDelayedLooper->AddTimer(pcCameraDelayedLooper,CAMERA_ID,0);
}
break;
}
}
}
// send alert
int sendAlert(SSL& ssl, const Alert& alert)
{
output_buffer out;
buildAlert(ssl, out, alert);
ssl.Send(out.get_buffer(), out.get_size());
return alert.get_length();
}
void run() {
while (!isInterruptionRequested()) {
Alert alert;
if (_buffer.tryGet(&alert, 500)) {
++_gridboardsEvaluationsCounter;
QList<Gridboard> &gridboards = _alerter->_gridboards.lockData();
for (int i = 0; i < gridboards.size(); ++i) {
QRegularExpressionMatch match =
gridboards[i].patternRegexp().match(alert.id());
if (match.hasMatch()) {
++_gridboardsUpdatesCounter;
gridboards[i].update(match, alert);
}
}
_alerter->_gridboards.unlockData();
}
}
}
void Address::ExecuteBrowser(const String& cUrl)
{
int nError=0;
if (fork() == 0)
{
set_thread_priority( -1, 0 );
nError = execlp("/Applications/Webster/Webster","/Applications/Webster/Webster",cUrl.c_str(),NULL);
}
if (nError == -1)
{
if (errno == ENOENT)
{
Alert* pcAlert = new Alert("Address...","Could not find Webster browser.",m_pcIcon->LockBitmap(),0,"_OK",NULL);
m_pcIcon->UnlockBitmap();
pcAlert->CenterInScreen();
pcAlert->Go(new Invoker());
}
else
{
Alert* pcAlert = new Alert("Address...","Error launching Webster browser.",m_pcIcon->LockBitmap(),0,"_OK",NULL);
m_pcIcon->UnlockBitmap();
pcAlert->CenterInScreen();
pcAlert->Go(new Invoker());
}
}
}
void LogAlertChannel::doNotifyAlert(Alert alert) {
switch(alert.status()) {
case Alert::Nonexistent:
case Alert::Raised:
if (!alert.subscription().notifyEmit())
return;
Log::log(alert.subscription().emitMessage(alert),
Log::severityFromString(alert.subscription().address(alert)));
break;
case Alert::Canceled:
if (!alert.subscription().notifyCancel())
return;
Log::log(alert.subscription().cancelMessage(alert),
Log::severityFromString(alert.subscription().address(alert)));
break;
case Alert::Rising:
case Alert::MayRise:
case Alert::Dropping:
; // should never happen
}
}
QString AlertSubscription::address(Alert alert) const {
const AlertSubscriptionData *d = data();
QString rawAddress = d ? d->_address : QString();
AlertPseudoParamsProvider ppp = alert.pseudoParams();
return d->_params.evaluate(rawAddress, &ppp);
}
TEST(AnomalyTrackerTest, TestConsecutiveBuckets) {
const int64_t bucketSizeNs = 30 * NS_PER_SEC;
const int32_t refractoryPeriodSec = 2 * bucketSizeNs / NS_PER_SEC;
Alert alert;
alert.set_num_buckets(3);
alert.set_refractory_period_secs(refractoryPeriodSec);
alert.set_trigger_if_sum_gt(2);
AnomalyTracker anomalyTracker(alert, kConfigKey);
MetricDimensionKey keyA = getMockMetricDimensionKey(1, "a");
MetricDimensionKey keyB = getMockMetricDimensionKey(1, "b");
MetricDimensionKey keyC = getMockMetricDimensionKey(1, "c");
int64_t eventTimestamp0 = 10 * NS_PER_SEC;
int64_t eventTimestamp1 = bucketSizeNs + 11 * NS_PER_SEC;
int64_t eventTimestamp2 = 2 * bucketSizeNs + 12 * NS_PER_SEC;
int64_t eventTimestamp3 = 3 * bucketSizeNs + 13 * NS_PER_SEC;
int64_t eventTimestamp4 = 4 * bucketSizeNs + 14 * NS_PER_SEC;
int64_t eventTimestamp5 = 5 * bucketSizeNs + 5 * NS_PER_SEC;
int64_t eventTimestamp6 = 6 * bucketSizeNs + 16 * NS_PER_SEC;
std::shared_ptr<DimToValMap> bucket0 = MockBucket({{keyA, 1}, {keyB, 2}, {keyC, 1}});
std::shared_ptr<DimToValMap> bucket1 = MockBucket({{keyA, 1}});
std::shared_ptr<DimToValMap> bucket2 = MockBucket({{keyB, 1}});
std::shared_ptr<DimToValMap> bucket3 = MockBucket({{keyA, 2}});
std::shared_ptr<DimToValMap> bucket4 = MockBucket({{keyB, 5}});
std::shared_ptr<DimToValMap> bucket5 = MockBucket({{keyA, 2}});
std::shared_ptr<DimToValMap> bucket6 = MockBucket({{keyA, 2}});
// Start time with no events.
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0u);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, -1LL);
// Event from bucket #0 occurs.
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 0, bucket0, {}, {keyA, keyB, keyC}));
detectAndDeclareAnomalies(anomalyTracker, 0, bucket0, eventTimestamp1);
checkRefractoryTimes(anomalyTracker, eventTimestamp0, refractoryPeriodSec,
{{keyA, -1}, {keyB, -1}, {keyC, -1}});
// Adds past bucket #0
anomalyTracker.addPastBucket(bucket0, 0);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3u);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 1LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 0LL);
// Event from bucket #1 occurs.
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 1, bucket1, {}, {keyA, keyB, keyC}));
detectAndDeclareAnomalies(anomalyTracker, 1, bucket1, eventTimestamp1);
checkRefractoryTimes(anomalyTracker, eventTimestamp1, refractoryPeriodSec,
{{keyA, -1}, {keyB, -1}, {keyC, -1}});
// Adds past bucket #0 again. The sum does not change.
anomalyTracker.addPastBucket(bucket0, 0);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3u);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 1LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 0LL);
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 1, bucket1, {}, {keyA, keyB, keyC}));
detectAndDeclareAnomalies(anomalyTracker, 1, bucket1, eventTimestamp1 + 1);
checkRefractoryTimes(anomalyTracker, eventTimestamp1, refractoryPeriodSec,
{{keyA, -1}, {keyB, -1}, {keyC, -1}});
// Adds past bucket #1.
anomalyTracker.addPastBucket(bucket1, 1);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 1L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
// Event from bucket #2 occurs. New anomaly on keyB.
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 2, bucket2, {keyB}, {keyA, keyC}));
detectAndDeclareAnomalies(anomalyTracker, 2, bucket2, eventTimestamp2);
checkRefractoryTimes(anomalyTracker, eventTimestamp2, refractoryPeriodSec,
{{keyA, -1}, {keyB, eventTimestamp2}, {keyC, -1}});
// Adds past bucket #1 again. Nothing changes.
anomalyTracker.addPastBucket(bucket1, 1);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 1L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
// Event from bucket #2 occurs (again).
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 2, bucket2, {keyB}, {keyA, keyC}));
detectAndDeclareAnomalies(anomalyTracker, 2, bucket2, eventTimestamp2 + 1);
checkRefractoryTimes(anomalyTracker, eventTimestamp2, refractoryPeriodSec,
{{keyA, -1}, {keyB, eventTimestamp2}, {keyC, -1}});
// Adds past bucket #2.
anomalyTracker.addPastBucket(bucket2, 2);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 2L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 1LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL);
// Event from bucket #3 occurs. New anomaly on keyA.
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 3, bucket3, {keyA}, {keyB, keyC}));
detectAndDeclareAnomalies(anomalyTracker, 3, bucket3, eventTimestamp3);
checkRefractoryTimes(anomalyTracker, eventTimestamp3, refractoryPeriodSec,
{{keyA, eventTimestamp3}, {keyB, eventTimestamp2}, {keyC, -1}});
// Adds bucket #3.
anomalyTracker.addPastBucket(bucket3, 3L);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 3L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL);
// Event from bucket #4 occurs. New anomaly on keyB.
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 4, bucket4, {keyB}, {keyA, keyC}));
detectAndDeclareAnomalies(anomalyTracker, 4, bucket4, eventTimestamp4);
checkRefractoryTimes(anomalyTracker, eventTimestamp4, refractoryPeriodSec,
{{keyA, eventTimestamp3}, {keyB, eventTimestamp4}, {keyC, -1}});
// Adds bucket #4.
anomalyTracker.addPastBucket(bucket4, 4);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 4L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 5LL);
// Event from bucket #5 occurs. New anomaly on keyA, which is still in refractory.
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 5, bucket5, {keyA, keyB}, {keyC}));
detectAndDeclareAnomalies(anomalyTracker, 5, bucket5, eventTimestamp5);
checkRefractoryTimes(anomalyTracker, eventTimestamp5, refractoryPeriodSec,
{{keyA, eventTimestamp3}, {keyB, eventTimestamp4}, {keyC, -1}});
// Adds bucket #5.
anomalyTracker.addPastBucket(bucket5, 5);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 5L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 5LL);
// Event from bucket #6 occurs. New anomaly on keyA, which is now out of refractory.
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 6, bucket6, {keyA, keyB}, {keyC}));
detectAndDeclareAnomalies(anomalyTracker, 6, bucket6, eventTimestamp6);
checkRefractoryTimes(anomalyTracker, eventTimestamp6, refractoryPeriodSec,
{{keyA, eventTimestamp6}, {keyB, eventTimestamp4}, {keyC, -1}});
}
TEST(AnomalyTrackerTest, TestSparseBuckets) {
const int64_t bucketSizeNs = 30 * NS_PER_SEC;
const int32_t refractoryPeriodSec = 2 * bucketSizeNs / NS_PER_SEC;
Alert alert;
alert.set_num_buckets(3);
alert.set_refractory_period_secs(refractoryPeriodSec);
alert.set_trigger_if_sum_gt(2);
AnomalyTracker anomalyTracker(alert, kConfigKey);
MetricDimensionKey keyA = getMockMetricDimensionKey(1, "a");
MetricDimensionKey keyB = getMockMetricDimensionKey(1, "b");
MetricDimensionKey keyC = getMockMetricDimensionKey(1, "c");
MetricDimensionKey keyD = getMockMetricDimensionKey(1, "d");
MetricDimensionKey keyE = getMockMetricDimensionKey(1, "e");
std::shared_ptr<DimToValMap> bucket9 = MockBucket({{keyA, 1}, {keyB, 2}, {keyC, 1}});
std::shared_ptr<DimToValMap> bucket16 = MockBucket({{keyB, 4}});
std::shared_ptr<DimToValMap> bucket18 = MockBucket({{keyB, 1}, {keyC, 1}});
std::shared_ptr<DimToValMap> bucket20 = MockBucket({{keyB, 3}, {keyC, 1}});
std::shared_ptr<DimToValMap> bucket25 = MockBucket({{keyD, 1}});
std::shared_ptr<DimToValMap> bucket28 = MockBucket({{keyE, 2}});
int64_t eventTimestamp1 = bucketSizeNs * 8 + 1;
int64_t eventTimestamp2 = bucketSizeNs * 15 + 11;
int64_t eventTimestamp3 = bucketSizeNs * 17 + 1;
int64_t eventTimestamp4 = bucketSizeNs * 19 + 2;
int64_t eventTimestamp5 = bucketSizeNs * 24 + 3;
int64_t eventTimestamp6 = bucketSizeNs * 27 + 3;
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, -1LL);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL);
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 9, bucket9, {}, {keyA, keyB, keyC, keyD}));
detectAndDeclareAnomalies(anomalyTracker, 9, bucket9, eventTimestamp1);
checkRefractoryTimes(anomalyTracker, eventTimestamp1, refractoryPeriodSec,
{{keyA, -1}, {keyB, -1}, {keyC, -1}, {keyD, -1}, {keyE, -1}});
// Add past bucket #9
anomalyTracker.addPastBucket(bucket9, 9);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 9L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 3UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyA), 1LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 2LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 16, bucket16, {keyB}, {keyA, keyC, keyD}));
// TODO: after detectAnomaly fix: EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 15L);
detectAndDeclareAnomalies(anomalyTracker, 16, bucket16, eventTimestamp2);
// TODO: after detectAnomaly fix: EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 15L);
checkRefractoryTimes(anomalyTracker, eventTimestamp2, refractoryPeriodSec,
{{keyA, -1}, {keyB, eventTimestamp2}, {keyC, -1}, {keyD, -1}, {keyE, -1}});
// Add past bucket #16
anomalyTracker.addPastBucket(bucket16, 16);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 16L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 4LL);
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 18, bucket18, {keyB}, {keyA, keyC, keyD}));
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 4LL);
// Within refractory period.
detectAndDeclareAnomalies(anomalyTracker, 18, bucket18, eventTimestamp3);
checkRefractoryTimes(anomalyTracker, eventTimestamp3, refractoryPeriodSec,
{{keyA, -1}, {keyB, eventTimestamp2}, {keyC, -1}, {keyD, -1}, {keyE, -1}});
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 4LL);
// Add past bucket #18
anomalyTracker.addPastBucket(bucket18, 18);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 18L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 20, bucket20, {keyB}, {keyA, keyC, keyD}));
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 19L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
detectAndDeclareAnomalies(anomalyTracker, 20, bucket20, eventTimestamp4);
checkRefractoryTimes(anomalyTracker, eventTimestamp4, refractoryPeriodSec,
{{keyA, -1}, {keyB, eventTimestamp4}, {keyC, -1}, {keyD, -1}, {keyE, -1}});
// Add bucket #18 again. Nothing changes.
anomalyTracker.addPastBucket(bucket18, 18);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 19L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 20, bucket20, {keyB}, {keyA, keyC, keyD}));
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 1LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
detectAndDeclareAnomalies(anomalyTracker, 20, bucket20, eventTimestamp4 + 1);
// Within refractory period.
checkRefractoryTimes(anomalyTracker, eventTimestamp4 + 1, refractoryPeriodSec,
{{keyA, -1}, {keyB, eventTimestamp4}, {keyC, -1}, {keyD, -1}, {keyE, -1}});
// Add past bucket #20
anomalyTracker.addPastBucket(bucket20, 20);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 20L);
EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 2UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyB), 3LL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyC), 1LL);
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 25, bucket25, {}, {keyA, keyB, keyC, keyD}));
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 24L);
// TODO: after detectAnomaly fix: EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL);
detectAndDeclareAnomalies(anomalyTracker, 25, bucket25, eventTimestamp5);
checkRefractoryTimes(anomalyTracker, eventTimestamp5, refractoryPeriodSec,
{{keyA, -1}, {keyB, eventTimestamp4}, {keyC, -1}, {keyD, -1}, {keyE, -1}});
// Add past bucket #25
anomalyTracker.addPastBucket(bucket25, 25);
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 25L);
// TODO: after detectAnomaly fix: EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 1UL);
EXPECT_EQ(anomalyTracker.getSumOverPastBuckets(keyD), 1LL);
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 28, bucket28, {},
{keyA, keyB, keyC, keyD, keyE}));
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 27L);
// TODO: after detectAnomaly fix: EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL);
detectAndDeclareAnomalies(anomalyTracker, 28, bucket28, eventTimestamp6);
// TODO: after detectAnomaly fix: EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL);
checkRefractoryTimes(anomalyTracker, eventTimestamp6, refractoryPeriodSec,
{{keyA, -1}, {keyB, -1}, {keyC, -1}, {keyD, -1}, {keyE, -1}});
// Updates current bucket #28.
(*bucket28)[keyE] = 5;
EXPECT_TRUE(detectAnomaliesPass(anomalyTracker, 28, bucket28, {keyE},
{keyA, keyB, keyC, keyD}));
EXPECT_EQ(anomalyTracker.mMostRecentBucketNum, 27L);
// TODO: after detectAnomaly fix: EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL);
detectAndDeclareAnomalies(anomalyTracker, 28, bucket28, eventTimestamp6 + 7);
// TODO: after detectAnomaly fix: EXPECT_EQ(anomalyTracker.mSumOverPastBuckets.size(), 0UL);
checkRefractoryTimes(anomalyTracker, eventTimestamp6, refractoryPeriodSec,
{{keyA, -1}, {keyB, -1}, {keyC, -1}, {keyD, -1}, {keyE, eventTimestamp6 + 7}});
}
void TailWin::HandleMessage(Message *msg)
{
switch(msg->GetCode()) {
case ID_COPY:
m_TextView->SelectAll();
m_TextView->Copy();
m_TextView->ClearSelection();
break;
case ID_CLEAR:
m_TextView->Clear();
break;
case ID_SAVE:
{
FileRequester *fr = new FileRequester(FileRequester::SAVE_REQ,
new Messenger(this));
fr->Show();
fr->MakeFocus();
}
break;
case ID_OPEN:
{
FileRequester *fr = new FileRequester(FileRequester::LOAD_REQ,new Messenger(this));
fr->Show();
fr->MakeFocus();
}
break;
case M_SAVE_REQUESTED:
{
const char *path;
if(msg->FindString("file/path", &path) == 0) {
Save(path);
}
}
break;
case M_LOAD_REQUESTED:
{
os::String path;
if (msg->FindString("file/path",&path) == 0 )
{
RemoveTimer(this,10);
m_TextView->Clear();
m_FileName = new String(path);
AddTimer(this, 10, 1000000, false);
}
break;
}
case ID_ABOUT:
{
char* abouttext = new char[ STR_ABOUT.size() + 64 ];
sprintf( abouttext, STR_ABOUT.c_str(), ATAIL_VERSION );
Alert *About = new Alert(STR_ABOUT_WINTITLE,
abouttext, 0x00, STR_ABOUT_OKBUTTON.c_str(), NULL);
About->Go(new Invoker(new Message(ID_NOP), 0));
}
break;
case ID_QUIT:
Application::GetInstance()->PostMessage(M_QUIT);
break;
case ID_NOP:
// Do nothing, dummy ID for the about requester
break;
default:
Window::HandleMessage(msg);
}
}
void BrowserWindow::HandleMessage( Message * pcMsg )
{
BrowserWebView *pcWebView = GetCurrentWebView();
switch( pcMsg->GetCode() )
{
case ID_URL_CHANGED:
{
bool bFinal = false;
pcMsg->FindBool( "final", &bFinal );
if( bFinal )
{
String cURL = "";
int nSelection = -1;
if( pcMsg->FindInt32( "selection", &nSelection ) == EOK )
cURL = m_pcUrlEdit->GetItem( nSelection );
else
{
cURL = m_pcUrlEdit->GetCurrentString();
m_pcUrlEdit->AppendItem( cURL );
}
OpenURL( cURL );
}
break;
}
case ID_SET_STATUS_BAR_TEXT:
{
String cText;
if( pcMsg->FindString( "text", &cText ) == EOK )
m_pcStatusBar->SetText( "text", cText );
break;
}
case ID_CLEAR_STATUS_BAR_TEXT:
{
m_pcStatusBar->SetText( "text", "" );
break;
}
case ID_CREATE_WINDOW:
{
BrowserWindow *pcWindow;
String cURL;
Rect cFrame;
/* Use the supplied dimensions if they've been provided, otherwise
clone the current Window */
if( pcMsg->FindRect( "frame", &cFrame ) != EOK )
cFrame = GetFrame();
pcWindow = new BrowserWindow( cFrame );
if( pcMsg->FindString( "url", &cURL ) == EOK )
pcWindow->OpenURL( cURL );
pcWindow->Show();
pcWindow->MakeFocus();
/* Tell BrowserApp about the new window */
Application::GetInstance()->PostMessage( ID_WINDOW_OPENED );
if( pcMsg->IsSourceWaiting() )
{
WebCore::Page *pcPage;
View *pcTab;
/* The new window will only have one tab at this stage so it's safe to always get tab #0 */
pcTab = pcWindow->m_pcTabView->GetTabView( 0 );
pcPage = static_cast<BrowserWebView*>( pcTab )->GetWebCoreFrame()->page();
Message cReply( ID_CREATE_WINDOW_REPLY );
cReply.AddPointer( "page", pcPage );
pcMsg->SendReply( &cReply );
}
break;
}
case ID_CREATE_TAB:
{
String cURL;
if( pcMsg->FindString( "url", &cURL ) == EOK )
{
uint nTabIndex;
nTabIndex = CreateTab( cURL );
if( pcMsg->IsSourceWaiting() )
{
WebCore::Page *pcPage;
View *pcTab;
pcTab = m_pcTabView->GetTabView( nTabIndex );
pcPage = static_cast<BrowserWebView*>( pcTab )->GetWebCoreFrame()->page();
Message cReply( ID_CREATE_WINDOW_REPLY );
cReply.AddPointer( "page", pcPage );
pcMsg->SendReply( &cReply );
}
}
break;
}
case ID_BUTTON_BACK:
{
pcWebView->GoBack();
UpdateButtonState( false );
break;
}
case ID_BUTTON_FORWARD:
{
pcWebView->GoForward();
UpdateButtonState( false );
break;
}
case ID_BUTTON_RELOAD:
{
pcWebView->Reload();
break;
}
case ID_BUTTON_STOP:
{
pcWebView->Stop();
UpdateButtonState( false );
break;
}
case ID_BUTTON_HOME:
{
OpenURL( m_pcSettings->GetString( "homepage", "about:blank" ) );
break;
}
case ID_MENU_APP_ABOUT:
{
Alert* pcAbout = new Alert( "About Webster",
"Webster " WEBSTER_VERSION " (Alpha)\nA WebCore based web browser\n\n© Copyright Kristian Van Der Vliet, 2008\nArno Klenke, 2004-2007\nKurt Skauen, 2001\n"
"\nWebster is released under the Gnu Public License (GPL)\n",
Alert::ALERT_INFO, 0x00, "Ok", NULL );
pcAbout->Go( NULL );
break;
}
case ID_MENU_WIN_NEW_TAB:
{
CreateTab( "" );
break;
}
case ID_MENU_WIN_CLOSE_TAB:
{
DestroyTab( m_pcTabView->GetSelection() );
break;
}
case ID_MENU_EDIT_CUT:
{
pcWebView->Cut();
break;
}
case ID_MENU_EDIT_COPY:
{
pcWebView->Copy();
break;
}
case ID_MENU_EDIT_PASTE:
{
pcWebView->Paste();
break;
}
case ID_MENU_EDIT_DELETE:
{
pcWebView->Delete();
break;
}
case ID_MENU_SETTINGS_CONFIGURE:
{
Rect cSettingsFrame = m_pcGuiSettings->GetRect( "settings", m_cSettingsFrame );
SettingsWindow *pcSettingsWindow = new SettingsWindow( cSettingsFrame, "Webster settings", this, m_pcWebSettings, m_pcSettings, m_pcGuiSettings );
pcSettingsWindow->Show();
pcSettingsWindow->MakeFocus();
break;
}
case ID_SETTINGS_SAVE:
{
Settings *pcSettings;
if( pcMsg->FindPointer( "settings", (void**)&pcSettings ) == EOK )
{
delete m_pcSettings;
m_pcSettings = pcSettings;
m_pcSettings->Save();
}
WebSettings *pcWebSettings;
if( pcMsg->FindPointer( "web_settings", (void**)&pcWebSettings ) == EOK )
{
delete m_pcWebSettings;
m_pcWebSettings = pcWebSettings;
}
break;
}
case ID_SETTINGS_APPLY:
{
Settings *pcSettings;
if( pcMsg->FindPointer( "settings", (void**)&pcSettings ) == EOK )
{
delete m_pcSettings;
m_pcSettings = pcSettings;
}
WebSettings *pcWebSettings;
if( pcMsg->FindPointer( "web_settings", (void**)&pcWebSettings ) == EOK )
{
delete m_pcWebSettings;
m_pcWebSettings = pcWebSettings;
}
break;
}
case ID_MENU_BOOKMARKS_ADD:
{
String cShortTitle, cLongTitle, cURL;
pcWebView->GetTitle( cShortTitle, cLongTitle );
cURL = pcWebView->GetCurrentURL();
m_pcBookmarksManager->AddBookmark( cLongTitle, cURL );
break;
}
case ID_MENU_BOOKMARKS_MANAGE:
{
String cPath;
if( pcMsg->FindString( "path", &cPath ) != EOK )
break;
/* XXXKV: This is a really rubbish way to manage bookmarks: we should have
a proper in-application dialog to do it */
/* Open a filebrowser window */
if( fork() == 0 )
{
set_thread_priority( -1, 0 );
execlp( "/system/bin/FileBrowser", "/system/bin/FileBrowser", cPath.c_str(), NULL );
}
break;
}
case ID_BOOKMARK_GO:
{
String cURL;
if( pcMsg->FindString( "url", &cURL ) == EOK )
OpenURL( cURL );
break;
}
case ID_TAB_CHANGED:
{
ChangeTab( m_pcTabView->GetSelection() );
break;
}
case ID_WEBVIEW_SET_TITLE:
{
String cShortTitle, cLongTitle;
uint nTabIndex;
if( pcMsg->FindString( "short", &cShortTitle ) == EOK &&
pcMsg->FindString( "long", &cLongTitle ) == EOK &&
pcMsg->FindInt32( "index", (int32*)&nTabIndex ) == EOK )
{
m_pcTabView->SetTabTitle( nTabIndex, cShortTitle );
/* If this is the currently selected tab, set the Window title to the full page title */
if( nTabIndex == m_pcTabView->GetSelection() )
SetTitle( cLongTitle );
}
break;
}
case ID_WEBVIEW_LOAD_STARTED:
{
String cURL;
uint nTabIndex;
if( pcMsg->FindString( "url", &cURL ) == EOK &&
pcMsg->FindInt32( "index", (int32*)&nTabIndex ) == EOK )
{
if( nTabIndex == m_pcTabView->GetSelection() )
{
m_pcUrlEdit->SetCurrentString( cURL.c_str() );
UpdateButtonState( true );
}
}
break;
}
case ID_WEBVIEW_LOAD_FINISHED:
{
uint nTabIndex;
if( pcMsg->FindInt32( "index", (int32*)&nTabIndex ) == EOK )
if( nTabIndex == m_pcTabView->GetSelection() )
UpdateButtonState( false );
break;
}
default:
{
fprintf( stderr, "Unknown message with code #%d\n", pcMsg->GetCode() );
Window::HandleMessage( pcMsg );
break;
}
}
}
AlertApp::AlertApp(int argc, char* argv[]) : Application( "application/x-vnd.rgc-alert")
{
if(argc <= 1) // no arguments
{
printf("Usage: alert title text alert_icon(Alert::ALERT_INFO is default) button1 [button2] [button3]\n");
exit (EXIT_FAILURE);
}
String title = "Untitled Alert";
String text = "Alert text goes here.";
String bitmap = "Alert icon here(Alert::ALERT_INFO is default)";
String button1 = "Ok";
String button2 = "Ok";
String button3 = "Ok";
int buttons = 1;
for(int32 i = 1; i < argc; i++)
{
switch (i)
{
case 1:
title = argv[i];
break;
case 2:
text = argv[i];
break;
case 3:
bitmap = argv[i];
break;
case 4:
button1 = argv[i];
break;
case 5:
button2 = argv[i];
buttons = 2;
break;
case 6:
button3 = argv[i];
buttons = 3;
break;
}
}
Alert * alert;
switch (buttons)
{
case 1:
{
if (strcmp(bitmap.c_str(),"Alert::ALERT_INFO")==0)
{
alert = new Alert(title.c_str(), text.c_str(),Alert::ALERT_INFO, 0x00, button1.c_str(), NULL);
break;
}
if (strcmp(bitmap.c_str(),"Alert::ALERT_WARNING")==0)
{
alert = new Alert(title.c_str(), text.c_str(),Alert::ALERT_WARNING, 0x00, button1.c_str(), NULL);
break;
}
if (strcmp(bitmap.c_str(),"Alert::ALERT_QUESTION")==0)
{
alert = new Alert(title.c_str(), text.c_str(),Alert::ALERT_QUESTION, 0x00, button1.c_str(), NULL);
break;
}
else
{
alert = new Alert(title.c_str(), text.c_str(),Alert::ALERT_INFO, 0x00, button1.c_str(), NULL);
break;
}
break;
}
case 2:
{
if (strcmp(bitmap.c_str(),"Alert::ALERT_INFO")==0)
{
alert = new Alert(title.c_str(), text.c_str(),Alert::ALERT_INFO, 0x00, button1.c_str(),button2.c_str(), NULL);
break;
}
if (strcmp(bitmap.c_str(),"Alert::ALERT_WARNING")==0)
{
alert = new Alert(title.c_str(), text.c_str(),Alert::ALERT_WARNING, 0x00, button1.c_str(),button2.c_str(), NULL);
break;
}
if (strcmp(bitmap.c_str(),"Alert::ALERT_QUESTION")==0)
{
alert = new Alert(title.c_str(), text.c_str(),Alert::ALERT_QUESTION, 0x00, button1.c_str(),button2.c_str(), NULL);
break;
}
else
{
alert = new Alert(title.c_str(), text.c_str(),Alert::ALERT_INFO, 0x00, button1.c_str(),button2.c_str(), NULL);
break;
}
break;
}
case 3:
{
if (strcmp(bitmap.c_str(),"Alert::ALERT_INFO")==0)
{
alert = new Alert(title.c_str(), text.c_str(),os::Alert::ALERT_INFO, 0x00, button1.c_str(),button2.c_str(),button3.c_str(), NULL);
break;
}
if (strcmp(bitmap.c_str(),"Alert::ALERT_WARNING")==0)
{
alert = new Alert(title.c_str(), text.c_str(),os::Alert::ALERT_WARNING, 0x00, button1.c_str(),button2.c_str(),button3.c_str(), NULL);
break;
}
if (strcmp(bitmap.c_str(),"Alert::ALERT_QUESTION")==0)
{
alert = new Alert(title.c_str(), text.c_str(),Alert::ALERT_QUESTION, 0x00, button1.c_str(),button2.c_str(),button3.c_str(), NULL);
break;
}
else
{
alert = new Alert(title.c_str(), text.c_str(),os::Alert::ALERT_INFO, 0x00, button1.c_str(),button2.c_str(),button3.c_str(), NULL);
break;
}
break;
}
default:
exit (EXIT_FAILURE);
break;
}
int reply = -1;
reply = alert->Go();
switch (reply)
{
case 0:
printf("%s\n", button1.c_str());
break;
case 1:
printf("%s\n", button2.c_str());
break;
case 2:
printf("%s\n", button3.c_str());
break;
default:
exit (EXIT_FAILURE);
break;
}
PostMessage(M_QUIT);
}
Alert* Alert::create()
{
//usual cocos create, note that I'm skipping handling errors. should fix that
Alert* alert = new (std::nothrow) Alert();
if (alert && alert->init())
{
alert->autorelease();
}
Size visibleSize = Director::getInstance()->getVisibleSize();
Size node_size = visibleSize*0.80f;
alert->setContentSize(node_size);
alert->setLayoutType(ui::Layout::Type::RELATIVE);
//alert->setBackGroundColor(Color3B::BLACK);
//alert->setBackGroundColorOpacity(255/1.5);
//alert->setBackGroundColorType(ui::LayoutBackGroundColorType::SOLID);
alert->setBackGroundImage("main_UI_export_10_x4.png", TextureResType::PLIST);
alert->setBackGroundImageScale9Enabled(true);
alert->setBackGroundImageColor(Color3B(114, 160, 72));
//alert->setBackGroundImageOpacity(200.0f);
//layout->setClippingEnabled(true);
auto create_txt = [&](std::string msg, ui::RelativeLayoutParameter* param) {
auto txt = ui::Text::create(msg, DEFAULT_FONT, sx(25.0f));
Label* lbl = (Label*)txt->getVirtualRenderer();
lbl->getFontAtlas()->setAliasTexParameters();
txt->setTextColor(Color4B::BLACK);
//txt->enableOutline(Color4B::BLACK, 2);
txt->ignoreContentAdaptWithSize(false); //word wrap or something
alert->addChild(txt);
txt->setLayoutParameter(param);
return txt;
};
auto header_param = ui::RelativeLayoutParameter::create();
header_param->setRelativeName("header_param");
header_param->setAlign(ui::RelativeAlign::PARENT_TOP_CENTER_HORIZONTAL);
header_param->setMargin(ui::Margin(sx(10), sy(30), sx(10), sy(10)));
alert->header_txt = create_txt("Title Here", header_param);
auto sub_header_param = ui::RelativeLayoutParameter::create();
sub_header_param->setRelativeName("sub_header_param");
sub_header_param->setAlign(ui::RelativeAlign::LOCATION_BELOW_CENTER);
sub_header_param->setMargin(ui::Margin(sx(10), sy(10), sx(10), sy(10)));
alert->sub_header_txt = create_txt("Sub header", sub_header_param);
sub_header_param->setRelativeToWidgetName("header_param");
auto body_param = ui::RelativeLayoutParameter::create();
body_param->setAlign(ui::RelativeAlign::PARENT_LEFT_CENTER_VERTICAL);
body_param->setMargin(ui::Margin(sx(30), sy(10), sx(10), sy(10)));
alert->body_txt = create_txt("Body content", body_param);
Size body_size = alert->body_txt->getAutoRenderSize();
alert->body_txt->setTextAreaSize(Size(
body_size.width,
body_size.height
));
auto close_btn = ui::Button::create();
close_btn->addTouchEventListener([alert](Ref*, TouchEventType type)
{
if (type == TouchEventType::ENDED)
{
Size visibleSize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
Vec2 pos = Vec2(
origin.x + visibleSize.width - 20,
origin.y + 20
);
alert->shrink_close(pos);
};
});
close_btn->setTitleText("X");
close_btn->setTitleColor(Color3B::RED);
close_btn->setTitleFontSize(sx(40.0f));
close_btn->getTitleRenderer()->enableOutline(Color4B::GRAY, 10);
close_btn->setScaleX(sx(1.0f));
close_btn->setScaleY(sy(1.0f));
alert->close_btn = close_btn;
ui::RelativeLayoutParameter* close_param = ui::RelativeLayoutParameter::create();
close_param->setAlign(ui::RelativeLayoutParameter::RelativeAlign::PARENT_TOP_RIGHT);
close_param->setMargin(ui::Margin(sx(30), sy(20), sx(30), sy(30)));
alert->close_btn->setLayoutParameter(close_param);
alert->addChild(alert->close_btn);
auto done_btn = ui::Button::create();
done_btn->addTouchEventListener([alert](Ref*, TouchEventType type)
{
if (type == TouchEventType::ENDED)
{
Size visibleSize = Director::getInstance()->getVisibleSize();
Vec2 origin = Director::getInstance()->getVisibleOrigin();
Vec2 pos = Vec2(
origin.x + visibleSize.width - 20,
origin.y + 20
);
alert->shrink_close(pos);
};
});
done_btn->setScale9Enabled(true);
done_btn->loadTextureNormal("main_UI_export_10_scale9_x4.png", ui::TextureResType::PLIST);
done_btn->setTitleText("Done");
done_btn->setTitleFontSize(40.0f);
done_btn->setTitleFontName(DEFAULT_FONT);
auto lbl_size = done_btn->getTitleRenderer()->getContentSize();
done_btn->setContentSize(
Size(
lbl_size.width * 1.5f,
lbl_size.height * 1.5f
)
);
done_btn->ignoreContentAdaptWithSize(false); //word wrap or something
done_btn->setTitleColor(Color3B::BLACK);
done_btn->setScaleX(sx(1.0f));
done_btn->setScaleY(sy(1.0f));
alert->done_btn = done_btn;
ui::RelativeLayoutParameter* done_param = ui::RelativeLayoutParameter::create();
done_param->setAlign(ui::RelativeLayoutParameter::RelativeAlign::PARENT_BOTTOM_CENTER_HORIZONTAL);
done_param->setMargin(ui::Margin(sx(30), sy(20), sx(30), sy(30)));
done_param->setRelativeName("done_btn");
alert->done_btn->setLayoutParameter(done_param);
alert->addChild(alert->done_btn);
auto listener = EventListenerTouchOneByOne::create();
listener->setSwallowTouches(true);
listener->onTouchBegan = CC_CALLBACK_2(Alert::onTouchBegan, alert);
listener->onTouchEnded = CC_CALLBACK_2(Alert::onTouchEnded, alert);
Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, alert);
return alert;
};
