Пример #1
0
KLF_EXPORT KLFSysInfo::BatteryInfo _klf_linux_battery_info(bool want_info_onbatterypower)
{
  KLFSysInfo::BatteryInfo info;

  if (!QFile::exists(SYSINFO_FILE)) {
    info.islaptop = false;
    info.onbatterypower = false;
    return info;
  }

  if (want_info_onbatterypower) {
    QFile file(SYSINFO_FILE);
    if (!file.open(QIODevice::ReadOnly)) {
      klfWarning("Can't open file "<<SYSINFO_FILE);
      return info;
    }
    QTextStream tstr(&file);

    int val;
    tstr >> val;
    // val == 1 -> power online
    // val == 0 -> on battery power
    info.onbatterypower = ! (bool)val;
  }

  info.islaptop = true;

  return info;
}
Пример #2
0
// !!UNC
static LPTSTR translate( LPCTSTR path, TCHAR *buffer )
{
	TCHAR *l = host_drive_list;
	const TCHAR *p = path;

	while(*l) {
		if(_totupper(p[1]) == _totupper(*l)) break;
		l += _tcslen(l) + 1;
	}

	if(p[0] == TEXT('\\') && *l && (p[2] == 0 || p[2] == TEXT(':') || p[2] == TEXT('\\'))) {
		p += 2;
		if(*p == TEXT(':')) p++;
		if(*p == TEXT('\\')) p++;
		_sntprintf( buffer, MAX_PATH_LENGTH, TEXT("%c:\\%s"), *l, p );
	} else {
		if(*path == TEXT('\\')) {
			_sntprintf( buffer, MAX_PATH_LENGTH, TEXT("%s%s"), virtual_root, path );
		} else {
			int len = _tcslen(path);
			if(len == 0 || path[len-1] == TEXT('\\')) {
				make_mask( buffer, virtual_root, path, tstr(my_computer).get() );
			} else {
				make_mask( buffer, virtual_root, path, 0 );
			}
		}
	}
	charset_mac2host( buffer );

	return buffer;
}
Пример #3
0
int my_remove( const char *path )
{
	DISABLE_ERRORS;
	auto tpath = tstr(path);
	LPTSTR p = MRP(tpath.get());
	strip_trailing_bs(p);
	int result;
	if(is_dir(p)) {
		result = myRemoveDirectory( p );
	} else {
		D(bug(TEXT("DeleteFile %s\n"), p));
		result = DeleteFile( p );
	}
	if(result) {
		result = 0;
		my_errno = 0;
	} else {
		result = -1;
		if(exists(p)) {
			my_errno = EACCES;
		} else {
			my_errno = ENOENT;
		}
	}
	D(bug(TEXT("remove(%s,%s) = %d\n"), tpath.get(), p, result));
	RESTORE_ERRORS;
	return result;
}
Пример #4
0
// Exported hook functions
int my_stat( const char *path, struct my_stat *st )
{
	DISABLE_ERRORS;

	auto tpath = tstr(path);
	int result;

	if(*tpath.get() == 0) {
		/// virtual root
		memset( st, 0, sizeof(struct my_stat) );
		st->st_mode = _S_IFDIR;
		result = 0;
		my_errno = 0;
	} else {
		result = _tstat( MRP(tpath.get()), (struct _stat *)st );
		if(result < 0) {
			my_errno = errno;
		} else {
			my_errno = 0;
		}
	}

	D(bug(TEXT("stat(%s,%s) = %d\n"), tpath.get(), MRP(tpath.get()), result));
	if(result >= 0) dump_stat( st );
	RESTORE_ERRORS;
	return result;
}
Пример #5
0
int my_open( const char *path, int mode, ... )
{
	DISABLE_ERRORS;
	int result;
	auto tpath = tstr(path);
	LPCTSTR p = MRP(tpath.get());

	// Windows "open" does not handle _O_CREAT and _O_BINARY as it should
	if(mode & _O_CREAT) {
		if(exists(p)) {
			result = _topen( p, mode & ~_O_CREAT );
			D(bug(TEXT("open-nocreat(%s,%s,%d) = %d\n"), tpath.get(), p, mode, result));
		} else {
			result = _tcreat( p, _S_IWRITE|_S_IREAD );
			if(result < 0) {
				make_folders(p);
				result = _tcreat( p, _S_IWRITE|_S_IREAD );
			}
			D(bug(TEXT("open-creat(%s,%s,%d) = %d\n"), tpath.get(), p, mode, result));
		}
	} else {
		result = _topen( p, mode );
		D(bug(TEXT("open(%s,%s,%d) = %d\n"), tpath.get(), p, mode, result));
	}
	if(result < 0) {
		my_errno = errno;
	} else {
		setmode(result, _O_BINARY);
		my_errno = 0;
	}
	RESTORE_ERRORS;
	return result;
}
Пример #6
0
//how states change between various states
void create_states(i64 n, vector<vector<int> >& vtransit )
{
    //states gives us all effective numbers, the last one is n
    vector<string> states;//for each state, empty, a, ab, abc....;
    states.push_back(string());
    string tstr(to_string(n));
    for(unsigned int i = 0; i < tstr.size(); ++i){
        states.push_back(tstr.substr(0,i+1));
    }

    vtransit.clear();
    
    //vtransit tells us how the state changes when we have 
    //some new input
    vtransit.resize(states.size());
    for(unsigned int i = 0; i < vtransit.size(); ++i){
        vtransit[i].resize(states.size(), 0);
    }

    //the last state is not necessary to consider
    for(unsigned int j = 0; j < states.size()-1; ++j){

        i64 n0 = 0;
        if(!states[j].empty())
            n0 = stoll(states[j]);
        n0 *= 10;
        for(unsigned int i = 0; i < 10; ++i){
            i64 num = n0 + i;
            string si(to_string(num));
            int matched = check_states(si, j+1, states);
            ++vtransit[j][matched];
        }
    }
}
TPtrC DeprecatedString::des() const
{
    if (!dataHandle[0]->_isUnicodeValid)
        dataHandle[0]->makeUnicode();

    TPtrC tstr((const TUint16*)unicode(), length() );

    return tstr;
}
Пример #8
0
int MessageOut(HWND hWnd,long strMsg, long strTitle, UINT mbstatus)
{
	CString tstr("");
	CString mstr("");
	VERIFY(tstr.LoadString(strTitle));
	VERIFY(mstr.LoadString(strMsg));

	return ::MessageBox(hWnd,mstr,tstr,mbstatus);
}
Пример #9
0
int my_rename( const char *old_path, const char *new_path )
{
	DISABLE_ERRORS;
	int result = -1;
	auto told_path = tstr(old_path);
	auto tnew_path = tstr(new_path);
	LPCTSTR p_old = MRP(told_path.get());
	LPCTSTR p_new = MRP2(tnew_path.get());

	result = my_access(old_path,0);
	if(result < 0) {
		// my_errno already set
	} else {
		if(is_same_drive(p_old,p_new)) {
			result = _trename( p_old, p_new );
			if(result != 0) { // by definition, rename may also return a positive value to indicate an error
				my_errno = errno;
			} else {
				my_errno = 0;
			}
		} else {
			if(is_dir(p_old)) {
				result = folder_copy( p_old, p_new );
				// my_errno already set
				if(result >= 0) {
					if(myRemoveDirectory( p_old )) {
						my_errno = 0;
						result = 0;
					} else {
						// there is no proper error code for this failure.
						my_errno = EACCES;
						result = -1;
					}
				}
			} else {
				result = file_move( p_old, p_new );
				// my_errno already set
			}
		}
	}
	D(bug(TEXT("rename(%s,%s,%s,%s) = %d\n"), told_path.get(), p_old, tnew_path.get(), p_new, result));
	RESTORE_ERRORS;
	return result;
}
Пример #10
0
int main(int argc, const char * argv[]) {
    CHString *str = tstr("r346457");
    id obj = dynamic_cast<id>(str);
    str = obj->description();
    CHLog("%p@", str);
    arc_ptr<CHMutableString> arc((CHMutableString *)str);
    arc_ptr<CHString> arc2;
    arc2 = arc;
    return 0;
}
Пример #11
0
int MessageOut(HWND hWnd, long strMsg, long strTitle, UINT mbstatus, long val1, long val2)
{
	CString tstr("");
	CString mstr("");
	CString fstr("");
	VERIFY(tstr.LoadString(strTitle));
	VERIFY(mstr.LoadString(strMsg));
	fstr.Format(mstr,val1,val2);

	return ::MessageBox(hWnd,fstr,tstr,mbstatus);
}
Пример #12
0
static int lua_peekstr(lua_State *L)
{
    lua::state st(L);
    char *buf;
    buf=new char[256];
    peekstr(st.as<size_t>(1),buf,256);
    std::string tstr(buf);
    st.push(tstr);
    delete [] buf;
    return 1;
}
    void Java_org_cocos2dx_cpp_FacebookConnectPlugin_nativeCallback(JNIEnv*  env, jobject thiz, jint cbIndex,jstring params)
    {
        
        if (params != NULL)
		{
			const char* str;
        	str = env->GetStringUTFChars(params, 0);
        	std::string tstr(str);
			HelloWorld::CallFunctionName(cbIndex,tstr);
		}
		else
		{
			std::string tstr = "";
			HelloWorld::CallFunctionName(cbIndex,tstr);
		}
    }
