Target Radar::getLockedTarget() {
return Target(m_target, m_object);
}
void
nsMutationReceiver::ContentRemoved(nsIDocument* aDocument,
nsIContent* aContainer,
nsIContent* aChild,
int32_t aIndexInContainer,
nsIContent* aPreviousSibling)
{
if (!IsObservable(aChild)) {
return;
}
nsINode* parent = NODE_FROM(aContainer, aDocument);
if (Subtree() && parent->SubtreeRoot() != RegisterTarget()->SubtreeRoot()) {
return;
}
if (nsAutoMutationBatch::IsBatching()) {
if (nsAutoMutationBatch::IsRemovalDone()) {
// This can happen for example if HTML parser parses to
// context node, but needs to move elements around.
return;
}
if (nsAutoMutationBatch::GetBatchTarget() != parent) {
return;
}
bool wantsChildList = ChildList() && (Subtree() || parent == Target());
if (wantsChildList || Subtree()) {
nsAutoMutationBatch::NodeRemoved(aChild);
nsAutoMutationBatch::UpdateObserver(Observer(), wantsChildList);
}
return;
}
if (Subtree()) {
// Try to avoid creating transient observer if the node
// already has an observer observing the same set of nodes.
nsMutationReceiver* orig = GetParent() ? GetParent() : this;
if (Observer()->GetReceiverFor(aChild, false, false) != orig) {
bool transientExists = false;
nsCOMArray<nsMutationReceiver>* transientReceivers = nullptr;
Observer()->mTransientReceivers.Get(aChild, &transientReceivers);
if (!transientReceivers) {
transientReceivers = new nsCOMArray<nsMutationReceiver>();
Observer()->mTransientReceivers.Put(aChild, transientReceivers);
} else {
for (int32_t i = 0; i < transientReceivers->Count(); ++i) {
nsMutationReceiver* r = transientReceivers->ObjectAt(i);
if (r->GetParent() == orig) {
transientExists = true;
}
}
}
if (!transientExists) {
// Make sure the elements which are removed from the
// subtree are kept in the same observation set.
nsMutationReceiver* tr;
if (orig->Animations()) {
tr = nsAnimationReceiver::Create(aChild, orig);
} else {
tr = nsMutationReceiver::Create(aChild, orig);
}
transientReceivers->AppendObject(tr);
}
}
}
if (ChildList() && (Subtree() || parent == Target())) {
nsDOMMutationRecord* m =
Observer()->CurrentRecord(nsGkAtoms::childList);
if (m->mTarget) {
// Already handled case.
return;
}
m->mTarget = parent;
m->mRemovedNodes = new nsSimpleContentList(parent);
m->mRemovedNodes->AppendElement(aChild);
m->mPreviousSibling = aPreviousSibling;
m->mNextSibling = parent->GetChildAt(aIndexInContainer);
}
// We need to schedule always, so that after microtask mTransientReceivers
// can be cleared correctly.
Observer()->ScheduleForRun();
}
/*
====================
build
====================
*/
VOID Game::build()
{
GUARD(Game::build);
// build the color texture
Image* image = GNEW(Image);
CHECK(image);
image->Width(256);
image->Height(256);
image->Depth(1);
image->PixelFormat(PF_RGBA);
image->DataType(DT_UNSIGNED_BYTE);
mColorTexPtr = GNEW(Texture);
CHECK(mColorTexPtr);
mColorTexPtr->Load(image);
// build the color rt
mColorRTPtr = GNEW(Target(mColorTexPtr.Ptr()));
CHECK(mColorRTPtr);
// build the primitive
mQuadPtr = GNEW(Primitive);
CHECK(mQuadPtr);
mQuadPtr->SetType(Primitive::PT_TRIANGLES);
// set the wvp
Constant* wvp_constant_ptr = GNEW(Constant);
CHECK(wvp_constant_ptr);
wvp_constant_ptr->SetMatrix(Matrix());
mQuadPtr->SetConstant("gWVP",wvp_constant_ptr);
// set the color texture
Constant* texture_constant_ptr = GNEW(Constant);
CHECK(texture_constant_ptr);
texture_constant_ptr->SetTexture(mColorTexPtr.Ptr());
mQuadPtr->SetConstant("gBaseTex",texture_constant_ptr);
// set the shader
Str shader_key_name = "shader/default.xml";
KeyPtr shader_key_ptr = Key::Find(shader_key_name.c_str());
if(shader_key_ptr == NULL)
{
Shader*shader = GNEW(Shader);
CHECK(shader);
shader->Load(GLoad(shader_key_name.c_str()));
shader_key_ptr = GNEW(Key(shader_key_name.c_str(), shader));
CHECK(shader_key_ptr);
}
mKeys.push_back(shader_key_ptr);
mQuadPtr->SetShader(dynamic_cast<Shader*>(shader_key_ptr->Ptr()),"p0");
// build the vertex buffer
F32 x = 0.0f, y = 0.0f, w = 256, h = 256;
DVT vertexes[] =
{
{x, y, 0, 0, 0},
{x+w, y, 0, 1, 0},
{x+w, y+h, 0, 1, 1},
{x, y+h, 0, 0, 1},
};
VertexBufferPtr vb_ptr = GNEW(VertexBuffer);
CHECK(vb_ptr);
{
GDataPtr vd_ptr = GNEW(GData);
CHECK(vd_ptr);
vd_ptr->Size(3*sizeof(U32) + 3*sizeof(U8) + sizeof(vertexes));
U8*data_ptr = (U8*)vd_ptr->Ptr();
*(U32*)data_ptr = MAKEFOURCC('G','V','B','O');
data_ptr += sizeof(U32);
*(U32*)data_ptr = sizeof(vertexes)/sizeof(DVT);
data_ptr += sizeof(U32);
*(U32*)data_ptr = sizeof(DVT);
data_ptr += sizeof(U32);
*(U8*)data_ptr = 2;
data_ptr += sizeof(U8);
*(U8*)data_ptr = VertexBuffer::VT_3F;
data_ptr += sizeof(U8);
*(U8*)data_ptr = VertexBuffer::VT_2F;
data_ptr += sizeof(U8);
::memcpy(data_ptr, vertexes, sizeof(vertexes));
data_ptr += sizeof(vertexes);
vb_ptr->Load(vd_ptr.Ptr());
}
mQuadPtr->SetVertexBuffer(vb_ptr.Ptr());
// build the index
const U16 indexes[] = { 3, 0, 2, 2, 0, 1 };
IndexBufferPtr ib_ptr = GNEW(IndexBuffer);
CHECK(ib_ptr);
{
GDataPtr id_ptr = GNEW(GData);
CHECK(id_ptr);
id_ptr->Size(3*sizeof(U32) + sizeof(indexes));
U8*data_ptr = (U8*)id_ptr->Ptr();
*(U32*)data_ptr = MAKEFOURCC('G','I','B','O');
data_ptr += sizeof(U32);
*(U32*)data_ptr = sizeof(indexes)/sizeof(U16);
data_ptr += sizeof(U32);
*(U32*)data_ptr = sizeof(U16);
data_ptr += sizeof(U32);
::memcpy(data_ptr, &indexes[0], sizeof(indexes));
data_ptr += sizeof(indexes);
ib_ptr->Load(id_ptr.Ptr());
}
mQuadPtr->SetIndexBuffer(ib_ptr.Ptr());
// build the bounding box
BoundingBox box;
box.set(MAX_F32,MAX_F32,MAX_F32,MIN_F32,MIN_F32,MIN_F32);
for(U32 i = 0; i < sizeof(vertexes)/sizeof(DVTN); i++)box.expand(vertexes[i].point);
mQuadPtr->SetBox(box);
UNGUARD;
}
// Parse SQL Server, Sybase ASE UPDATE statememt
bool SqlParser::ParseSqlServerUpdateStatement(Token *update)
{
Token *name = GetNextIdentToken(SQL_IDENT_OBJECT);
if(name == NULL)
return false;
Token *set = TOKEN_GETNEXTW("SET");
if(set == NULL)
{
PushBack(name);
return false;
}
// Parser list of assignments: c1 = exp1, ...
while(true)
{
Token *col = GetNextIdentToken();
if(col == NULL)
break;
Token *equal = TOKEN_GETNEXT('=');
if(equal == NULL)
break;
// Single value or (SELECT c1, c2, ...) can be specified
Token *open = TOKEN_GETNEXT('(');
Token *select = NULL;
// Check for SELECT statement
if(open != NULL)
{
select = GetNextSelectStartKeyword();
// A subquery used to specify assignment values
if(select != NULL)
ParseSelectStatement(select, 0, SQL_SEL_UPDATE_SET, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
TOKEN_GETNEXT(')');
}
else
{
Token *exp = GetNextToken();
if(exp == NULL)
break;
ParseExpression(exp);
}
Token *comma = TOKEN_GETNEXT(',');
if(comma == NULL)
break;
}
Token *from = NULL;
Token *from_end = NULL;
// FROM clause can include inner/outer joins
ParseSelectFromClause(NULL, false, &from, &from_end, NULL, true, NULL);
Token *where_ = NULL;
Token *where_end = NULL;
// optional WHERE clause
ParseWhereClause(SQL_STMT_UPDATE, &where_, &where_end, NULL);
// UPDATE FROM syntax is used
if(from != NULL)
{
// MySQL, MariaDB use syntax UPDATE t1, t2 SET ... WHERE
if(Target(SQL_MYSQL, SQL_MARIADB))
{
Token::Remove(from);
AppendCopy(name, from, from_end, false);
Token::Remove(name);
Token::Remove(from, from_end);
}
}
// Implement CONTINUE handler for NOT FOUND in Oracle
if(_target == SQL_ORACLE)
OracleContinueHandlerForUpdate(update);
// Add statement delimiter if not set when source is SQL Server
SqlServerAddStmtDelimiter();
return true;
}
void
BitmapView::MessageReceived(BMessage *msg)
{
if (msg->WasDropped() && AcceptsDrops()) {
// We'll handle two types of drops: those from Tracker and those from ShowImage
if (msg->what == B_SIMPLE_DATA) {
int32 actions;
if (msg->FindInt32("be:actions", &actions) == B_OK) {
// ShowImage drop. This is a negotiated drag&drop, so send a reply
BMessage reply(B_COPY_TARGET), response;
reply.AddString("be:types", "image/jpeg");
reply.AddString("be:types", "image/png");
msg->SendReply(&reply, &response);
// now, we've gotten the response
if (response.what == B_MIME_DATA) {
// Obtain and translate the received data
uint8 *imagedata;
ssize_t datasize;
// Try JPEG first
if (response.FindData("image/jpeg", B_MIME_DATA,
(const void **)&imagedata, &datasize) != B_OK) {
// Try PNG next and piddle out if unsuccessful
if (response.FindData("image/png", B_PNG_FORMAT,
(const void **)&imagedata, &datasize) != B_OK)
return;
}
// Set up to decode into memory
BMemoryIO memio(imagedata, datasize);
BTranslatorRoster *roster = BTranslatorRoster::Default();
BBitmapStream bstream;
if (roster->Translate(&memio, NULL, NULL, &bstream, B_TRANSLATOR_BITMAP) == B_OK)
{
BBitmap *bmp;
if (bstream.DetachBitmap(&bmp) != B_OK)
return;
SetBitmap(bmp);
if (fConstrainDrops)
ConstrainBitmap();
Invoke();
}
}
return;
}
entry_ref ref;
if (msg->FindRef("refs", &ref) == B_OK) {
// Tracker drop
BBitmap *bmp = BTranslationUtils::GetBitmap(&ref);
if (bmp) {
SetBitmap(bmp);
if (fConstrainDrops)
ConstrainBitmap();
Invoke();
}
}
}
return;
}
switch (msg->what)
{
case M_REMOVE_IMAGE: {
BAlert *alert = new BAlert("Mr. Peeps!", "This cannot be undone. Remove the image?",
"Remove", "Cancel");
int32 value = alert->Go();
if (value == 0) {
SetBitmap(NULL);
if (Target()) {
BMessenger msgr(Target());
msgr.SendMessage(new BMessage(M_BITMAP_REMOVED));
return;
}
}
}
case M_PASTE_IMAGE:
{
PasteBitmap();
Invoke();
}
}
BView::MessageReceived(msg);
}
//------------------------------------------------------------------------------
void BSliderEditor::Init()
{
int bottom = Bottom();
if (!fModMsg)
{
bottom = Bottom();
fModMsg = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"modmsg", "Modification Message: ", "",
new BMessage(MSG_SLIDER_SET_MOD_MSG));
fModMsg->SetDivider(be_plain_font->StringWidth("Modification Message: "));
AddControl(fModMsg);
}
if (!fMinLabel)
{
bottom = Bottom();
fMinLabel = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"minlabel", "Left Label: ", "",
new BMessage(MSG_SLIDER_SET_LIMIT_LABELS));
fMinLabel->SetDivider(be_plain_font->StringWidth("Left Label: "));
AddControl(fMinLabel);
}
if (!fMaxLabel)
{
bottom = Bottom();
fMaxLabel = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"maxlabel", "Right Label: ", "",
new BMessage(MSG_SLIDER_SET_LIMIT_LABELS));
fMaxLabel->SetDivider(be_plain_font->StringWidth("Right Label: "));
AddControl(fMaxLabel);
}
if (!fMinValue)
{
bottom = Bottom();
fMinValue = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"minvalue", "Min Value: ", "",
new BMessage(MSG_SLIDER_SET_MIN_VALUE));
fMinValue->SetDivider(be_plain_font->StringWidth("Min Value: "));
AddControl(fMinValue);
}
if (!fMaxValue)
{
bottom = Bottom();
fMaxValue = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"maxvalue", "Max Value: ", "",
new BMessage(MSG_SLIDER_SET_MAX_VALUE));
fMaxValue->SetDivider(be_plain_font->StringWidth("Max Value: "));
AddControl(fMaxValue);
}
if (!fIncrValue)
{
bottom = Bottom();
fIncrValue = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"incrvalue", "Increment: ", "",
new BMessage(MSG_SLIDER_SET_INCREMENT));
fIncrValue->SetDivider(be_plain_font->StringWidth("Increment: "));
AddControl(fMaxValue);
}
if (!fOrientation)
{
bottom = Bottom();
fOrientation = new BMenuField(BRect(10, bottom, 190, bottom + 20),
"orientation", "Orientation: ",
new BPopUpMenu("menu"));
fOrientation->Menu()->AddItem(new BMenuItem("Horizontal",
new BMessage(MSG_SLIDER_SET_ORIENT_HORZ)));
fOrientation->Menu()->AddItem(new BMenuItem("Vertical",
new BMessage(MSG_SLIDER_SET_ORIENT_VERT)));
AddControl(fOrientation);
}
if (!fHashStyle)
{
bottom = Bottom();
fHashStyle = new BMenuField(BRect(10, bottom, 190, bottom + 20),
"hashstyle", "Hash Marks: ",
new BMenu("menu"));
fHashStyle->Menu()->AddItem(new BMenuItem("Top",
new BMessage(MSG_SLIDER_SET_HASH_TOP_LEFT)));
fHashStyle->Menu()->AddItem(new BMenuItem("Bottom",
new BMessage(MSG_SLIDER_SET_HASH_BOTTOM_RIGHT)));
AddControl(fHashStyle);
}
if (!fHashCount)
{
bottom = Bottom();
fHashCount = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"hashcount", "Hash Mark Count: ", "",
new BMessage(MSG_SLIDER_SET_HASH_COUNT));
fHashCount->SetDivider(be_plain_font->StringWidth("Hash Mark Count: "));
AddControl(fHashCount);
}
if (!fThumbStyle)
{
bottom = Bottom();
fThumbStyle = new BMenuField(BRect(10, bottom, 190, bottom + 20),
"thumbstyle", "Thumb Style: ",
new BPopUpMenu("menu"));
fThumbStyle->Menu()->AddItem(new BMenuItem("Rectangle",
new BMessage(MSG_SLIDER_SET_BLOCK_THUMB)));
fThumbStyle->Menu()->AddItem(new BMenuItem("Triangle",
new BMessage(MSG_SLIDER_SET_TRI_THUMB)));
AddControl(fThumbStyle);
}
if (!fBarColor)
{
bottom = Bottom();
fBarColor = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"barcolor", "Bar Color: ", "",
new BMessage(MSG_SLIDER_SET_BAR_COLOR));
fBarColor->SetDivider(be_plain_font->StringWidth("Bar Color: "));
AddControl(fBarColor);
}
if (!fUseFillCheck)
{
bottom = Bottom();
fUseFillCheck = new BCheckBox(BRect(10, bottom, 190, bottom + 20),
"usefillcolor", "Use Fill Color",
new BMessage(MSG_SLIDER_USE_FILL_COLOR));
AddControl(fUseFillCheck);
}
if (!fFillColor)
{
bottom = Bottom();
fFillColor = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"fillcolor", "Fill Color: ", "",
new BMessage(MSG_SLIDER_SET_FILL_COLOR));
fFillColor->SetDivider(be_plain_font->StringWidth("Bar Thickness: "));
AddControl(fFillColor);
}
if (!fBarThickness)
{
bottom = Bottom();
fBarThickness = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"barthickness", "Bar Thickness: ", "",
new BMessage(MSG_SLIDER_SET_THICKNESS));
fBarThickness->SetDivider(be_plain_font->StringWidth("Bar Thickness: "));
AddControl(fBarThickness);
}
if (!fSnoozeAmount)
{
bottom = Bottom();
fSnoozeAmount = new BTextControl(BRect(10, bottom, 190, bottom + 20),
"snoozeamount", "Snooze: ", "",
new BMessage(MSG_SLIDER_SET_SNOOZE));
fSnoozeAmount->SetDivider(be_plain_font->StringWidth("Snooze: "));
AddControl(fSnoozeAmount);
}
if (Target())
{
SetThumbStyle(Target()->Style());
}
}
void Epetra_Import::Construct_Expert( const Epetra_BlockMap & targetMap, const Epetra_BlockMap & sourceMap, int NumRemotePIDs, const int * UserRemotePIDs,
const int & UserNumExportIDs, const int * UserExportLIDs, const int * UserExportPIDs)
{
int i,ierr;
// Build three ID lists:
// NumSameIDs - Number of IDs in TargetMap and SourceMap that are identical, up to the first
// nonidentical ID.
// NumPermuteIDs - Number of IDs in SourceMap that must be indirectly loaded but are on this processor.
// NumRemoteIDs - Number of IDs that are in SourceMap but not in TargetMap, and thus must be imported.
int NumSourceIDs = sourceMap.NumMyElements();
int NumTargetIDs = targetMap.NumMyElements();
int_type *TargetGIDs = 0;
if (NumTargetIDs>0) {
TargetGIDs = new int_type[NumTargetIDs];
targetMap.MyGlobalElements(TargetGIDs);
}
int_type * SourceGIDs = 0;
if (NumSourceIDs>0) {
SourceGIDs = new int_type[NumSourceIDs];
sourceMap.MyGlobalElements(SourceGIDs);
}
int MinIDs = EPETRA_MIN(NumSourceIDs, NumTargetIDs);
NumSameIDs_ = 0;
for (i=0; i< MinIDs; i++) if (TargetGIDs[i]==SourceGIDs[i]) NumSameIDs_++; else break;
// Find count of Target IDs that are truly remote and those that are local but permuted
NumPermuteIDs_ = 0;
NumRemoteIDs_ = 0;
for (i=NumSameIDs_; i< NumTargetIDs; i++)
if (sourceMap.MyGID(TargetGIDs[i])) NumPermuteIDs_++; // Check if Target GID is a local Source GID
else NumRemoteIDs_++; // If not, then it is remote
// Define remote and permutation lists
int_type * RemoteGIDs=0;
RemoteLIDs_ = 0;
if (NumRemoteIDs_>0) {
RemoteLIDs_ = new int[NumRemoteIDs_];
RemoteGIDs = new int_type[NumRemoteIDs_];
}
if (NumPermuteIDs_>0) {
PermuteToLIDs_ = new int[NumPermuteIDs_];
PermuteFromLIDs_ = new int[NumPermuteIDs_];
}
NumPermuteIDs_ = 0;
NumRemoteIDs_ = 0;
for (i=NumSameIDs_; i< NumTargetIDs; i++) {
if (sourceMap.MyGID(TargetGIDs[i])) {
PermuteToLIDs_[NumPermuteIDs_] = i;
PermuteFromLIDs_[NumPermuteIDs_++] = sourceMap.LID(TargetGIDs[i]);
}
else {
//NumRecv_ +=TargetMap.ElementSize(i); // Count total number of entries to receive
NumRecv_ +=targetMap.MaxElementSize(); // Count total number of entries to receive (currently need max)
RemoteGIDs[NumRemoteIDs_] = TargetGIDs[i];
RemoteLIDs_[NumRemoteIDs_++] = i;
}
}
if( NumRemoteIDs_>0 && !sourceMap.DistributedGlobal() )
ReportError("Warning in Epetra_Import: Serial Import has remote IDs. (Importing to Subset of Target Map)", 1);
// Test for distributed cases
int * RemotePIDs = 0;
if (sourceMap.DistributedGlobal()) {
if (NumRemoteIDs_>0) RemotePIDs = new int[NumRemoteIDs_];
#ifdef EPETRA_ENABLE_DEBUG
int myeq = (NumRemotePIDs==NumRemoteIDs_);
int globaleq=0;
sourceMap.Comm().MinAll(&myeq,&globaleq,1);
if(globaleq!=1) {
printf("[%d] UserRemotePIDs count wrong %d != %d\n",sourceMap.Comm().MyPID(),NumRemotePIDs,NumRemoteIDs_);
fflush(stdout);
sourceMap.Comm().Barrier();
sourceMap.Comm().Barrier();
sourceMap.Comm().Barrier();
throw ReportError("Epetra_Import: UserRemotePIDs count wrong");
}
#endif
if(NumRemotePIDs==NumRemoteIDs_){
// Since I need to sort these, I'll copy them
for(i=0; i<NumRemoteIDs_; i++) RemotePIDs[i] = UserRemotePIDs[i];
}
//Get rid of IDs that don't exist in SourceMap
if(NumRemoteIDs_>0) {
int cnt = 0;
for( i = 0; i < NumRemoteIDs_; ++i )
if( RemotePIDs[i] == -1 ) ++cnt;
if( cnt ) {
if( NumRemoteIDs_-cnt ) {
int_type * NewRemoteGIDs = new int_type[NumRemoteIDs_-cnt];
int * NewRemotePIDs = new int[NumRemoteIDs_-cnt];
int * NewRemoteLIDs = new int[NumRemoteIDs_-cnt];
cnt = 0;
for( i = 0; i < NumRemoteIDs_; ++i )
if( RemotePIDs[i] != -1 ) {
NewRemoteGIDs[cnt] = RemoteGIDs[i];
NewRemotePIDs[cnt] = RemotePIDs[i];
NewRemoteLIDs[cnt] = targetMap.LID(RemoteGIDs[i]);
++cnt;
}
NumRemoteIDs_ = cnt;
delete [] RemoteGIDs;
delete [] RemotePIDs;
delete [] RemoteLIDs_;
RemoteGIDs = NewRemoteGIDs;
RemotePIDs = NewRemotePIDs;
RemoteLIDs_ = NewRemoteLIDs;
ReportError("Warning in Epetra_Import: Target IDs not found in Source Map (Do you want to import to subset of Target Map?)", 1);
}
else { //valid RemoteIDs empty
NumRemoteIDs_ = 0;
delete [] RemoteGIDs;
RemoteGIDs = 0;
delete [] RemotePIDs;
RemotePIDs = 0;
}
}
}
//Sort Remote IDs by processor so DoReverses will work
Epetra_Util util;
if(targetMap.GlobalIndicesLongLong())
{
util.Sort(true,NumRemoteIDs_,RemotePIDs,0,0, 1,&RemoteLIDs_, 1,(long long**)&RemoteGIDs);
}
else if(targetMap.GlobalIndicesInt())
{
int* ptrs[2] = {RemoteLIDs_, (int*)RemoteGIDs};
util.Sort(true,NumRemoteIDs_,RemotePIDs,0,0,2,&ptrs[0], 0, 0);
}
else
{
throw ReportError("Epetra_Import::Epetra_Import: GlobalIndices Internal Error", -1);
}
// Build distributor & Export lists
Distor_ = sourceMap.Comm().CreateDistributor();
NumExportIDs_=UserNumExportIDs;
ExportLIDs_ = new int[NumExportIDs_];
ExportPIDs_ = new int[NumExportIDs_];
for(i=0; i<NumExportIDs_; i++) {
ExportPIDs_[i] = UserExportPIDs[i];
ExportLIDs_[i] = UserExportLIDs[i];
}
#ifdef HAVE_MPI
Epetra_MpiDistributor* MpiDistor = dynamic_cast< Epetra_MpiDistributor*>(Distor_);
bool Deterministic = true;
if(MpiDistor)
ierr=MpiDistor->CreateFromSendsAndRecvs(NumExportIDs_,ExportPIDs_,
NumRemoteIDs_, RemoteGIDs, RemotePIDs,Deterministic);
else ierr=-10;
#else
ierr=-20;
#endif
if (ierr!=0) throw ReportError("Error in Epetra_Distributor.CreateFromRecvs()", ierr);
}
if( NumRemoteIDs_>0 ) delete [] RemoteGIDs;
if( NumRemoteIDs_>0 ) delete [] RemotePIDs;
if (NumTargetIDs>0) delete [] TargetGIDs;
if (NumSourceIDs>0) delete [] SourceGIDs;
#ifdef EPETRA_ENABLE_DEBUG
// Sanity check to make sure we got the import right
Epetra_IntVector Source(sourceMap);
Epetra_IntVector Target(targetMap);
for(i=0; i<Source.MyLength(); i++)
Source[i] = (int) (Source.Map().GID(i) % INT_MAX);
Target.PutValue(-1);
Target.Import(Source,*this,Insert);
bool test_passed=true;
for(i=0; i<Target.MyLength(); i++){
if(Target[i] != Target.Map().GID(i) % INT_MAX) test_passed=false;
}
if(!test_passed) {
printf("[%d] PROCESSOR has a mismatch... prepearing to crash or hang!\n",sourceMap.Comm().MyPID());
fflush(stdout);
sourceMap.Comm().Barrier();
sourceMap.Comm().Barrier();
sourceMap.Comm().Barrier();
throw ReportError("Epetra_Import: ERROR. User provided IDs do not match what an import generates.");
}
#endif
return;
}
void
BNavMenu::ResetTargets()
{
SetTargetForItems(Target());
}
bool Fluid::perform( Action a, const Target& t )
{
switch ( a )
{
case aPolymorph:
do
{
f_material = (materialClass) Random::randint( m_total );
}
while ( Material::data[ f_material ].state != powder
&& Material::data[ f_material ].state != ooze
&& Material::data[ f_material ].state != liquid);
image.val.color = Material::data[ f_material ].color;
return Item::perform(a, t);
case aSpMessage:
{
String thisplace = "This place";
Target parent = getTarget(tg_parent);
if (!!parent)
{
thisplace = Grammar::plural(parent, Grammar::det_definite) + " here";
}
Message::add(thisplace + " is covered in " + menustring() + ".");
return true;
}
case aCombine:
if ( equals(t) || t->equals( Target(THIS) ) )
{
return true;
}
return false;
case aBeQuaffed:
{
if (t->getVal(attrib_visible))
{
String adj;
switch (f_material)
{
case m_blood:
adj = "metallic";
break;
case m_water:
adj = "refreshing";
break;
default:
adj = "revolting";
break;
}
if ( t->istype(tg_player) )
{
Message::add(Grammar::Subject(THIS, Grammar::det_definite) + " taste" + (getVal(attrib_plural) ? " " : "s ") + adj + ".");
}
else
{
Message::add(Grammar::Subject(THIS, Grammar::det_definite) + " look" + (getVal(attrib_plural) ? " " : "s ") + adj + ".");
}
}
getTarget(tg_controller)->perform(aAddBill, THIS);
detach();
return true;
}
default:
return Item::perform(a, t);
}
}
inline Target lexical_cast_noexcept_d(Source const& arg)
{
return lexical_cast_noexcept(arg, Target());
}
inline Target lexical_cast_noexcept_d(CharType const* arg, std::size_t len)
{
return lexical_cast_noexcept(arg, len, Target());
}
bool Init()
{
// Vector3f Pos(0.0f, 23.0f, -5.0f);
// Vector3f Target(-1.0f, 0.0f, 0.1f);
Vector3f Pos(0.0f, 24.0f, -38.0f);
Vector3f Target(0.0f, -0.5f, 1.0f);
Vector3f Up(0.0, 1.0f, 0.0f);
m_pGameCamera = new Camera(WINDOW_WIDTH, WINDOW_HEIGHT, Pos, Target, Up);
if (!m_geomPassTech.Init()) {
OGLDEV_ERROR("Error initializing the geometry pass technique\n");
return false;
}
if (!m_SSAOTech.Init()) {
OGLDEV_ERROR("Error initializing the SSAO technique\n");
return false;
}
m_SSAOTech.Enable();
m_SSAOTech.SetSampleRadius(1.5f);
Matrix4f PersProjTrans;
PersProjTrans.InitPersProjTransform(m_persProjInfo);
m_SSAOTech.SetProjMatrix(PersProjTrans);
if (!m_lightingTech.Init()) {
OGLDEV_ERROR("Error initializing the lighting technique\n");
return false;
}
m_lightingTech.Enable();
m_lightingTech.SetDirectionalLight(m_directionalLight);
m_lightingTech.SetScreenSize(WINDOW_WIDTH, WINDOW_HEIGHT);
m_lightingTech.SetShaderType(0);
if (!m_blurTech.Init()) {
OGLDEV_ERROR("Error initializing the blur technique\n");
return false;
}
//if (!m_mesh.LoadMesh("../Content/crytek_sponza/sponza.obj")) {
if (!m_mesh.LoadMesh("../Content/jeep.obj")) {
return false;
}
m_mesh.GetOrientation().m_scale = Vector3f(0.05f);
m_mesh.GetOrientation().m_pos = Vector3f(0.0f, 0.0f, 0.0f);
m_mesh.GetOrientation().m_rotation = Vector3f(0.0f, 180.0f, 0.0f);
if (!m_quad.LoadMesh("../Content/quad.obj")) {
return false;
}
if (!m_gBuffer.Init(WINDOW_WIDTH, WINDOW_HEIGHT, true, GL_RGB32F)) {
return false;
}
if (!m_aoBuffer.Init(WINDOW_WIDTH, WINDOW_HEIGHT, false, GL_R32F)) {
return false;
}
if (!m_blurBuffer.Init(WINDOW_WIDTH, WINDOW_HEIGHT, false, GL_R32F)) {
return false;
}
#ifndef WIN32
if (!m_fontRenderer.InitFontRenderer()) {
return false;
}
#endif
return true;
}
void FWorldTreeItem::OnDrop(FDragDropPayload& DraggedObjects, UWorld& InWorld, const FDragValidationInfo& ValidationInfo, TSharedRef<SWidget> DroppedOnWidget)
{
FFolderDropTarget Target(NAME_None);
return Target.OnDrop(DraggedObjects, InWorld, ValidationInfo, DroppedOnWidget);
}
FDragValidationInfo FWorldTreeItem::ValidateDrop(FDragDropPayload& DraggedObjects, UWorld& InWorld) const
{
// Dropping on the world means 'moving to the root' in folder terms
FFolderDropTarget Target(NAME_None);
return Target.ValidateDrop(DraggedObjects, InWorld);
}
//
// Poll
//
// Attempt to trigger this trap
//
Bool TrapObj::Poll()
{
// Did we find a valid target
Bool valid = FALSE;
// Has recharging finished
if (recharge.Test())
{
UnitObj *target;
// Find an enemy within the configured range
UnitObjIter::Tactical i
(
NULL, UnitObjIter::FilterData(GetTeam(), Relation::ENEMY, Position(), TrapType()->GetDistance())
);
// Step through each possible target
while ((target = i.Next()) != NULL)
{
// Can this trap trigger on this target
if (TrapType()->Test(target))
{
// Does this trap self destruct
if (TrapType()->GetSelfDestruct())
{
SelfDestruct(TRUE, GetTeam());
valid = TRUE;
}
// Does this trap attach a parasite
if (TrapType()->GetParasite() && TrapType()->GetParasite()->Infect(target, GetTeam()))
{
valid = TRUE;
}
// Should we fire a weapon
if (TrapType()->GetWeaponSpeed() > 0.0F)
{
if (GetWeapon())
{
Vector pos = Origin();
pos.y += 20.0f;
GetWeapon()->SetTarget(Target(pos));
valid = TRUE;
}
else
{
LOG_WARN(("Trap %s configured to fire a weapon, but has none!", TypeName()));
}
}
if (valid)
{
// Signal team radio that we were triggered
if (GetTeam())
{
// "Trap::Triggered"
GetTeam()->GetRadio().Trigger(0xA0FF29A5, Radio::Event(this));
}
// Signal the target that it has been trapped
if (target->GetTeam())
{
// "Trap::Triggered::Target"
target->GetTeam()->GetRadio().Trigger(0x3070E869, Radio::Event(target));
}
// Start charge time
recharge.Start(TrapType()->GetChargeTime());
}
// Only affect one target for now
break;
}
}
}
return (valid);
}
bool WINAPI getCredmanData(__in PLUID logId, __in mod_pipe * monPipe, __in bool justSecurity)
{
wostringstream message;
if(searchCredmanFuncs())
{
DWORD credNb = 0;
PCREDENTIAL * pCredential = NULL;
DWORD CredIEnumerateFlags = (mod_system::GLOB_Version.dwMajorVersion < 6) ? 0 : CRED_ENUMERATE_ALL_CREDENTIALS;
NTSTATUS status = (mod_system::GLOB_Version.dwBuildNumber < 8000 ) ? CredIEnumerate(logId, 0, NULL, CredIEnumerateFlags, &credNb, &pCredential) : reinterpret_cast<PCRED_I_ENUMERATE62>(CredIEnumerate)(logId, NULL, CredIEnumerateFlags, &credNb, &pCredential);
if(NT_SUCCESS(status))
{
for(DWORD i = 0; i < credNb; i++)
{
wstring Target(pCredential[i]->TargetName);
wstring ShortTarget = (mod_system::GLOB_Version.dwMajorVersion < 6) ? Target : Target.substr(Target.find_first_of(L'=') + 1);
message << endl;
if(justSecurity)
message << L"\t [" << i << L"] " << Target << L'\t';
else message <<
L"\t * [" << i << L"] Target : " << Target << L" / " << (pCredential[i]->TargetAlias ? pCredential[i]->TargetAlias : L"<NULL>") << endl <<
L"\t * [" << i << L"] Comment : " << (pCredential[i]->Comment ? pCredential[i]->Comment : L"<NULL>") << endl <<
L"\t * [" << i << L"] User : "******"[" << j << L"] ";
message << descEncryptedCredential(pEncryptedCredential[j], justSecurity, prefix.str());
}
SeckPkgFunctionTable->CrediFreeCredentials(dwNbCredentials, pEncryptedCredential);
}
else message << L"Error CrediReadDomainCredentials : " << mod_system::getWinError(false, status);
}
else
{
PENCRYPTED_CREDENTIALW pEncryptedCredential;
NTSTATUS status = SeckPkgFunctionTable->CrediRead(logId, CREDP_FLAGS_IN_PROCESS, const_cast<wchar_t *>(ShortTarget.c_str()), pCredential[i]->Type, 0, &pEncryptedCredential);
if(NT_SUCCESS(status))
{
message << descEncryptedCredential(pEncryptedCredential, justSecurity);
CredFree(pEncryptedCredential);
}
else message << L"Error CrediRead : " << mod_system::getWinError(false, status);
}
}
CredFree(pCredential);
}
else message << L"CredIEnumerate KO : " << mod_system::getWinError(false, status);
} else message << L"n.a. (credman KO)";
return sendTo(monPipe, message.str());
}
Operand* ConstantFolder::HandleCall(CallInstr* callInstr) {
// A call to an 'undef' operand, or to a null pointer yields
// undefined behavior, so we're allowed to do everything we want.
if(callInstr->TargetOp()->IsUndefinedConstant() ||
callInstr->TargetOp()->IsNullConstant()) {
// We should return 'undef' only if the function returns a value.
if(callInstr->ResultOp()) {
return GetUndefined(callInstr->ResultOp());
}
else return nullptr;
}
// The target must be a reference to a known function.
auto functionRef = callInstr->TargetOp()->As<FunctionReference>();
if(functionRef == nullptr) {
return nullptr;
}
// First test for intrinsics; we fold them using the stdlib functions.
if(auto intrinsic = functionRef->Target()->As<Intrinsic>()) {
return HandleIntrinsic(callInstr, intrinsic);
}
// Check if the function is a known standard library function,
// and try to evaluate it at compile time. Very useful for functions like
// 'sin', 'cos', 'floor', etc.
StdlibType functionType = StdlibRecognizer::Recognize(functionRef->Target());
if(functionType == Stdlib_None) {
return nullptr;
}
// We treat for now only functions from 'math.h'.
// The functions are evaluated using the implementation
// provided by the compiler, so note that the results
// are dependent on the machine where the program is compiled.
switch(functionType) {
case Stdlib_fabs: return EvaluateMathOneParam(callInstr, std::fabs);
case Stdlib_sqrt: return EvaluateMathOneParam(callInstr, std::sqrt);
case Stdlib_exp: return EvaluateMathOneParam(callInstr, std::exp);
case Stdlib_floor: return EvaluateMathOneParam(callInstr, std::floor);
case Stdlib_ceil: return EvaluateMathOneParam(callInstr, std::ceil);
case Stdlib_log: return EvaluateMathOneParam(callInstr, std::log);
case Stdlib_log10: return EvaluateMathOneParam(callInstr, std::log10);
case Stdlib_sin: return EvaluateMathOneParam(callInstr, std::sin);
case Stdlib_asin: return EvaluateMathOneParam(callInstr, std::asin);
case Stdlib_cos: return EvaluateMathOneParam(callInstr, std::cos);
case Stdlib_acos: return EvaluateMathOneParam(callInstr, std::acos);
case Stdlib_tan: return EvaluateMathOneParam(callInstr, std::tan);
case Stdlib_atan: return EvaluateMathOneParam(callInstr, std::atan);
case Stdlib_abs: return EvaluateMathOneParamInt(callInstr, std::abs);
case Stdlib_labs: return EvaluateMathOneParamLong(callInstr, std::labs);
case Stdlib_sqrtf: return EvaluateMathOneParamFloat(callInstr, std::sqrtf);
case Stdlib_expf: return EvaluateMathOneParamFloat(callInstr, std::expf);
case Stdlib_floorf: return EvaluateMathOneParamFloat(callInstr, std::floorf);
case Stdlib_ceilf: return EvaluateMathOneParamFloat(callInstr, std::ceilf);
case Stdlib_logf: return EvaluateMathOneParamFloat(callInstr, std::logf);
case Stdlib_log10f: return EvaluateMathOneParamFloat(callInstr, std::log10f);
case Stdlib_sinf: return EvaluateMathOneParamFloat(callInstr, std::sinf);
case Stdlib_asinf: return EvaluateMathOneParamFloat(callInstr, std::asinf);
case Stdlib_cosf: return EvaluateMathOneParamFloat(callInstr, std::cosf);
case Stdlib_acosf: return EvaluateMathOneParamFloat(callInstr, std::acosf);
case Stdlib_tanf: return EvaluateMathOneParamFloat(callInstr, std::tanf);
case Stdlib_atanf: return EvaluateMathOneParamFloat(callInstr, std::atanf);
case Stdlib_pow: return EvaluateMathTwoParams(callInstr, std::pow);
case Stdlib_fmod: return EvaluateMathTwoParams(callInstr, std::fmod);
case Stdlib_atan2: return EvaluateMathTwoParams(callInstr, std::atan2);
case Stdlib_powf: return EvaluateMathTwoParamsFloat(callInstr, std::powf);
case Stdlib_fmodf: return EvaluateMathTwoParamsFloat(callInstr, std::fmodf);
}
return nullptr;
}
//------------------------------------------------------------------------------
bool BSliderEditor::MessageReceived(BMessage* msg)
{
switch (msg->what)
{
case MSG_SLIDER_SET_BLOCK_THUMB:
Target()->SetStyle(B_BLOCK_THUMB);
Target()->Invalidate();
return true;
case MSG_SLIDER_SET_TRI_THUMB:
Target()->SetStyle(B_TRIANGLE_THUMB);
Target()->Invalidate();
return true;
case MSG_SLIDER_SET_LIMIT_LABELS:
Target()->SetLimitLabels(fMinLabel->Text(), fMaxLabel->Text());
return true;
case MSG_SLIDER_SET_HASH_TOP_LEFT:
{
SetHashStyle(B_HASH_MARKS_TOP);
return true;
}
case MSG_SLIDER_SET_HASH_BOTTOM_RIGHT:
{
SetHashStyle(B_HASH_MARKS_BOTTOM);
return true;
}
case MSG_SLIDER_SET_ORIENT_HORZ:
Target()->SetOrientation(B_HORIZONTAL);
SetOrientation(B_HORIZONTAL);
return true;
case MSG_SLIDER_SET_ORIENT_VERT:
Target()->SetOrientation(B_VERTICAL);
SetOrientation(B_VERTICAL);
return true;
case MSG_SLIDER_SET_HASH_COUNT:
Target()->SetHashMarkCount(atoi(fHashCount->Text()));
return true;
case MSG_SLIDER_SET_MIN_VALUE:
case MSG_SLIDER_SET_MAX_VALUE:
Target()->SetLimits(atoi(fMinValue->Text()),
atoi(fMaxValue->Text()));
return true;
case MSG_SLIDER_SET_INCREMENT:
Target()->SetKeyIncrementValue(atoi(fIncrValue->Text()));
return true;
case MSG_SLIDER_SET_MOD_MSG:
{
BMessage* Message = new BMessage(flipcode(*(int32*)fModMsg->Text()));
Target()->SetModificationMessage(Message);
return true;
}
case MSG_SLIDER_SET_BAR_COLOR:
{
int32 color = atoi(fBarColor->Text());
Target()->SetBarColor(*(rgb_color*)&color);
Target()->Invalidate();
return true;
}
case MSG_SLIDER_USE_FILL_COLOR:
case MSG_SLIDER_SET_FILL_COLOR:
{
bool use = fUseFillCheck->Value();
int32 color = atoi(fFillColor->Text());
Target()->UseFillColor(use, (rgb_color*)&color);
fFillColor->SetEnabled(use);
Target()->Invalidate();
return true;
}
case MSG_SLIDER_SET_THICKNESS:
Target()->SetBarThickness(atof(fBarThickness->Text()));
Target()->Invalidate();
return true;
default:
return BControlEditor::MessageReceived(msg);
}
}
