void Nmr::on_isotopeCombo_currentIndexChanged(QString const& text)
{
QString isotope(currentIsotope(text));
Data::NmrReferenceLibrary& library(Data::NmrReferenceLibrary::instance());
QList<Data::NmrReference const*> refs(library.filter(isotope));
QStringList systems;
QList<Data::NmrReference const*>::iterator iter;
for (iter = refs.begin(); iter != refs.end(); ++iter) {
QString system((*iter)->system());
if (!systems.contains(system)) systems.append(system);
}
QComboBox* combo(m_ui->systemCombo);
combo->clear();
combo->addItems(systems);
loadShifts(currentReference(), isotope);
QPair<double, double> range(standardRange(isotope));
m_plot->xAxis->setRange(range.first, range.second);
updatePlot();
}
void WWinPartService::Reset()
{
IWorkbenchPage* tempPage = activePage;
activePage = 0;
if (tempPage)
{
WorkbenchPage* page = dynamic_cast<WorkbenchPage*>(tempPage);
std::vector<IWorkbenchPartReference::Pointer> refs(page->GetOpenParts());
for (std::size_t i = 0; i < refs.size(); i++)
{
IWorkbenchPartReference::Pointer reference = refs[i];
if (page->IsPartVisible(reference))
{
partService.FirePartHidden(reference);
}
partService.FirePartClosed(reference);
}
tempPage->RemovePartListener(partListener);
}
}
void DisassemblerDatabase::load()
{
this->_disassemblerdb.open(this->_filename.toUtf8().constData());
SQLiteStatement s(this->_disassemblerdb, "SELECT * FROM SymbolTable");
while(s.step())
{
DataValue addressvalue = DataValue::create(s.column(0).integer64(), this->_symboltable->addressType());
DataValue sizevalue = DataValue::create(s.column(3).integer64(), this->_symboltable->addressType());
this->_symboltable->set(static_cast<Symbol::Type>(s.column(2).integer()), addressvalue, sizevalue, DataValue(), QString::fromUtf8(s.column(1).text()));
if(s.column(4).integer64())
{
Symbol* symbol = this->_symboltable->get(addressvalue);
SQLiteStatement refs(this->_disassemblerdb, "SELECT * FROM ReferenceTable WHERE Address = ?");
refs.bind(1, s.column(0).integer64());
while(refs.step())
{
DataValue referencevalue = DataValue::create(refs.column(1).integer64(), this->_symboltable->addressType());
symbol->addSource(referencevalue);
}
}
}
this->_disassemblerdb.close();
}
static int Android_JNI_FileClose(SDL_RWops* ctx, bool release)
{
LocalReferenceHolder refs(__FUNCTION__);
int result = 0;
JNIEnv *mEnv = Android_JNI_GetEnv();
if (!refs.init(mEnv)) {
SDL_SetError("Failed to allocate enough JVM local references");
return -1;
}
if (ctx) {
if (release) {
mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.fileNameRef);
}
jobject inputStream = (jobject)ctx->hidden.androidio.inputStreamRef;
// inputStream.close();
jmethodID mid = mEnv->GetMethodID(mEnv->GetObjectClass(inputStream),
"close", "()V");
mEnv->CallVoidMethod(inputStream, mid);
mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.inputStreamRef);
mEnv->DeleteGlobalRef((jobject)ctx->hidden.androidio.readableByteChannelRef);
if (Android_JNI_ExceptionOccurred()) {
result = -1;
}
if (release) {
SDL_FreeRW(ctx);
}
}
return result;
}
Status ViewCatalog::_upsertIntoGraph(OperationContext* opCtx, const ViewDefinition& viewDef) {
// Performs the insert into the graph.
auto doInsert = [this, &opCtx](const ViewDefinition& viewDef, bool needsValidation) -> Status {
// Validate that the pipeline is eligible to serve as a view definition. If it is, this
// will also return the set of involved namespaces.
auto pipelineStatus = _validatePipeline_inlock(opCtx, viewDef);
if (!pipelineStatus.isOK()) {
if (needsValidation) {
uassertStatusOKWithContext(pipelineStatus.getStatus(),
str::stream() << "Invalid pipeline for view "
<< viewDef.name().ns());
}
return pipelineStatus.getStatus();
}
auto involvedNamespaces = pipelineStatus.getValue();
std::vector<NamespaceString> refs(involvedNamespaces.begin(), involvedNamespaces.end());
refs.push_back(viewDef.viewOn());
int pipelineSize = 0;
for (auto obj : viewDef.pipeline()) {
pipelineSize += obj.objsize();
}
if (needsValidation) {
// Check the collation of all the dependent namespaces before updating the graph.
auto collationStatus = _validateCollation_inlock(opCtx, viewDef, refs);
if (!collationStatus.isOK()) {
return collationStatus;
}
return _viewGraph.insertAndValidate(viewDef, refs, pipelineSize);
} else {
_viewGraph.insertWithoutValidating(viewDef, refs, pipelineSize);
return Status::OK();
}
};
if (_viewGraphNeedsRefresh) {
_viewGraph.clear();
for (auto&& iter : _viewMap) {
auto status = doInsert(*(iter.second.get()), false);
// If we cannot fully refresh the graph, we will keep '_viewGraphNeedsRefresh' true.
if (!status.isOK()) {
return status;
}
}
// Only if the inserts completed without error will we no longer need a refresh.
opCtx->recoveryUnit()->onRollback([this]() { this->_viewGraphNeedsRefresh = true; });
_viewGraphNeedsRefresh = false;
}
// Remove the view definition first in case this is an update. If it is not in the graph, it
// is simply a no-op.
_viewGraph.remove(viewDef.name());
return doInsert(viewDef, true);
}
void pushFrame(refFrame frame, int count)
{ refRefObject slotsStart = refs(frame);
count(frame) = count;
while (count > 0)
{ d(slotsStart) = nil;
slotsStart += 1;
count -= 1; }
link(frame) = frames;
frames = frame; }
void WWinPartService::PageActivated(SmartPointer<IWorkbenchPage> newPage)
{
// Optimize.
if (newPage == activePage)
{
return;
}
// Fire events in the following order:
// 1. For each open part in the new page, open it and then (if applicable) make it visible
// 2. Deactivate old active part
// 3. Activate the new active part
// 4. For each open part in the old page, make it invisible then close it
// Hook listener on the new page.
if (newPage)
{
std::vector<IWorkbenchPartReference::Pointer> refs(newPage.Cast<
WorkbenchPage> ()->GetOpenParts());
for (std::size_t i = 0; i < refs.size(); i++)
{
IWorkbenchPartReference::Pointer reference = refs[i];
partService.FirePartOpened(reference);
IWorkbenchPart::Pointer part = reference->GetPart(false);
if (part && newPage->IsPartVisible(part))
{
partService.FirePartVisible(reference);
}
}
partService.SetActivePart(newPage->GetActivePartReference());
selectionService.SetActivePart(newPage->GetActivePart());
}
else
{
partService.SetActivePart(IWorkbenchPartReference::Pointer(0));
selectionService.SetActivePart(IWorkbenchPart::Pointer(0));
}
// Unhook listener from the old page.
Reset();
// Update active page.
activePage = newPage.GetPointer();
if (newPage)
{
newPage->AddPartListener(partListener);
}
}
void Configuration::readConfig()
{
if (!m_dirty)
return;
m_dirty = false;
QObject deleterParent;
QDir dir = QDir::current();
do {
QDir git = dir;
if (git.cd(".git")) {
m_repoDir = dir;
m_repoMetaDataDir = git;
QDir refs(git.absoluteFilePath("refs/heads"));
m_emptyRepo = refs.count() == 2; // only '.' and '..'
break;
}
if (!dir.cdUp())
break;
} while(!dir.isRoot());
QString home = QDir::homePath();
QFile *config;
config = new QFile(home + "/.vng/config", &deleterParent);
if (! config->exists())
config = new QFile(home + "/.darcs/defaults", &deleterParent);
if (config->exists()) {
if (! config->open(QIODevice::ReadOnly)) {
Logger::error() << "Failed to open config file, is it readable?\n";
return;
}
char buf[1024];
while(true) {
qint64 lineLength = config->readLine(buf, sizeof(buf));
if (lineLength == -1)
break;
QString line = QString::fromUtf8(buf, lineLength);
QString option;
if (line.startsWith("ALL "))
option = line.mid(3).trimmed();
else if (line.length() > m_section.length() && line.startsWith(m_section))
option = line.mid(m_section.length()).trimmed();
if (! option.isEmpty()) {
const int index = option.indexOf(' ');
if (index > 0) {
m_options.insert(option.left(index).trimmed(), option.mid(index).trimmed());
}
else
m_options.insert(option, QString());
}
}
config->close();
}
}
void CtcQInterCoreF::contract(IntervalVector& box) {
Array<IntervalVector> refs(list.size());
for (int i=0; i<list.size(); i++) {
boxes[i]=box;
list[i].contract(boxes[i]);
refs.set_ref(i,boxes[i]);
}
box = qinter_coref(refs,q);
}
wxString FeedPanel::DecorateStatusText(wxString text) const
{
wxRegEx links(_T("((https?|www\\.)://[^[:space:]]+)"), wxRE_ICASE);
wxRegEx hashtags(_T("#([[:alnum:]_]+)"));
wxRegEx refs(_T("@([[:alnum:]_]+)"));
links.ReplaceAll(&text, _T("<a href='\\1'>\\1</a>"));
refs.ReplaceAll(&text, _T("@<a href='http://twitter.com/\\1'>\\1</a>"));
hashtags.ReplaceAll(&text, _T("#<a href='http://hashtags.org/tag/\\1'>\\1</a>"));
return text;
}
extern "C" size_t Android_JNI_FileRead(SDL_RWops* ctx, void* buffer,
size_t size, size_t maxnum)
{
LocalReferenceHolder refs(__FUNCTION__);
if (ctx->hidden.androidio.assetFileDescriptorRef) {
size_t bytesMax = size * maxnum;
if (ctx->hidden.androidio.size != -1 /*UNKNOWN_LENGTH*/ && ctx->hidden.androidio.position + bytesMax > ctx->hidden.androidio.size) {
bytesMax = ctx->hidden.androidio.size - ctx->hidden.androidio.position;
}
size_t result = read(ctx->hidden.androidio.fd, buffer, bytesMax );
if (result > 0) {
ctx->hidden.androidio.position += result;
return result / size;
}
return 0;
} else {
jlong bytesRemaining = (jlong) (size * maxnum);
jlong bytesMax = (jlong) (ctx->hidden.androidio.size - ctx->hidden.androidio.position);
int bytesRead = 0;
/* Don't read more bytes than those that remain in the file, otherwise we get an exception */
if (bytesRemaining > bytesMax) bytesRemaining = bytesMax;
JNIEnv *mEnv = Android_JNI_GetEnv();
if (!refs.init(mEnv)) {
return -1;
}
jobject readableByteChannel = (jobject)ctx->hidden.androidio.readableByteChannelRef;
jmethodID readMethod = (jmethodID)ctx->hidden.androidio.readMethod;
jobject byteBuffer = mEnv->NewDirectByteBuffer(buffer, bytesRemaining);
while (bytesRemaining > 0) {
// result = readableByteChannel.read(...);
int result = mEnv->CallIntMethod(readableByteChannel, readMethod, byteBuffer);
if (Android_JNI_ExceptionOccurred()) {
return 0;
}
if (result < 0) {
break;
}
bytesRemaining -= result;
bytesRead += result;
ctx->hidden.androidio.position += result;
}
return bytesRead / size;
}
}
void mark(refObject object)
{ refNode P0 = r(P3);
refNode P1 = toRefNode(object);
refNode P2;
int S;
if (P1 != nil)
{ while (P1 != r(P3))
{ S = state(P1);
if (S < degree(P1))
{ state(P1) += 1;
P2 = refs(P1)[S];
if (P2 != nil && state(P2) == 0)
{ refs(P1)[S] = P0;
P0 = P1;
P1 = P2; }}
else
{ state(P1) = 0x7F;
S = state(P0) - 1;
P2 = refs(P0)[S];
refs(P0)[S] = P1;
P1 = P0;
P0 = P2; }}}}
extern "C" void *SDL_AndroidGetActivity()
{
LocalReferenceHolder refs(__FUNCTION__);
jmethodID mid;
JNIEnv *env = Android_JNI_GetEnv();
if (!refs.init(env)) {
return NULL;
}
// return SDLActivity.getContext();
mid = env->GetStaticMethodID(mActivityClass,
"getContext","()Landroid/content/Context;");
return env->CallStaticObjectMethod(mActivityClass, mid);
}
TEST_F( OpenDDLDefectsTest, Issue20_WrongColorNodeParsing ) {
char token[] = "{0.588235, 0.588235, 0.588235}\n";
size_t len( 0 );
char *end = findEnd( token, len );
Value *data( ddl_nullptr );
Reference *refs( ddl_nullptr );
size_t numRefs( 0 ), numValues( 0 );
Value::ValueType type( Value::ddl_none );
char *in = OpenDDLParser::parseDataList( token, end, type, &data, numValues, &refs, numRefs );
ASSERT_FALSE( ddl_nullptr == in );
ASSERT_FALSE( ddl_nullptr == data );
ASSERT_EQ( 3U, numValues );
delete data;
delete refs;
}
bool ViewFactory::SaveState(IMemento::Pointer memento)
{
// final MultiStatus result = new MultiStatus(PlatformUI.PLUGIN_ID,
// IStatus.OK, WorkbenchMessages.ViewFactory_problemsSavingViews, null);
bool result = true;
QList<IViewReference::Pointer> refs(GetViews());
for (int i = 0; i < refs.size(); i++)
{
IViewDescriptor::Pointer desc = viewReg->Find(refs[i]->GetId());
if (desc->IsRestorable())
{
//for dynamic UI - add the following line to replace subsequent code which is commented out
SaveViewState(memento, refs[i], result);
}
}
return result;
}
void CtcQInterCoreF::contract(IntervalVector& box) {
Array<IntervalVector> refs(list.size());
for (int i=0; i<list.size(); i++) {
try {
boxes[i]=box;
list[i].contract(boxes[i]);
} catch(EmptyBoxException&) {
assert(boxes[i].is_empty());
}
refs.set_ref(i,boxes[i]);
}
box = qinter_coref(refs,q);
if (box.is_empty()) throw EmptyBoxException();
}
void CtcQInter::contract(IntervalVector& box, ContractContext& context) {
Array<IntervalVector> refs(list.size());
for (int i=0; i<list.size(); i++) {
boxes[i]=box;
ContractContext c_context(boxes[i], context);
list[i].contract(boxes[i], c_context);
refs.set_ref(i,boxes[i]);
}
box = qinter(refs,q);
context.prop.update(BoxEvent(box,BoxEvent::CONTRACT));
}
// -----------------------------------------------------------------------------
// CHttpConnHandler::Referencies
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CHttpConnHandler::Referencies()
{
TInt refs( 0 );
__ASSERT_DEBUG( iClientApp, DMPanic( KErrCorrupt ) );
CArrayPtrFlat<CHttpDownload>* downloads =
iClientApp->Downloads();
for( TInt i = 0; i < downloads->Count(); ++i )
{
if( (*downloads)[i]->ConnHandler() == this )
{
++refs;
}
}
return refs;
}
char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) {
if( !isNumeric( *in ) && !isCharacter( *in ) ) {
++in;
}
in = lookForNextToken( in, end );
Value::ValueType type( Value::ddl_none );
size_t arrayLen( 0 );
in = OpenDDLParser::parsePrimitiveDataType( in, end, type, arrayLen );
if( Value::ddl_none != type ) {
// parse a primitive data type
in = lookForNextToken( in, end );
if( *in == Grammar::OpenBracketToken[ 0 ] ) {
Reference *refs( ddl_nullptr );
DataArrayList *dtArrayList( ddl_nullptr );
Value *values( ddl_nullptr );
if( 1 == arrayLen ) {
size_t numRefs( 0 ), numValues( 0 );
in = parseDataList( in, end, type, &values, numValues, &refs, numRefs );
setNodeValues( top(), values );
setNodeReferences( top(), refs );
} else if( arrayLen > 1 ) {
in = parseDataArrayList( in, end, type, &dtArrayList );
setNodeDataArrayList( top(), dtArrayList );
} else {
std::cerr << "0 for array is invalid." << std::endl;
error = true;
}
}
in = lookForNextToken( in, end );
if( *in != '}' ) {
logInvalidTokenError( in, std::string( Grammar::CloseBracketToken ), m_logCallback );
return ddl_nullptr;
} else {
//in++;
}
} else {
// parse a complex data type
in = parseNextNode( in, end );
}
return in;
}
extern "C" const char * SDL_AndroidGetExternalStoragePath()
{
static char *s_AndroidExternalFilesPath = NULL;
if (!s_AndroidExternalFilesPath) {
LocalReferenceHolder refs(__FUNCTION__);
jmethodID mid;
jobject context;
jobject fileObject;
jstring pathString;
const char *path;
JNIEnv *env = Android_JNI_GetEnv();
if (!refs.init(env)) {
return NULL;
}
// context = SDLActivity.getContext();
mid = env->GetStaticMethodID(mActivityClass,
"getContext","()Landroid/content/Context;");
context = env->CallStaticObjectMethod(mActivityClass, mid);
// fileObj = context.getExternalFilesDir();
mid = env->GetMethodID(env->GetObjectClass(context),
"getExternalFilesDir", "(Ljava/lang/String;)Ljava/io/File;");
fileObject = env->CallObjectMethod(context, mid, NULL);
if (!fileObject) {
SDL_SetError("Couldn't get external directory");
return NULL;
}
// path = fileObject.getAbsolutePath();
mid = env->GetMethodID(env->GetObjectClass(fileObject),
"getAbsolutePath", "()Ljava/lang/String;");
pathString = (jstring)env->CallObjectMethod(fileObject, mid);
path = env->GetStringUTFChars(pathString, NULL);
s_AndroidExternalFilesPath = SDL_strdup(path);
env->ReleaseStringUTFChars(pathString, path);
}
return s_AndroidExternalFilesPath;
}
char *OpenDDLParser::parseDataArrayList( char *in, char *end,Value::ValueType type,
DataArrayList **dataArrayList ) {
if ( ddl_nullptr == dataArrayList ) {
return in;
}
*dataArrayList = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
return in;
}
in = lookForNextToken( in, end );
if( *in == Grammar::OpenBracketToken[ 0 ] ) {
++in;
Value *currentValue( ddl_nullptr );
Reference *refs( ddl_nullptr );
DataArrayList *prev( ddl_nullptr ), *currentDataList( ddl_nullptr );
do {
size_t numRefs( 0 ), numValues( 0 );
currentValue = ddl_nullptr;
in = parseDataList( in, end, type, ¤tValue, numValues, &refs, numRefs );
if( ddl_nullptr != currentValue || 0 != numRefs ) {
if( ddl_nullptr == prev ) {
*dataArrayList = createDataArrayList( currentValue, numValues, refs, numRefs );
prev = *dataArrayList;
} else {
currentDataList = createDataArrayList( currentValue, numValues, refs, numRefs );
if( ddl_nullptr != prev ) {
prev->m_next = currentDataList;
prev = currentDataList;
}
}
}
} while( Grammar::CommaSeparator[ 0 ] == *in && in != end );
in = lookForNextToken( in, end );
++in;
}
return in;
}
TEST_P(Test_TensorFlow_nets, MobileNet_SSD)
{
checkBackend();
if ((backend == DNN_BACKEND_INFERENCE_ENGINE && target != DNN_TARGET_CPU) ||
(backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16))
throw SkipTestException("");
std::string netPath = findDataFile("dnn/ssd_mobilenet_v1_coco.pb", false);
std::string netConfig = findDataFile("dnn/ssd_mobilenet_v1_coco.pbtxt", false);
std::string imgPath = findDataFile("dnn/street.png", false);
Mat inp;
resize(imread(imgPath), inp, Size(300, 300));
inp = blobFromImage(inp, 1.0f / 127.5, Size(), Scalar(127.5, 127.5, 127.5), true);
std::vector<String> outNames(3);
outNames[0] = "concat";
outNames[1] = "concat_1";
outNames[2] = "detection_out";
std::vector<Mat> refs(outNames.size());
for (int i = 0; i < outNames.size(); ++i)
{
std::string path = findDataFile("dnn/tensorflow/ssd_mobilenet_v1_coco." + outNames[i] + ".npy", false);
refs[i] = blobFromNPY(path);
}
Net net = readNetFromTensorflow(netPath, netConfig);
net.setPreferableBackend(backend);
net.setPreferableTarget(target);
net.setInput(inp);
std::vector<Mat> output;
net.forward(output, outNames);
normAssert(refs[0].reshape(1, 1), output[0].reshape(1, 1), "", 1e-5, 1.5e-4);
normAssert(refs[1].reshape(1, 1), output[1].reshape(1, 1), "", 1e-5, 3e-4);
normAssertDetections(refs[2], output[2], "", 0.2);
}
// returns a new global reference which needs to be released later
static jobject Android_JNI_GetSystemServiceObject(const char* name)
{
LocalReferenceHolder refs(__FUNCTION__);
JNIEnv* env = Android_JNI_GetEnv();
if (!refs.init(env)) {
return NULL;
}
jstring service = env->NewStringUTF(name);
jmethodID mid;
mid = env->GetStaticMethodID(mActivityClass, "getContext", "()Landroid/content/Context;");
jobject context = env->CallStaticObjectMethod(mActivityClass, mid);
mid = env->GetMethodID(mActivityClass, "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;");
jobject manager = env->CallObjectMethod(context, mid, service);
env->DeleteLocalRef(service);
return manager ? env->NewGlobalRef(manager) : NULL;
}
Data::NmrReference const* Nmr::currentReference()
{
Data::NmrReference const* reference;
QString isotope(currentIsotope());
QString system(m_ui->systemCombo->currentText());
QString method(m_ui->methodCombo->currentText());
Data::NmrReferenceLibrary& library(Data::NmrReferenceLibrary::instance());
QList<Data::NmrReference const*> refs(library.filter(isotope, system, method));
if (refs.size() == 1) {
reference = refs.first();
//qDebug() << "Found reference:";
//reference->dump();
}else {
reference = 0;
//qDebug() << "No reference found for" << isotope << system << method;
}
return reference;
}
void Nmr::on_systemCombo_currentIndexChanged(QString const& text)
{
QString isotope(currentIsotope());
Data::NmrReferenceLibrary& library(Data::NmrReferenceLibrary::instance());
QString method(m_data.method());
QList<Data::NmrReference const*> refs(library.filter(isotope, text, method));
QStringList methods;
QList<Data::NmrReference const*>::iterator iter;
for (iter = refs.begin(); iter != refs.end(); ++iter) {
method = (*iter)->method();
if (!methods.contains(method)) methods.append(method);
}
QComboBox* combo(m_ui->methodCombo);
combo->clear();
combo->addItems(methods);
loadShifts(currentReference(), isotope);
updatePlot();
}
extern "C" int Android_JNI_FileOpen(SDL_RWops* ctx,
const char* fileName, const char*)
{
LocalReferenceHolder refs(__FUNCTION__);
JNIEnv *mEnv = Android_JNI_GetEnv();
if (!refs.init(mEnv)) {
return -1;
}
if (!ctx) {
return -1;
}
jstring fileNameJString = mEnv->NewStringUTF(fileName);
ctx->hidden.androidio.fileNameRef = mEnv->NewGlobalRef(fileNameJString);
ctx->hidden.androidio.inputStreamRef = NULL;
ctx->hidden.androidio.readableByteChannelRef = NULL;
ctx->hidden.androidio.readMethod = NULL;
return Android_JNI_FileOpen(ctx);
}
extern "C" int SDL_AndroidGetExternalStorageState()
{
LocalReferenceHolder refs(__FUNCTION__);
jmethodID mid;
jclass cls;
jstring stateString;
const char *state;
int stateFlags;
JNIEnv *env = Android_JNI_GetEnv();
if (!refs.init(env)) {
return 0;
}
cls = env->FindClass("android/os/Environment");
mid = env->GetStaticMethodID(cls,
"getExternalStorageState", "()Ljava/lang/String;");
stateString = (jstring)env->CallStaticObjectMethod(cls, mid);
state = env->GetStringUTFChars(stateString, NULL);
// Print an info message so people debugging know the storage state
__android_log_print(ANDROID_LOG_INFO, "SDL", "external storage state: %s", state);
if (SDL_strcmp(state, "mounted") == 0) {
stateFlags = SDL_ANDROID_EXTERNAL_STORAGE_READ |
SDL_ANDROID_EXTERNAL_STORAGE_WRITE;
} else if (SDL_strcmp(state, "mounted_ro") == 0) {
stateFlags = SDL_ANDROID_EXTERNAL_STORAGE_READ;
} else {
stateFlags = 0;
}
env->ReleaseStringUTFChars(stateString, state);
return stateFlags;
}
void
ApplicationTypesWindow::MessageReceived(BMessage* message)
{
switch (message->what) {
case kMsgTypeSelected:
{
int32 index;
if (message->FindInt32("index", &index) == B_OK) {
MimeTypeItem* item = (MimeTypeItem*)fTypeListView->ItemAt(index);
if (item != NULL) {
BMimeType type(item->Type());
_SetType(&type);
} else
_SetType(NULL);
}
break;
}
case kMsgTypeInvoked:
{
int32 index;
if (message->FindInt32("index", &index) == B_OK) {
MimeTypeItem* item = (MimeTypeItem*)fTypeListView->ItemAt(index);
if (item != NULL) {
BMimeType type(item->Type());
entry_ref ref;
if (type.GetAppHint(&ref) == B_OK) {
BMessage refs(B_REFS_RECEIVED);
refs.AddRef("refs", &ref);
be_app->PostMessage(&refs);
}
}
}
break;
}
case kMsgEdit:
fTypeListView->Invoke();
break;
case kMsgRemoveUninstalled:
_RemoveUninstalled();
break;
case B_META_MIME_CHANGED:
{
const char* type;
int32 which;
if (message->FindString("be:type", &type) != B_OK
|| message->FindInt32("be:which", &which) != B_OK) {
break;
}
if (fCurrentType.Type() == NULL)
break;
if (!strcasecmp(fCurrentType.Type(), type)) {
if (which != B_MIME_TYPE_DELETED)
_SetType(&fCurrentType, which);
else
_SetType(NULL);
}
break;
}
default:
BWindow::MessageReceived(message);
}
}
void WatcherData::perform(void* thread)
{
WatcherData* watcher = static_cast<WatcherData*>(thread);
std::unique_lock<std::mutex> locker(watcher->mutex);
if (watcher->flags & Stop) {
if (watcher->fss) {
FSEventStreamStop(watcher->fss);
FSEventStreamInvalidate(watcher->fss);
}
CFRunLoopSourceInvalidate(watcher->source);
CFRunLoopStop(watcher->loop);
return;
} else if (watcher->flags & Clear) {
watcher->flags &= ~Clear;
if (watcher->fss) {
FSEventStreamStop(watcher->fss);
FSEventStreamInvalidate(watcher->fss);
watcher->fss = 0;
}
// We might have paths added since the clear operation was inititated
if (watcher->paths.empty())
return;
}
// ### might make sense to have multiple streams instead of recreating one for each change
// ### and then merge them if the stream count reaches a given treshold
const int pathSize = watcher->paths.size();
FSEventStreamRef newfss = 0;
if (pathSize) {
StackBuffer<1024, CFStringRef> refs(pathSize);
int i = 0;
const Set<Path> copy = watcher->paths;
for (const Path &path : copy) {
refs[i++] = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault,
path.constData(),
kCFStringEncodingUTF8,
kCFAllocatorNull);
}
// don't need to hold the mutex beyond this point
locker.unlock();
CFArrayRef list = CFArrayCreate(kCFAllocatorDefault,
reinterpret_cast<const void**>(&refs[0]),
pathSize,
&kCFTypeArrayCallBacks);
for (int j = 0; j < i; ++j)
CFRelease(refs[j]);
FSEventStreamContext ctx = { 0, watcher, 0, 0, 0 };
newfss = FSEventStreamCreate(kCFAllocatorDefault,
notifyCallback,
&ctx,
list,
watcher->since,
.1,
kFSEventStreamCreateFlagIgnoreSelf
| kFSEventStreamCreateFlagFileEvents
);
CFRelease(list);
}
if (!newfss)
return;
if (watcher->fss) {
FSEventStreamStop(watcher->fss);
FSEventStreamInvalidate(watcher->fss);
}
watcher->fss = newfss;
FSEventStreamScheduleWithRunLoop(watcher->fss, watcher->loop, kCFRunLoopDefaultMode);
FSEventStreamStart(watcher->fss);
}
void reclaimSizedHunks()
{ int count;
refHunk lastHunk;
refHeap nextHeap;
refHunk nextHunk;
refFrame nextFrame;
refRefObject refsStart;
int size;
int total;
// Mark protected global variables.
mark(bases);
mark(cellSimple);
mark(characterZero);
mark(countName);
mark(emptyAlts);
mark(emptyClosure);
mark(emptyString);
mark(fakeCall);
mark(firstProc);
mark(formCall);
mark(integerOne);
mark(integerMinusOne);
mark(integerZero);
mark(lastProc);
mark(layers);
mark(linkName);
mark(markable);
mark(markingName);
mark(toRefObject(matches));
mark(nullSimple);
mark(plainLayer);
mark(realZero);
mark(resultName);
mark(rowChar0);
mark(rowRowChar0);
mark(rowVoid);
mark(rowVoidExternal);
mark(skolemLayer);
mark(symNoName);
mark(typeExeJoker);
mark(typeFojJoker);
mark(typeMutJoker);
mark(typeObjJoker);
mark(typeTypeObjJoker);
mark(typeSymNoName);
mark(typeVoid);
mark(typeTypeVoid);
mark(vajJoker);
mark(voidExternal);
// Mark stack frames.
nextFrame = frames;
while (nextFrame != nil)
{ count = count(nextFrame);
refsStart = refs(nextFrame);
while (count > 0)
{ mark(d(refsStart));
count -= 1;
refsStart += 1; }
nextFrame = link(nextFrame); }
// Make a pass through the chain of heaps, looking at every hunk. If we find a
// hunk whose TAG is HUNK TAG, then we skip it, because it's already in a free
// list somewhere. If we find a marked hunk, then we simply unmark it, because
// it's still in use. If we find an unmarked hunk, then it's not in use, so we
// reset its TAG to HUNK TAG, and add it to the appropriate free list in SIZED
// HUNKS.
total = 0;
nextHeap = heaps;
while (nextHeap != nil)
{ nextHunk = toRefHunk(hunks(nextHeap) + hunkSize);
lastHunk = r(lastHunk(nextHeap));
while (nextHunk != lastHunk)
{ if (isHunk(nextHunk))
{ nextHunk = toRefHunk(toRefChar(nextHunk) + space(nextHunk)); }
else
{ size = size(nextHunk);
if (state(nextHunk) == 0)
{ tag(nextHunk) = hunkTag;
space(nextHunk) = size;
next(nextHunk) = sizedHunks[size];
sizedHunks[size] = nextHunk;
total += size; }
else
{ state(nextHunk) = 0; }
nextHunk = toRefHunk(toRefChar(nextHunk) + size); }}
nextHeap = next(nextHeap); }
// Write optional debugging information.
if (maxDebugLevel >= 0)
{ fprintf(stream(debug), "[0] Reclaimed %i bytes\n", total); }}