Пример #14
0
std::string FileInfo::linksTo()
{
#if EFSW_PLATFORM != EFSW_PLATFORM_WIN32
	if ( isLink() )
	{
		char * ch = realpath( Filepath.c_str(), NULL);

		std::string tstr( ch );

		free( ch );

		return tstr;
	}
#endif
	return std::string("");
}
Пример #15
0
int constant(LVALUE *lval)
{
        constype=CINT;
        conssign=dosigned;
        lval->is_const = 1 ;            /* assume constant will be found */
        if ( fnumber(&lval->const_val) ) {
                lval->val_type=DOUBLE;
		if ( doublestrings ) {
		    immedlit(litlab);
		    outdec(lval->const_val); nl();
		    callrts("__atof2");
                    WriteDefined("math_atof",1);
		} else {
		    immedlit(dublab);
		    outdec(lval->const_val); nl();
		    callrts("dload");
		}
                lval->is_const = 0 ;                    /*  floating point not constant */
                lval->flags=0;
                return(1);
        }
        else if ( number(&lval->const_val) || pstr(&lval->const_val) ) {
/* Insert long stuff/long pointer here? */
		if ( (unsigned long )lval->const_val >= 65536LU )
			constype = LONG;

                lval->val_type = constype ;
                lval->flags = (lval->flags&MKSIGN)|conssign;
                if (constype == LONG) vlongconst(lval->const_val);
                else vconst(lval->const_val);
                return(1);
        }
        else if ( tstr(&lval->const_val) ) {
                lval->is_const = 0 ;                    /* string address not constant */
                lval->ptr_type=CCHAR;   /* djm 9/3/99 */
                lval->val_type=CINT;
                lval->flags=0;
                immedlit(litlab);
        }
        else {
                lval->is_const = 0 ;
                return(0);       
        }
        outdec(lval->const_val);
        nl();
        return(1);
}
Пример #16
0
int my_access( const char *path, int mode )
{
	DISABLE_ERRORS;
	auto tpath = tstr(path);
	LPCTSTR p = MRP(tpath.get());
	WIN32_FIND_DATA fdata;

	int result;

	if(is_dir(p)) {
		// access does not work for folders.
		HANDLE h = FindFirstFile( p, &fdata );
		if(h != INVALID_HANDLE_VALUE) {
			FindClose( h );
			if(mode == W_OK) {
				if( (fdata.dwFileAttributes & FILE_ATTRIBUTE_READONLY) == 0 ) {
					result = 0;
					my_errno = 0;
				} else {
					result = -1;
					my_errno = EACCES;
				}
			} else {
				result = 0;
				my_errno = 0;
			}
		} else {
			result = -1;
			my_errno = ENOENT;
		}
	} else {
		// W_OK, F_OK are ok.
		result = _taccess(p,mode);
		if(result < 0) {
			my_errno = errno;
		} else {
			my_errno = 0;
		}
	}

	D(bug(TEXT("access(%s,%s,%d) = %d\n"), tpath.get(), p, mode, result));
	RESTORE_ERRORS;
	return result;
}
Пример #17
0
int my_mkdir( const char *path, int mode )
{
	DISABLE_ERRORS;
	auto tpath = tstr(path);
	LPTSTR p = MRP(tpath.get());
	strip_trailing_bs(p);
	int result = _tmkdir( p );
	if(result < 0) {
		make_folders(p);
		result = _tmkdir( p );
	}
	if(result < 0) {
		my_errno = errno;
	} else {
		my_errno = 0;
	}
	D(bug(TEXT("mkdir(%s,%s,%d) = %d\n"), tpath.get(), p, mode, result));
	RESTORE_ERRORS;
	return result;
}
Пример #18
0
int my_creat( const char *path, int mode )
{
	DISABLE_ERRORS;
	auto tpath = tstr(path);
	LPCTSTR p = MRP(tpath.get());
	int result = _tcreat( p, _S_IWRITE|_S_IREAD ); // note mode
	if(result < 0) {
		make_folders(p);
		result = _tcreat( p, _S_IWRITE|_S_IREAD ); // note mode
	}
	if(result < 0) {
		my_errno = errno;
	} else {
		setmode(result, _O_BINARY);
		my_errno = 0;
	}
	D(bug(TEXT("creat(%s,%s,%d) = %d\n"), tpath.get(), p, mode,result));
	RESTORE_ERRORS;
	return result;
}
Пример #19
0
int main()
{
    QString folder("C:\\Users\\Gigotdarnaud\\Desktop\\CircleTexturesHD");
    QString outFolder("C:\\Users\\Gigotdarnaud\\Desktop\\CircleTexturesHD\\OUT");

    QDir dir (folder);
    QStringList filters; filters << "*.bmp" << "*.png" << "*.jpg" << "*.tiff";
    QStringList ls=dir.entryList(filters, QDir::Files|QDir::NoDotAndDotDot);

    QFile file(outFolder+'/'+"filelist.list");
    file.open(QIODevice::WriteOnly|QIODevice::Text);
    QTextStream tstr(&file);

    int c=0;
    for(int i=0, m=ls.size();i<m;++i)
    {
        c+=splitImage(folder+'/'+ls[i], outFolder, tstr,c);
    }

    return 0;
}
Пример #20
0
QoreStringNode *RegexTransNode::exec(const QoreString *str, ExceptionSink *xsink) const {
   //printd(5, "source='%s' target='%s' ('%s')\n", source->getBuffer(), target->getBuffer(), str->getBuffer());
   TempEncodingHelper tstr(str, QCS_DEFAULT, xsink);
   if (*xsink)
      return 0;

   QoreStringNode *ns = new QoreStringNode;
   for (qore_size_t i = 0; i < tstr->strlen(); i++) {
      char c = tstr->getBuffer()[i];
      const char *p = strchr(source->getBuffer(), c);
      if (p) {
	 qore_size_t pos = p - source->getBuffer();
	 if (target->strlen() <= pos)
	    pos = target->strlen() - 1;
	 ns->concat(target->getBuffer()[pos]);
      }
      else
	 ns->concat(c);
   }

   return ns;
}
bool check_scrabble_missed(ScrabbleTst& tst, ScrabbleTst& found, int jokers)
{
	typedef std::pair<std::string::iterator, std::string::iterator> MissPair;
	for (ScrabbleTst::iterator A = tst.begin(); A != tst.end(); ++A)
	{
		std::string tstr(A.key());
		std::sort(tstr.begin(), tstr.end());
		if (found.find(tstr) != found.end())
			continue;
		for (ScrabbleTst::iterator B = found.begin(); B != found.end(); ++B)
		{
			if (tstr.size() > B.key().size())
				continue;
			++scrabble_testcount;
			std::string fs(B.key());
			MissPair miss = std::mismatch(fs.begin(), fs.end(), tstr.begin());
			if (miss.first == fs.end() && miss.second == tstr.end()) {
				std::cout << "SCRABBLE(" << jokers << "): " << tstr << " not found by " << fs << "\n";
				return false;
			}
		}
	}
	return true;
}
Пример #22
0
struct DIR *opendir( const char *path )
{
	DISABLE_ERRORS;
	auto tpath = tstr(path);
	DIR *d = new DIR;
	if(d) {
		memset( d, 0, sizeof(DIR) );
		if(*tpath.get() == 0) {
			d->vname_list = host_drive_list;
			if(d->vname_list) {
				d->h = VIRTUAL_ROOT_ID;
				_tcscpy( d->FindFileData.cFileName, d->vname_list );
				d->FindFileData.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
			} else {
				d->h = INVALID_HANDLE_VALUE;
			}
		} else {
			TCHAR mask[MAX_PATH_LENGTH];
			make_mask( mask, MRP(tpath.get()), TEXT("*.*"), 0 );

			D(bug(TEXT("opendir path=%s, mask=%s\n"), tpath.get(), mask));

			d->h = FindFirstFile( mask, &d->FindFileData );
			if(d->h == INVALID_HANDLE_VALUE) {
				delete d;
				d = 0;
			}
		}
	}

	D(bug(TEXT("opendir(%s,%s) = %08x\n"), tpath.get(), MRP(tpath.get()), d));

	RESTORE_ERRORS;

	return d;
}
Пример #23
0
bool ether_init(void)
{
	TCHAR buf[256];

	// Do nothing if no Ethernet device specified
	const char *name = PrefsFindString("ether");
	if (name == NULL)
		return false;

	ether_multi_mode = PrefsFindInt32("ethermulticastmode");
	ether_use_permanent = PrefsFindBool("etherpermanentaddress");

	// Determine Ethernet device type
	net_if_type = -1;
	if (PrefsFindBool("routerenabled") || strcmp(name, "router") == 0)
		net_if_type = NET_IF_ROUTER;
	else if (strcmp(name, "slirp") == 0)
		net_if_type = NET_IF_SLIRP;
	else if (strcmp(name, "tap") == 0)
		net_if_type = NET_IF_TAP;
	else
		net_if_type = NET_IF_B2ETHER;

	// Initialize NAT-Router
	if (net_if_type == NET_IF_ROUTER) {
		if (!router_init())
			net_if_type = NET_IF_FAKE;
	}

	// Initialize slirp library
	if (net_if_type == NET_IF_SLIRP) {
		if (slirp_init() < 0) {
			WarningAlert(GetString(STR_SLIRP_NO_DNS_FOUND_WARN));
			return false;
		}
	}

	// Open ethernet device
	decltype(tstr(std::declval<const char*>())) dev_name;
	switch (net_if_type) {
	case NET_IF_B2ETHER:
		dev_name = tstr(PrefsFindString("etherguid"));
		if (dev_name == NULL || strcmp(name, "b2ether") != 0)
			dev_name = tstr(name);
		break;
	case NET_IF_TAP:
		dev_name = tstr(PrefsFindString("etherguid"));
		break;
	}
	if (net_if_type == NET_IF_B2ETHER) {
		if (dev_name == NULL) {
			WarningAlert("No ethernet device GUID specified. Ethernet is not available.");
			goto open_error;
		}

		fd = PacketOpenAdapter( dev_name.get(), ether_multi_mode );
		if (!fd) {
			_sntprintf(buf, lengthof(buf), TEXT("Could not open ethernet adapter %s."), dev_name.get());
			WarningAlert(buf);
			goto open_error;
		}

		// Get Ethernet address
		if(!PacketGetMAC(fd,ether_addr,ether_use_permanent)) {
			_sntprintf(buf, lengthof(buf), TEXT("Could not get hardware address of device %s. Ethernet is not available."), dev_name.get());
			WarningAlert(buf);
			goto open_error;
		}
		D(bug("Real ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));

		const char *ether_fake_address;
		ether_fake_address = PrefsFindString("etherfakeaddress");
		if(ether_fake_address && strlen(ether_fake_address) == 12) {
			char sm[10];
			strcpy( sm, "0x00" );
			for( int i=0; i<6; i++ ) {
				sm[2] = ether_fake_address[i*2];
				sm[3] = ether_fake_address[i*2+1];
				ether_addr[i] = (uint8)strtoul(sm,0,0);
			}
			D(bug("Fake ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));
		}
	}
	else if (net_if_type == NET_IF_TAP) {
		if (dev_name == NULL) {
			WarningAlert("No ethernet device GUID specified. Ethernet is not available.");
			goto open_error;
		}

		fd = tap_open_adapter(dev_name.get());
		if (!fd) {
			_sntprintf(buf, lengthof(buf), TEXT("Could not open ethernet adapter %s."), dev_name.get());
			WarningAlert(buf);
			goto open_error;
		}

		if (!tap_check_version(fd)) {
			_sntprintf(buf, lengthof(buf), TEXT("Minimal TAP-Win32 version supported is %d.%d."), TAP_VERSION_MIN_MAJOR, TAP_VERSION_MIN_MINOR);
			WarningAlert(buf);
			goto open_error;
		}

		if (!tap_set_status(fd, true)) {
			WarningAlert("Could not set media status to connected.");
			goto open_error;
		}

		if (!tap_get_mac(fd, ether_addr)) {
			_sntprintf(buf, lengthof(buf), TEXT("Could not get hardware address of device %s. Ethernet is not available."), dev_name.get());
			WarningAlert(buf);
			goto open_error;
		}
		D(bug("Real ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));

		const char *ether_fake_address;
		ether_fake_address = PrefsFindString("etherfakeaddress");
		if (ether_fake_address && strlen(ether_fake_address) == 12) {
			char sm[10];
			strcpy( sm, "0x00" );
			for( int i=0; i<6; i++ ) {
				sm[2] = ether_fake_address[i*2];
				sm[3] = ether_fake_address[i*2+1];
				ether_addr[i] = (uint8)strtoul(sm,0,0);
			}
		}
#if 1
		/*
		  If we bridge the underlying ethernet connection and the TAP
		  device altogether, we have to use a fake address.
		 */
		else {
			ether_addr[0] = 0x52;
			ether_addr[1] = 0x54;
			ether_addr[2] = 0x00;
		}
#endif
		D(bug("Fake ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));
	}
	else if (net_if_type == NET_IF_SLIRP) {
		ether_addr[0] = 0x52;
		ether_addr[1] = 0x54;
		ether_addr[2] = 0x00;
		ether_addr[3] = 0x12;
		ether_addr[4] = 0x34;
		ether_addr[5] = 0x56;
		D(bug("Ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));
	}
	else {
		memcpy( ether_addr, router_mac_addr, 6 );
		D(bug("Fake ethernet address (same as router) %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));
	}

	// Start packet reception thread
	int_ack = CreateSemaphore( 0, 0, 1, NULL);
	if(!int_ack) {
		WarningAlert("WARNING: Cannot create int_ack semaphore");
		goto open_error;
	}

	// nonsignaled
	int_sig = CreateSemaphore( 0, 0, 1, NULL);
	if(!int_sig) {
		WarningAlert("WARNING: Cannot create int_sig semaphore");
		goto open_error;
	}

	int_sig2 = CreateSemaphore( 0, 0, 1, NULL);
	if(!int_sig2) {
		WarningAlert("WARNING: Cannot create int_sig2 semaphore");
		goto open_error;
	}

	int_send_now = CreateSemaphore( 0, 0, 1, NULL);
	if(!int_send_now) {
		WarningAlert("WARNING: Cannot create int_send_now semaphore");
		goto open_error;
	}

	init_queue();

	if(!allocate_read_packets()) goto open_error;

	// No need to enter wait state if we can avoid it.
	// These all terminate fast.

	InitializeCriticalSectionAndSpinCount( &fetch_csection, 5000 );
	InitializeCriticalSectionAndSpinCount( &queue_csection, 5000 );
	InitializeCriticalSectionAndSpinCount( &send_csection, 5000 );
	InitializeCriticalSectionAndSpinCount( &wpool_csection, 5000 );

	ether_th = (HANDLE)_beginthreadex( 0, 0, ether_thread_feed_int, 0, 0, &ether_tid );
	if (!ether_th) {
		D(bug("Failed to create ethernet thread\n"));
		goto open_error;
	}
	thread_active = true;

	unsigned int dummy;
	unsigned int (WINAPI *receive_func)(void *);
	switch (net_if_type) {
	case NET_IF_SLIRP:
	  receive_func = slirp_receive_func;
	  break;
	default:
	  receive_func = ether_thread_get_packets_nt;
	  break;
	}
	ether_th2 = (HANDLE)_beginthreadex( 0, 0, receive_func, 0, 0, &dummy );
	ether_th1 = (HANDLE)_beginthreadex( 0, 0, ether_thread_write_packets, 0, 0, &dummy );

	// Everything OK
	return true;

 open_error:
	if (thread_active) {
		TerminateThread(ether_th,0);
		ether_th = 0;
		if (int_ack)
			CloseHandle(int_ack);
		int_ack = 0;
		if(int_sig)
			CloseHandle(int_sig);
		int_sig = 0;
		if(int_sig2)
			CloseHandle(int_sig2);
		int_sig2 = 0;
		if(int_send_now)
			CloseHandle(int_send_now);
		int_send_now = 0;
		thread_active = false;
	}
	if (fd) {
		switch (net_if_type) {
		case NET_IF_B2ETHER:
			PacketCloseAdapter(fd);
			break;
		case NET_IF_TAP:
			tap_close_adapter(fd);
			break;
		}
		fd = 0;
	}
	return false;
}
Пример #24
0
void
Win::LoadInterfaceGraphics()
{
	//cout << "Win::LoadInterfaceGraphics()" << endl;
	
	bool dir_exists = true;
	BString dirstr( "/boot/home/config/settings/Themis/interface/" );
	BDirectory dir( dirstr.String() );
	if( dir.InitCheck() != B_OK )
	{
		dir_exists = false;
		//cout << "/boot/home/config/settings/Themis/interface/ does not exist" << endl;
	}
	
	// load the icons either from bitmap-file or if not present, from internal
	// icon hexdumps located in "ThemisIcons.h"
	
	// initialize all bitmaps with NULL
	for( int i=0; i < 10; i++ )
		bitmaps[i] = NULL;
	
	// the array with file-names
	const char* names[9];
	// 4-pic bitmap
	names[0] = "button_back.png";
	names[1] = "button_forward.png";
	names[2] = "button_stop.png";
	names[3] = "button_home.png";
	names[4] = "button_newtab.png";
	// 3-pic bitmap
	names[5] = "button_reload.png";
	names[6] = "button_go.png";
	names[7] = "button_closetabview.png";
	// 1-pic bitmap
	names[8] = "icon_document.png";
	names[9] = "icon_document_empty.png";
	
	// the array with pointers to the hexdumps
	const unsigned char* hexp[10];
	// 4-pic bitmap
	hexp[0] = button_back_hex;
	hexp[1] = button_forward_hex;
	hexp[2] = button_stop_hex;
	hexp[3] = button_home_hex;
	hexp[4] = button_newtab_hex;
	// 3-pic bitmap
	hexp[5] = button_reload_hex;
	hexp[6] = button_go_hex;
	hexp[7] = button_closetabview_hex;
	// 1-pic bitmap
	hexp[8] = icon_document_hex;
	hexp[9] = icon_document_empty_hex;
	
	// a tempstring :D
	// ( i had to move this below the 2 char arrays .. otherwise i got a
	// seqm viol. and tstr was initialized with hexp[9] ..
	// dunno if i did some very lousy coding mistakes or if sth is playing me a trick )
	BString tstr( dirstr.String() );
		
	for( int i = 0; i < 10; i++ )
	{
		//cout << "bitmap " << i << ": ";
		if( dir_exists == true )
		{
			//cout << "loading from file" << endl;
			// load from file
			tstr.SetTo( dirstr.String() );
			if( ( bitmaps[i] = BTranslationUtils::GetBitmapFile( ( tstr += names[i] ).String() ) ) == 0 )
				cout << "loading from bitmap-file failed" << endl;
		}
		if( bitmaps[i] == NULL )
		{
			// load from hexdump
			//cout << "loading from hexdump" << endl;
			if( i <= 4 )
			{
				bitmaps[i] = new BBitmap( BRect( 0,0,63,15 ), B_RGB32 );
				memcpy( bitmaps[i]->Bits(), hexp[i], 4096 );
			}
			if( i >= 5 && i <= 7 )
			{
				bitmaps[i] = new BBitmap( BRect( 0,0,47,15 ), B_RGB32 );
				memcpy( bitmaps[i]->Bits(), hexp[i], 3072 );
			}
			if( i == 8 || i == 9 )
			{
				bitmaps[i] = new BBitmap( BRect( 0,0,15,15 ), B_RGB32 );
				memcpy( bitmaps[i]->Bits(), hexp[i], 1024 );
			}
		}
	}
}
Пример #25
0
//=================================================================================================
// Pocz¹tek programu
//=================================================================================================
int main(int argc, char **argv)
{
	setlocale(LC_ALL, "");
	setlocale(LC_NUMERIC, "C");

	if(argc == 1)
	{
		printf("QMSH converter, version %s (output %d).\nUsage: \"converter FILE.qmsh.tmp\". Use \"converter -h\" for list of commands.\n",
			CONVERTER_VERSION, QMSH::VERSION);
		return 0;
	}
	export_phy = false;

	int result = 0;
	bool check_subdir = true, force_update = false;

	for(int i = 1; i < argc; ++i)
	{
		char* cstr = argv[i];

		if(cstr[0] == '-')
		{
			string str(cstr);

			if(str == "-h" || str == "-help" || str == "-?")
			{
				printf("Converter switches:\n"
					"-h/help/? - list of commands\n"
					"-v - show converter version and input file versions\n"
					"-o FILE - output file name\n"
					"-g1 - use single group (default)\n"
					"-gf FILE - use animation groups from file\n"
					"-gcreate - create animation groups and save as file\n"
					"-gcreaten FILE - create animation groups and save as named file\n"
					"-phy - export only physic mesh (default extension .phy)\n"
					"-normal - export normal mesh\n"
					"-info FILE - show information about mesh (version etc)\n"
					"-details OPTIONS FILE - like info but more details\n"
					"-compare FILE FILE2 - compare two meshes and show differences\n"
					"-upgrade FILE - upgrade mesh to newest version\n"
					"-upgradedir DIR - upgrade all meshes in directory and subdirectories\n"
					"-subdir - check subdirectories in upgradedir (default)\n"
					"-nosubdir - don't check subdirectories in upgradedir\n"
					"-force - force upgrade operation\n"
					"-noforce - don't force upgrade operation (default)\n"
					"Parameters without '-' are treated as input file.\n");
			}
			else if(str == "-v")
			{
				printf("Converter version %s\nHandled input file version: %d..%d\nOutput file version: %d\n",
					CONVERTER_VERSION, QmshTmpLoader::QMSH_TMP_HANDLED_VERSION.x, QmshTmpLoader::QMSH_TMP_HANDLED_VERSION.y, QMSH::VERSION);
			}
			else if(str == "-g1")
				gopt = GO_ONE;
			else if(str == "-gf")
			{
				if(i + 1 < argc)
				{
					++i;
					group_file = argv[i];
					gopt = GO_FILE;
				}
				else
					printf("Missing FILE name for '-gf'!\n");
			}
			else if(str == "-gcreate")
			{
				gopt = GO_CREATE;
				group_file.clear();
			}
			else if(str == "-gcreaten")
			{
				if(i + 1 < argc)
				{
					++i;
					group_file = argv[i];
					gopt = GO_CREATE;
				}
				else
					printf("Missing FILE name for '-gcreaten'!\n");
			}
			else if(str == "-o")
			{
				if(i + 1 < argc)
				{
					++i;
					output_file = argv[i];
					force_output = true;
				}
				else
					printf("Missing OUTPUT PATH for '-o'!\n");
			}
			else if(str == "-phy")
				export_phy = true;
			else if(str == "-normal")
				export_phy = false;
			else if(str == "-info")
			{
				if(i + 1 < argc)
				{
					++i;
					Info(argv[i]);
				}
				else
					printf("Missing FILE for '-info'!\n");
			}
			else if(str == "-details")
			{
				if(i + 2 < argc)
				{
					Info(argv[i + 2], argv[i + 1]);
					i += 2;
				}
				else
				{
					printf("Missing OPTIONS or FILE for '-details'!\n");
					++i;
				}
			}
			else if(str == "-compare")
			{
				if(i + 2 < argc)
				{
					Compare(argv[i + 1], argv[i + 2]);
					i += 2;
				}
				else
				{
					printf("Missing FILEs for '-compare'!\n");
					++i;
				}
			}
			else if(str == "-upgrade")
			{
				if(i + 1 < argc)
				{
					++i;
					Upgrade(argv[i], force_update);
				}
				else
					printf("Missing FILE for '-upgrade'!\n");
			}
			else if(str == "-upgradedir")
			{
				if(i + 1 < argc)
				{
					++i;
					UpgradeDir(argv[i], force_update, check_subdir);
				}
				else
					printf("Missing FILE for '-upgradedir'!\n");
			}
			else if(str == "-subdir")
				check_subdir = true;
			else if(str == "-nosubdir")
				check_subdir = false;
			else if(str == "-force")
				force_update = true;
			else if(str == "-noforce")
				force_update = false;
			else
				printf("Unknown switch \"%s\"!\n", cstr);
		}
		else
		{
			string tstr(cstr);
			if(!ConvertToQmsh(tstr))
				result = 1;
			group_file.clear();
			output_file.clear();
			gopt = GO_ONE;
		}
	}

	if(IsDebuggerPresent())
	{
		printf("Press any key to exit...");
		_getch();
	}

	return result;
}
TPtrC8 DeprecatedString::des8() const
{
    TPtrC8 tstr((const TUint8*)latin1(), length());

    return tstr;
}
Пример #27
0
bool IODicom<T>::GetAttributes(PGCore::MetaData<T>& oMetaDataObject, const std::string &iFilePath)
{
#ifdef _DEBUG
    LOG0("{ IODicom::GetAttributes");
#endif

    if (iFilePath.empty())
    {
        LOG0("IO/IODicom::GetAttributes Empty filename");
        return false;
    }

#ifdef _PG_GDDCM_


#else
    OFCondition status = m_fileformat.loadFile(iFilePath.c_str());
    if (!status.good())
    {
        LOG2("IO/IODicom::GetAttributes: Cannot read dicom file %s: (%s).", iFilePath.c_str(), status.text());
        return false;
    }

#ifdef _DEBUG
    LOG2("\tIODicom::GetAttributes: Successfully read dicom file %s: (%s).", iFilePath.c_str(), status.text());
#endif

    // read the meta file here
    //LOG1("IO/IOBase::ReadMetaData: File: %s", iMetaFileName.c_str());

    DcmDataset *dataset = m_fileformat.getDataset();
    if (dataset==NULL)
    {
        return false;
    }

    // patient name
    OFString patientsName;
    bool res = dataset->findAndGetOFString(DCM_PatientsName, patientsName).good();
    if (!res)
    {
        LOG0("IO/IODicom::Read: Cannot fetch patient name");
        return false;
    }
    oMetaDataObject.SetPatientName(std::string(patientsName.c_str()));

#ifdef _DEBUG
    LOG1("\tIODicom::Read: Successfully read PatientName: (%s).", patientsName.c_str());
#endif

    // modality
    OFString modalityStr;
    res = dataset->findAndGetOFString(DCM_Modality, modalityStr).good();
    if (!res)
    {
        LOG0("IO/IODicom::Read: Cannot fetch modality");
        return false;
    }
    PGCore::ePGModality modality = 	PGCore::MetaData<T>::StrToModality(modalityStr.c_str());
    oMetaDataObject.SetModality(modality);
#ifdef _DEBUG
    LOG1("\tIODicom::Read: Successfully read Modality: (%s).", modalityStr.c_str());
#endif



    // SOP Class UID
    OFString sopClassUIDStr;
    DcmMetaInfo *metaInfo = m_fileformat.getMetaInfo();
    if (metaInfo)
    {
        metaInfo->findAndGetOFString(DCM_MediaStorageSOPClassUID, sopClassUIDStr);
        PGCore::ePGSOPClass sopClass = 	PGCore::MetaData<T>::StrToSOPClass(sopClassUIDStr.c_str());
        oMetaDataObject.SetSOPClass(sopClass);


        // DCM_TransferSyntaxUID
        OFString transferSyntaxStr;
        res = metaInfo->findAndGetOFString(DCM_TransferSyntaxUID, transferSyntaxStr).good();
        if (!res)
        {
            LOG0("IO/IODicom::Read:Warning: Cannot fetch TransferSyntaxUID");
        } else
        {

            if (!strcmp(kPgTransferSyntaxUIDRawImplicitVRLittleEndian, transferSyntaxStr.c_str()))
            {

                oMetaDataObject.SetMSBFirst(0);

            } else if (!strcmp(kPgTransferSyntaxUIDRawExplicitVRLittle, transferSyntaxStr.c_str()))
            {

                oMetaDataObject.SetMSBFirst(0);

            } else if (!strcmp(kPgTransferSyntaxUIDRawExplicitVRLittle, transferSyntaxStr.c_str()))
            {

                oMetaDataObject.SetMSBFirst(1);

            } else if (!strcmp(kPgTransferSyntaxUIDLossLessRLE, transferSyntaxStr.c_str()))
            {
                LOG0("IO/IODicom::Read: Cannot read RLE compressed images yet");
                return false;

            } else
            {
                std::string tstr(transferSyntaxStr.c_str());
                std::string filterStr(kPgTransferSyntaxUIDJPEG);
                PGCore::ToUpper(tstr);
                PGCore::ToUpper(filterStr);

                size_t found=tstr.find(filterStr);
                bool isJPEG = (found!=string::npos);
                if (isJPEG)
                {
                    LOG0("IO/IODicom::Read: Cannot read JPEG images yet");
                    return false;
                }
            }
        }
    }

    DcmItem *ditem = OFstatic_cast(DcmItem *, dataset);
    if (!ditem)
    {
        LOG0("IO/IODicom::Read: Cannot fetch ditem");
        return false;
    }

    // Samples Per Pixel
    Uint16 samplesPerPixel = 0;
    res = ditem->findAndGetUint16(DCM_SamplesPerPixel, samplesPerPixel).good();
    if (!res)
    {
        LOG0("IO/IODicom::Read: Warning: Cannot fetch SamplesPerPixel");
    } else if (samplesPerPixel > sizeof(T))
    {
        LOG2("IO/IODicom::Read: Cannot read SamplesPerPixel: %d, target resolution smaller: %d yet", samplesPerPixel, sizeof(T));
        return false;
    }

    oMetaDataObject.SetSamplesPerPixel(samplesPerPixel);


    // DCM_PhotometricInterpretation
    OFString photoInterpretationStr;
    res = metaInfo->findAndGetOFString(DCM_PhotometricInterpretation, photoInterpretationStr).good();
    if (!res)
    {
#ifdef _DEBUG
        LOG0("IO/IODicom::Read:Warning Cannot fetch PhotometricInterpretation");
#endif

    } else if (strcmp(kPgPhotometricRepresentationMChrome2, photoInterpretationStr.c_str()))
    {
#ifdef _DEBUG
        LOG1("IO/IODicom::Read: Cannot read PhotometricInterpretation %s", photoInterpretationStr.c_str());
#endif
        return false;
    }

    // DCM_NumberOfFrames
    long numFrames = 1;
    res = dataset->findAndGetLongInt(DCM_NumberOfFrames, numFrames).good();
    if (!res)
    {
#ifdef _DEBUG
        LOG0("IO/IODicom::Read: Warning: Cannot fetch NumberOfFrames");
#endif
        oMetaDataObject.SetFrameCount(1);
    } else
    {
        oMetaDataObject.SetFrameCount(numFrames);
    }

    // size
    Uint16 imageRows = 0;
    Uint16 imageColumns = 0;
    res = ditem->findAndGetUint16(DCM_Rows, imageRows).good();
    if (!res)
    {
        LOG0("IO/IODicom::Read: Cannot fetch rows");
        return false;
    }
    res = ditem->findAndGetUint16(DCM_Columns, imageColumns).good();
    if (!res)
    {
        LOG0("IO/IODicom::Read: Cannot fetch columns");
        return false;
    }
    oMetaDataObject.SetSize(PGMath::Vector3D<int>(imageColumns, imageRows, 1));
#ifdef _DEBUG
    LOG2("\tIODicom::Read: Size: Rows: %d, Columns: %d", imageRows, imageColumns);
#endif

    // number of bits
    Uint16 imageBitsAllocated = 0;
    res = ditem->findAndGetUint16(DCM_BitsAllocated, imageBitsAllocated).good();
    if (!res)
    {
        LOG0("IO/IODicom::Read: Cannot fetch bits allocated");
        return false;
    }
    oMetaDataObject.SetNumberOfBits(imageBitsAllocated);
#ifdef _DEBUG
    LOG1("\tIODicom::Read: bits allocated: %d", imageBitsAllocated);
#endif

    // spacing
    Float64 sx=1, sy=1;
    DcmElement *elem = 0;
    OFCondition	cond = dataset->findAndGetElement(DCM_PixelSpacing, elem);
    if(!cond.good())
    {
        LOG1("IO/IODicom::Read:Warning Cannot fetch pixel spacing (%s)", cond.text());
    } else
    {
        cond = elem->getFloat64(sx, 0);
        if(!cond.good())
        {
            LOG1("IO/IODicom::Read:Warning Cannot fetch pixel X spacing (%s)", cond.text());
        }
        cond = elem->getFloat64(sy, 1);
        if(!cond.good())
        {
            LOG1("IO/IODicom::Read:Warning Cannot fetch pixel Y spacing (%s)", cond.text());
        }
    }

    if (sx!=sy)
    {
        LOG2("IO/IODicom::Read:Warning: X/Y spacings (%3.2f, %3.2f) mismatch. Ignoring anisotrpy", sx, sy);
        sy = sx;
    }

#ifdef _DEBUG
    LOG2("\tIODicom::Read: pixel X and Y spacings (%3.5f %3.5f)",sx, sy);
#endif

    oMetaDataObject.SetSpacing(PGMath::Vector3D<float>(sx, sy, 1));

    // STUDY UID
    OFString studyUIDStr;
    res = dataset->findAndGetOFString(DCM_StudyInstanceUID, studyUIDStr).good();
    if (!res)
    {
        LOG0("IO/IODicom::Read:Warning Cannot fetch StudyUID");
    } else
    {
        oMetaDataObject.SetStudyUID(std::string(studyUIDStr.c_str()));
    }

    // series UID
    OFString seriesUIDStr;
    res = dataset->findAndGetOFString(DCM_SeriesInstanceUID, seriesUIDStr).good();
    if (!res)
    {
        LOG0("IO/IODicom::Read:Warning Cannot fetch seriesUID");
    } else
    {
        oMetaDataObject.SetSeriesUID(std::string(seriesUIDStr.c_str()));
        //LOG1("IO/IODicom::Read:seriesUID : %s", oMetaDataObject.GetSeriesUID().c_str());
    }


    // orientation
    Float64 rowOr[3] = { 1.0f, 0.0f, 0.0f }, colOr[3] = { 0.0f, 1.0f, 0.0f };
    std::vector<PGMath::Vector3D<float> > orXs;
    std::vector<PGMath::Vector3D<float> > orYs;
    cond = dataset->findAndGetElement(DCM_ImageOrientationPatient, elem);
    if(!cond.good())
    {
        LOG1("IO/IODicom::Read:Warning Cannot fetch DCM_ImageOrientationPatient (%s)", cond.text());
    } else
    {
        elem->getFloat64(rowOr[0], 0);
        elem->getFloat64(rowOr[1], 1);
        elem->getFloat64(rowOr[2], 2);
        elem->getFloat64(colOr[0], 3);
        elem->getFloat64(colOr[1], 4);
        elem->getFloat64(colOr[2], 5);
    }

    orXs.push_back(PGMath::Vector3D<float>(rowOr[0], rowOr[1], rowOr[2]));
    oMetaDataObject.SetImageOrientationsPatientX(orXs);
#ifdef _DEBUG
    LOG3("\tIODicom::Read: Image Row vector orientation (%3.5f %3.5f %3.5f)", rowOr[0], rowOr[1], rowOr[2]);
#endif
    orYs.push_back(PGMath::Vector3D<float>(colOr[0], colOr[1], colOr[2]));
    oMetaDataObject.SetImageOrientationsPatientY(orYs);
#ifdef _DEBUG
    LOG3("\tIODicom::Read: Image Col vector orientation (%3.5f %3.5f %3.5f)", colOr[0], colOr[1], colOr[2]);
#endif

    // position
    Float64 imgPos[3] = { 0.0f, 0.0f, 0.0f };
    std::vector<PGMath::Vector3D<float> > positions;
    cond = dataset->findAndGetElement(DCM_ImagePositionPatient, elem);
    if(!cond.good())
    {
        LOG1("IO/IODicom::Read:Warning Cannot fetch DCM_ImagePositionPatient (%s)", cond.text());
    } else
    {
        elem->getFloat64(imgPos[0], 0);
        elem->getFloat64(imgPos[1], 1);
        elem->getFloat64(imgPos[2], 2);
    }
    positions.push_back(PGMath::Vector3D<float>(imgPos[0], imgPos[1], imgPos[2]));
    oMetaDataObject.SetImagePositionsPatient(positions);
#ifdef _DEBUG
    LOG3("\tIODicom::Read: Image Position (%3.5f %3.5f %3.5f)", imgPos[0], imgPos[1], imgPos[2]);
#endif

    // slope / intercept
    if (modality==PGCore::kPGModalityCT || modality==PGCore::kPGModalityPT)
    {
        Float64 slope = -999.0f;
        cond = dataset->findAndGetElement(DCM_RescaleSlope, elem);
        if(!cond.good())
        {
            LOG1("IO/IODicom::Read:Warning Cannot fetch DCM_RescaleSlope (%s)", cond.text());
        } else
        {
            cond = elem->getFloat64(slope, 0);
            if(cond.good())
                //if (dataset->findAndGetFloat64(DCM_RescaleIntercept, slope) == EC_Normal)
            {
                oMetaDataObject.SetSlope(slope);
                //LOG1("IO/IODicom::Read: Cannot fetch pixel Y spacing (%s)", cond.text());
            }
        }

        Float64 intercept = -999.0f;
        //dataset->findAndGetFloat64(DCM_RescaleIntercept, intercept);
        cond = dataset->findAndGetElement(DCM_RescaleIntercept, elem);
        if(!cond.good())
        {
            LOG1("IO/IODicom::Read:Warning Cannot fetch DCM_RescaleIntercept (%s)", cond.text());
        } else
        {
            cond = elem->getFloat64(intercept, 0);
            if(cond.good())
                //if (dataset->findAndGetFloat64(DCM_RescaleIntercept, intercept) == EC_Normal)
            {
                oMetaDataObject.SetIntercept(intercept);
            }
        }
    }
    /*
    Uint16 imageBytesAllocated = 0;
    Uint16 imagePlanarConfiguration = 0;
    Uint16 imageSamplesPerPixel = 0;

    Sint32 imageFrames = 1;
    Uint16 imageBitsAllocated = 0;


    if (result.good()) result = ditem->findAndGetUint16(DCM_BitsAllocated, imageBitsAllocated);
    res = ditem->findAndGetUint16(DCM_SamplesPerPixel, imageSamplesPerPixel);

    // slope / intercept

    // high bit

    // planar configuration

    // endianness
    oMetaData->SetMSBFirst(getValueI(iStr,std::string(kPGTagMSBFirst)));
    */
#endif

#ifdef _DEBUG
    LOG0("} IODicom::GetAttributes");
#endif

    return true;

}
Пример #28
0
void forOlya()
{
	TString ntuple = "flatout"; // or "mvaout"
	TFile* f = (ntuple=="flatout") ? new TFile("flatout.periodall+MC.muons.mva.analysis.n0.j0.loose.root","READ") : new TFile("mvaout.muons.root","READ");;
	TTree* tS0 = (TTree*)f->Get((ntuple=="flatout") ? "flatout_Wtaunu_3mu"      : "fltmva_Wtaunu_3mu");
	TTree* tS  = (TTree*)f->Get((ntuple=="flatout") ? "flatout_Wtaunu_200k_3mu" : "fltmva_Wtaunu_200k_3mu");
	TTree* tD  = (TTree*)f->Get((ntuple=="flatout") ? "flatout_Data"            : "fltmva_Data");

	TString smMinTraining  = tstr(mTrainingMinGlob,0);
	TString smMaxTraining  = tstr(mTrainingMaxGlob,0);
	TString smMinSBleft    = tstr(mSideBandLeftLowerMeVGlob,0);
	TString smMaxSBleft    = tstr(mBlindMinGlob,0);
	TString smMinSBright   = tstr(mBlindMaxGlob,0);
	TString smMaxSBright   = tstr(mSideBandRightUpperMeVGlob,0);
	TString sxSRmin        = tstr(mSRminMeVGlob,0);
	TString sxSRmax        = tstr(mSRmaxMeVGlob,0);
	TString soptBDTcut     = tstr(optBDTcut,4);
	TString sminBDTcut     = tstr(minBDTcut,4);
	
	TString cuts_sig = "";
	TString cuts_bkg = "";
	Float_t ninitS   = -1;
	Float_t npassedS = -1;
	Float_t npassedD = -1;
	bool blinded = true; bool unblinded = false;
	bool doBDT   = true; bool noBDT     = false;
	
	//// loose training selection
	cuts_sig = postBDTcut(smMinTraining,smMinSBleft,smMaxSBright,smMaxTraining,"-1","-1","sig", "","", unblinded,noBDT,"preTraining",ntuple);
	cuts_bkg = postBDTcut(smMinTraining,smMinSBleft,smMaxSBright,smMaxTraining,"-1","-1","bkg", "","", blinded,noBDT,"preTraining",ntuple);
	npassedS = tS->GetEntries(cuts_sig); cout << "Loose+training only (signal) : " << npassedS << endl;
	npassedD = tD->GetEntries(cuts_bkg); cout << "Loose+training only (SB data): " << npassedD << endl;
	
	//// loose selection
	cuts_sig = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,"-1","-1","sig", sxSRmin,sxSRmax, unblinded,noBDT,"preTraining",ntuple);
	cuts_bkg = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,"-1","-1","bkg", sxSRmin,sxSRmax, blinded,noBDT,"preTraining",ntuple);
	npassedS = tS->GetEntries(cuts_sig); cout << "Loose only (signal) : " << npassedS << endl;
	npassedD = tD->GetEntries(cuts_bkg); cout << "Loose only (SB data): " << npassedD << endl;
	
	//// loose+x>x0 selection
	cuts_sig = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,sminBDTcut,sminBDTcut,"sig", sxSRmin,sxSRmax, unblinded,doBDT,"preTraining",ntuple);
	cuts_bkg = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,sminBDTcut,sminBDTcut,"bkg", sxSRmin,sxSRmax, blinded,doBDT,"preTraining",ntuple);
	npassedS = tS->GetEntries(cuts_sig); cout << "Loose+x>x0 only (signal) : " << npassedS << endl;
	npassedD = tD->GetEntries(cuts_bkg); cout << "Loose+x>x0 only (SB data): " << npassedD << endl;
	
	//// tight selection
	cuts_sig = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,"-1","-1","sig", sxSRmin,sxSRmax, unblinded,noBDT,"postTraining",ntuple);
	cuts_bkg = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,"-1","-1","bkg", sxSRmin,sxSRmax, blinded,noBDT,"postTraining",ntuple);
	npassedS = tS->GetEntries(cuts_sig); cout << "Tight only (signal) : " << npassedS << endl;
	npassedD = tD->GetEntries(cuts_bkg); cout << "Tight only (SB data): " << npassedD << endl;
	
	//// tight+x>x0 selection
	cuts_sig = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,sminBDTcut,sminBDTcut,"sig", sxSRmin,sxSRmax, unblinded,doBDT,"postTraining",ntuple);
	cuts_bkg = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,sminBDTcut,sminBDTcut,"bkg", sxSRmin,sxSRmax, blinded,doBDT,"postTraining",ntuple);
	npassedS = tS->GetEntries(cuts_sig); cout << "Tight+x>x0 only (signal) : " << npassedS << endl;
	npassedD = tD->GetEntries(cuts_bkg); cout << "Tight+x>x0 only (SB data): " << npassedD << endl;
	
	//// tight+x>x1 selection
	cuts_sig = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,sminBDTcut,soptBDTcut,"sig", sxSRmin,sxSRmax, unblinded,doBDT,"postTraining",ntuple);
	cuts_bkg = postBDTcut(smMinSBleft,smMaxSBleft,smMinSBright,smMaxSBright,sminBDTcut,soptBDTcut,"bkg", sxSRmin,sxSRmax, blinded,doBDT,"postTraining",ntuple);
	npassedS = tS->GetEntries(cuts_sig); cout << "Tight+x>x1 only (signal) : " << npassedS << endl;
	npassedD = tD->GetEntries(cuts_bkg); cout << "Tight+x>x1 only (SB data): " << npassedD << endl;
}