SFTWorker::~SFTWorker()
{
stop();
safe_delete(m_pBzs);
}
void soft_stop ()
{
if (state () == async_state::running)
stop ();
}
QgsOracleConnectionItem::~QgsOracleConnectionItem()
{
stop();
}
/**
* @brief Destroys the Timer
* @details Makes sure to stop any eventual underlying Timer
* if its running.
*/
~Timer()
{ stop(); }
ConsoleProcess::~ConsoleProcess()
{
stop();
delete d;
}
/**
* respondStop
*
* Default responder function. Stop the robot.
*/
void respondStop(void)
{
stop();
usleep(30);
}
int main(int argc, char *argv[])
{
if (argc < 4) {
fprintf(stderr, "usage:\t%s <D size > <Q size> <I size> "
"<seed>\n", argv[0]);
return 1;
}
int d = atoi(argv[1]); // size of data set D
int q = atoi(argv[2]); // size of query set Q
int i = atoi(argv[3]); // size of index I
int seed = atoi(argv[4]);
srand(seed);
int *D = (int *) malloc(d * sizeof(int));
int j;
for (j = 0; j < d; j++)
D[j] = rand();
qsort(D, d, sizeof(int), compare_int);
/* Print list
for (j = 0; j < d; j++)
printf("%d %d\n", j, D[j]);
*/
int *I = (int *) malloc(i * sizeof(int));
for (j = 1; j < i; j++) {
int lo = -1, hi = d;
I[ j - 1 ] = D[ ( j*hi + (i - j)*lo ) / i];
}
unsigned long bs = 0;
unsigned long is = 0;
int w = 0;
/* Search list */
for (j = 0; j < q; j++) {
/*
printf("%d\t", r);
int a = b_search(r, D, d, -1, d);
int b = b_search(r, I, i, -1, i);
int lo = -1, hi = d;
int new_hi = ( (b+1)*hi + (i - (b+1))*lo ) / i;
int new_lo = ( (b)*hi + (i - (b+1))*lo ) / i;
if (b == 0)
new_lo = -1;
else if (b == i) {
new_hi = d;
new_lo = ( (b-1)*hi + (i - (b+1))*lo ) / i;
}
int c = b_search(r, D, d, new_lo, new_hi);
printf("d:%d\ti:%d\t%d\n",a,b,c);
*/
printf("b:\n");
int r = rand();
start();
int a = b_search(r, D, d, -1, d);
stop();
bs += report();
printf("i:\n");
start();
int b = i_b_search(r, D, d, I, i);
stop();
is += report();
if (a != b)
++w;
}
printf("%lu\t%lu\t%f\n", bs, is, (((double)bs) / ((double)is)) );
return 0;
}
Connector::~Connector (void)
{
this->reactor (0);
stop ();
}
int main( void ) {
if ( !init() ) {
return EXIT_FAILURE;
}
STATE state = S_init;
STATE last_state;
stop();
while ( 1 ) {
last_state = state;
readRegisters();
switch ( state ) {
default:
case S_init:
if ( regs.STATUS1.bumperLeft ) {
state = bumperLeft;
} else if ( regs.STATUS1.bumperRight ) {
state = bumperRight;
} else if ( regs.STATUS1.obstacleLeft ) {
state = obstacleLeft;
} else if ( regs.STATUS1.obstacleRight ) {
state = obstacleRight;
} else {
state = forward;
}
break;
case forward:
if ( regs.STATUS1.bumperLeft ) {
state = bumperLeft;
} else if ( regs.STATUS1.bumperRight ) {
state = bumperRight;
} else if ( regs.STATUS1.obstacleLeft ) {
state = obstacleLeft;
} else if ( regs.STATUS1.obstacleRight ) {
state = obstacleRight;
}
break;
case bumperLeft:
if ( regs.STATUS3.movementComplete ) {
state = bumperLeft2;
}
break;
case bumperLeft2:
if ( regs.STATUS3.movementComplete ) {
state = forward;
}
break;
case bumperRight:
if ( regs.STATUS3.movementComplete ) {
state = bumperRight2;
}
break;
case bumperRight2:
if ( regs.STATUS3.movementComplete ) {
state = forward;
}
break;
case obstacleLeft:
if ( regs.STATUS1.bumperLeft ) {
state = bumperLeft;
} else if ( regs.STATUS1.bumperRight ) {
state = bumperRight;
} else if ( !regs.STATUS1.obstacleLeft ) {
state = forward;
}
break;
case obstacleRight:
if ( regs.STATUS1.bumperLeft ) {
state = bumperLeft;
} else if ( regs.STATUS1.bumperRight ) {
state = bumperRight;
} else if ( !regs.STATUS1.obstacleRight ) {
state = forward;
}
break;
}
if ( last_state != state ) {
switch ( state ) {
case forward:
stop();
changeDirection( RP6_FORWARD );
moveAtSpeed( 80 , 80 );
printf( "Change State: forward\n" );
break;
case bumperLeft:
stop();
move( 20 , RP6_BACKWARD , 600 );
printf( "Change State: bumperLeft\n" );
break;
case bumperLeft2:
rotate( 20 , RP6_RIGHT , 45 );
printf( "Change State: bumperLeft2\n" );
break;
case bumperRight:
stop();
move( 20 , RP6_BACKWARD , 600 );
printf( "Change State: bumperRight\n" );
break;
case bumperRight2:
rotate( 20 , RP6_LEFT , 45 );
printf( "Change State: bumperRight2\n" );
break;
case obstacleLeft:
stop();
changeDirection( RP6_RIGHT );
moveAtSpeed( 20 , 20 );
printf( "Change State: obstacleLeft\n" );
break;
case obstacleRight:
stop();
changeDirection( RP6_LEFT );
moveAtSpeed( 20 , 20 );
printf( "Change State: obstacleRight\n" );
break;
default:
break;
}
}
}
linux_i2c->close( linux_i2c );
return EXIT_SUCCESS;
}
virtual ~MyTask () { stop (); }
Acceptor::~Acceptor (void)
{
this->reactor (0);
stop ();
}
int main(int argc, char **argv)
{
if(argc != 6) {
std::cout << "wrong args" << std::endl;
return 1;
}
const char *sensorDeviceName = argv[1];
const char *actuatorDeviceName = argv[2];
const int cameraDeviceNum = atoi(argv[3]);
const int port = atoi(argv[4]);
const char *mode = argv[5];
bool showThermal = false;
bool showRGB = false;
if(mode[0] == 't') {
showThermal = true;
} else if(mode[0] == 'r') {
showRGB = true;
} else {
throw "wtf";
}
std::cout << "blah" << std::endl;
std::shared_ptr<ApplicationCore> core = ApplicationCore::instantiate();
auto sc = std::make_shared<ThermalSensorController>(core, sensorDeviceName, 115200);
auto rc = std::make_shared<RgbController>(core, cameraDeviceNum);
auto ac = std::make_shared<ActuatorController>("/dev/tty.usbserial-A9S3VTXD");
auto ns = std::make_shared<NetService>(core);
sc->init();
rc->init();
ac->init();
ns->init(port);
boost::asio::deadline_timer timer(*core->getIOService());
std::function<void(const boost::system::error_code&)> captureStuff;
GyroReading gyroReading;
ThermoReading thermoReading;
captureStuff = [&](const boost::system::error_code& /*e*/) {
//
cv::Vec2d pos = ac->getCurrentPosition();
rc->captureFrame();
auto rgbFrame = rc->popFrame();
if(showRGB && rgbFrame->rows > 0) {
rapidjson::Document doc;
auto &aloc = doc.GetAllocator();
doc.SetObject();
cv::Mat imgMat(rgbFrame->rows, rgbFrame->cols, CV_8UC4, cv::Scalar::all(0.0));
cv::cvtColor(*rgbFrame, imgMat, CV_BGR2RGBA, 4);
cv::Size size(rgbFrame->cols*0.2, rgbFrame->rows*0.2);
cv::resize(imgMat, imgMat, size);
std::string imgDataB64 = tobase64(imgMat.data, imgMat.total()*4*sizeof(byte));
rapidjson::Value val;
val.SetString(imgDataB64.c_str(), doc.GetAllocator());
doc.AddMember("data", val, aloc);
doc.AddMember("type", "rgb_data", aloc);
doc.AddMember("yaw", -pos[0], aloc);
doc.AddMember("pitch", -pos[1], aloc);
doc.AddMember("dataWidth", imgMat.cols, aloc);
doc.AddMember("dataHeight", imgMat.rows, aloc);
doc.AddMember("yawSize", 63.625, aloc);
doc.AddMember("pitchSize", 35.789, aloc);
ns->sendWSDoc(doc);
}
/*if(sc->popGyroReading(gyroReading)) {
printf("Roll: %f, Pitch: %f, Yaw: %f.\n",
gyroReading.roll, gyroReading.pitch, gyroReading.yaw
);
}*/
sc->requestThermoReading();
std::cout << "tick: " << timer.expires_at() << std::endl;
if(showThermal && sc->popThermoReading(thermoReading)){
rapidjson::Document doc;
auto &aloc = doc.GetAllocator();
doc.SetObject();
doc.AddMember("type", "thermo_data", aloc);
doc.AddMember("yaw", -pos[0], aloc);
doc.AddMember("pitch", -pos[1], aloc);
cv::Mat imgMat(4, 16, CV_8UC4, cv::Scalar::all(0.0));
cv::Mat mat = thermoReading.img;
for(int i = 0; i < mat.total(); i++) {
int y = 3-(i%4);
int x = i/4;
double temp = mat.at<float>(0, i);
if(
(x == 11 && y == 2)
|| (x == 11 && y == 3)
|| (x == 12 && y == 2)
) {
temp += 10.0;
}
//std::cout << (int)temp << " ";
cv::Vec4b col = hsv(
300-300.0*(std::max(temp, 14.0)-14.0)/(40.0-14.0),
1, 1
);
if(temp <= 11.0) {
col = cv::Vec4b(30, 30, 50, 255);
} else if(temp > 40.0) {
col = cv::Vec4b(255, 255, 255, 255);
}
imgMat.at<cv::Vec4b>(y, x) = col;
//std::cout << std::endl;
}
std::string imgDataB64 = tobase64(imgMat.data, imgMat.total()*4*sizeof(byte));
rapidjson::Value val;
val.SetString(imgDataB64.c_str(), doc.GetAllocator());
doc.AddMember("data", val, aloc);
ns->sendWSDoc(doc);
}
timer.expires_from_now(boost::posix_time::milliseconds(interval));
timer.async_wait(captureStuff);
};
timer.expires_from_now(boost::posix_time::milliseconds(interval));
timer.async_wait(captureStuff);
ns->registerCallback("move_actuator", [&](const rapidjson::Document &doc) {
ac->stop();
ActuatorMoveOrder order;
order.posDeg = cv::Vec2d(
std::max(-150.0, std::min(150.0, -doc["yaw" ].GetDouble()/M_PI*180)),
std::max(- 90.0, std::min( 90.0, -doc["pitch"].GetDouble()/M_PI*180))
);
order.duration = 3.5;
ac->queueMove(order);
});
std::cout << "run" << std::endl;
core->run();
}
uint8_t I2C::endTransmission()
{
stop();
return(returnStatusWire);
}
OpenALSoundSource::~OpenALSoundSource()
{
stop();
alDeleteSources(1, &source);
}
//The main invoker routine. It takes as argument the next command to execute and does what is necessary
//Self-explanatory code!
void my_invoker (unsigned char command) {
if(command == BUZZER_ON){
buzzer_on();
return;
}
else if(command == BUZZER_OFF){
buzzer_off();
return;
}
else if(command == MOVE_FORWARD)
{
forward(); //forward
return;
}
else if(command == MOVE_BACKWARD)
{
back(); //back
return;
}
else if(command == MOVE_LEFT)
{
left(); //left
return;
}
else if(command == MOVE_RIGHT)
{
right(); //right
return;
}
else if(command == STOP)
{
stop(); //stop
return;
}
else if(command == SET_VELOCITY)
{
int numargs;
unsigned char * ch = recieve_args(&numargs);
//assert(numargs == 1);
int velleft = (int)*(ch);
int velright = (int)*(ch+1);
velocity(velleft,velright);
return;
}
else if(command == MOVE_BY)
{
int numargs;
unsigned char * ch = recieve_args(&numargs);
int pos_a = (int)*(ch);
int pos_b = (int)*(ch+1);
//int pos = 10;
//while (pos_b--) pos *= 10;
//pos *= pos_a;
//forward_mm(pos);
pos_a += (pos_b << 8);
forward();
velocity(120,120);
while (pos_a--) {
//delay on 5 ms
stop_on_timer4_overflow = 1;
start_timer4();
while (stop_on_timer4_overflow != 0) {;}
}
stop();
send_char(SUCCESS);
leftInt = 0;
rightInt = 0;
return;
}
else if(command == MOVE_BACK_BY)
{
int numargs;
unsigned char * ch = recieve_args(&numargs);
int pos_a = (int)*(ch);
int pos_b = (int)*(ch+1);
//int pos = 10;
//while (pos_b--) pos *= 10;
//pos *= pos_a;
//forward_mm(pos);
pos_a += (pos_b << 8);
back();
velocity(120,120);
while (pos_a--) {
//delay on 5 ms
stop_on_timer4_overflow = 1;
start_timer4();
while (stop_on_timer4_overflow != 0) {;}
}
stop();
send_char(SUCCESS);
leftInt = 0;
rightInt = 0;
return;
}
else if(command == TURN_LEFT_BY)
{
int numargs;
unsigned char * ch = recieve_args(&numargs);
already_stopped = 0;
int pos_a = (int)*(ch);
int pos_b = (int)*(ch+1);
pos_a += (pos_b << 8);
_delay_ms(500);
left();
velocity(200,200);
while (pos_a--) {
//delay on 5 ms
stop_on_timer4_overflow = 1;
start_timer4();
while (stop_on_timer4_overflow != 0) {;}
}
stop();
send_char(SUCCESS);
leftInt = 0;
rightInt = 0;
already_modified_stopped = 0;
return;
}
else if(command == TURN_RIGHT_BY)
{
int numargs;
unsigned char * ch = recieve_args(&numargs);
//assert(numargs == 2);
int pos_a = (int)*(ch);
int pos_b = (int)*(ch+1);
pos_a += (pos_b << 8);
_delay_ms(500);
right();
velocity(200,200);
while (pos_a--) {
//delay on 5 ms
stop_on_timer4_overflow = 1;
start_timer4();
while (stop_on_timer4_overflow != 0) {;}
}
stop();
send_char(SUCCESS);
leftInt = 0;
rightInt = 0;
already_modified_stopped = 0;
return;
}
else if(command == LCD_SET_STRING)
{
int numargs;
unsigned char * ch = recieve_args(&numargs);
int i =0;
lcd_clear();
for(;i<numargs;i++)
{
lcd_wr_char(*(ch+i));
}
return;
}
else if (command == SET_PORT){
int numargs;
unsigned char * ch = recieve_args(&numargs); ;
if (numargs != 2){
}
int portnum = (int) *(ch);
unsigned char value = (unsigned char) *(ch+1);
setPort(portnum,value);
}
else if(command == GET_SENSOR_VALUE)
{
int numargs;
unsigned char * ch = recieve_args(&numargs); ;
if (numargs != 1){
}
int sensornum = (int) *(ch);
//setPort(portnum,value);
getSensorValue(sensornum);
}
else if(command == GET_PORT)
{
int numargs;
unsigned char * ch = recieve_args(&numargs); ;
if (numargs != 1){
}
int portnum = (int) *(ch);
getPort(portnum);
}
else if (command == WHITELINE_FOLLOW_START) {
whiteline_follow_start();
}
else if(command == PRINT_STATE){
buzzer_on();
lcd_num(state);
_delay_ms(1000);
buzzer_off();
}
else if (command == WHITELINE_FOLLOW_END) {
whiteline_follow_end();
}
else if (command == WHITELINE_STOP_INTERSECTION) {
whiteline_stop_intersection_flag = 1;
}
else if(command == ACC_START) {
acc_flag = 1;
}
else if(command == ACC_STOP) {
acc_flag = 0;
acc_modified_flag = 0;
buzzer_off();
}
else if(command == ACC_MODIFIED){
acc_modified_flag = 1;
already_modified_stopped = 0;
}
else if(command == ACC_CHECK){
if (acc_modified_flag == 1 && already_modified_stopped == 1){
send_char((char)1);
}
else {
char value = PORTA;
if (value == 0) send_char((char)2);
else send_char((char)0);
}
}
else if (command == ENABLE_LEFT_WHEEL_INTERRUPT) {
leftInt = 0;
left_position_encoder_interrupt_init();
}
else if (command == ENABLE_RIGHT_WHEEL_INTERRUPT) {
rightInt = 0;
right_position_encoder_interrupt_init();
}
else if (command == GET_LEFT_WHEEL_INTERRUPT_COUNT) {
send_int (leftInt);
leftInt = 0;
}
else if (command == GET_RIGHT_WHEEL_INTERRUPT_COUNT) {
send_int (rightInt);
rightInt = 0;
}
else if (command == SET_TIMER) {
int numargs;
unsigned char * ch = recieve_args(&numargs); ;
if (numargs != 1){
}
int time = (int) *(ch);
timer4_init2(time);
}
else if (command == DISCONNECT) {
disconnect();
}
else { //Error!!! Unrecognized Command
buzzer_on();
_delay_ms(1000);
buzzer_off();
}
}
io_looper::~io_looper(void)
{
stop();
}
void animation::setPlayFrame(int start, int end, BOOL reverse, BOOL loop)
{
_loop = loop;
_vPlayList.clear();
if (start == end)
{
//시작 프레임과 끝프레임이 같으면~~~
_vPlayList.clear();
stop();
return;
}
//시작이 종료보다 크면..
if (start > end)
{
//되돌아오냐?
if (reverse)
{
//루프냐?
if (_loop)
{
for (int i = start; i >= end; i--)
{
_vPlayList.push_back(i);
}
for (int i = end + 1; i < start; i++)
{
_vPlayList.push_back(i);
}
}
else
{
for (int i = start; i >= end; i--)
{
_vPlayList.push_back(i);
}
}
}
else
{
for (int i = start; i >= end; i--)
{
_vPlayList.push_back(i);
}
}
}
else
{
//되돌아오냐?
if (reverse)
{
//루프냐?
if (_loop)
{
for (int i = start; i <= end; i++)
{
_vPlayList.push_back(i);
}
for (int i = end - 1; i > start; i--)
{
_vPlayList.push_back(i);
}
}
else
{
for (int i = start; i >= end; i--)
{
_vPlayList.push_back(i);
}
}
}
else
{
for (int i = start; i <= end; i++)
{
_vPlayList.push_back(i);
}
}
}
}
void StereoSample::addSamples(float *samples, int length, int numChannels) {
if(length>BUFF_SIZE) {
printf("Buffer not big enough!!\n");
memset(samples, 0, length*numChannels*sizeof(float));
return;
}
// get the samples to work on
getSamples(StereoSample_buffer, length);
float lerpAmt = 0.05f;
if(fadePos>-1) {
targetVolume = getFadeVolume();
fadePos += length;
}
// make sure we don't shoot over the channels
channel1 %= numChannels;
if(channel2!=-1) channel2 %= numChannels;
if(getNumChannels()==1) {
for(int i = 0; i < length; i++) {
volume = volume*(1.f-lerpAmt) + targetVolume*lerpAmt;
pan = pan*(1.f-lerpAmt) + targetPan*lerpAmt;
samples[i*numChannels + channel1] += StereoSample_buffer[i]*(1 - pan)*volume;
if(channel2!=-1)
samples[i*numChannels + channel2] += StereoSample_buffer[i]*pan*volume;
}
} else if(getNumChannels()==2) {
for(int i = 0; i < length; i++) {
volume = volume*(1.f-lerpAmt) + targetVolume*lerpAmt;
pan = pan*(1.f-lerpAmt) + targetPan*lerpAmt;
samples[i*numChannels + channel1] += StereoSample_buffer[i*2]*(1 - pan)*volume;
if(channel2!=-1)
samples[i*numChannels + channel2] += StereoSample_buffer[i*2+1]*pan*volume;
}
}
if(fadePos>=fadeDuration) {
fadePos = -1;
if(targetVolume<0.001 && volume<0.001) {
stop();
}
}
}
ActiveThread::~ActiveThread()
{
stop();
//_log.warning("END");
}
AbstractManager::~AbstractManager()
{
stop();
}
void ScanDlg::onCancelPressed()
{
stop();
}
static void
compute(JNIEnv *env, jobject thiz, jlong memoryPointer, jshortArray input)
{
Variables* inParam = (Variables*) memoryPointer;
//TVPhamVAD* VADRefer = (TVPhamVAD*) malloc(sizeof(TVPhamVAD));
start(inParam->timer);
short *_in = (*env)->GetShortArrayElements(env, input, NULL);
int i,j,overlap, stepsize,order,index;
order = 12;
stepsize = inParam->stepSize;
float* cepstra;
float XL_temp = 0;
float XH_temp = 0;
//---------------------------
int counter = 0;
//----------------------------
overlap = inParam->overlap;
stepsize = inParam->stepSize;
for(i=0; i<overlap; i++)
{
inParam->inputBuffer[i] = inParam->inputBuffer[stepsize + i];
}
for (i=0; i<stepsize; i++)
{
inParam->inputBuffer[overlap + i] = _in[i]/32768.0;
//inParam->outputBuffer[i] = inParam->inputBuffer[overlap + i];
}
(*env)->ReleaseShortArrayElements(env, input, _in, 0);
//Processing logic here. For now this placeholder will copy the input
//to the output array for the processing function and scale it by 1/2.
//For switching between suppressed and original output a GUI option
//can be used to select the output channel.
for(i=0;i<stepsize;i++)
{
XL_temp = 0;
XH_temp = 0;
for(j=0;j<order;j++)
{
index = overlap + i - j;
if(index>=0)
{
XL_temp += inParam->inputBuffer[overlap + i - j]*LD[j];
XH_temp += inParam->inputBuffer[overlap + i - j]*HD[j];
}
}
if(i%2 == 0)
{
inParam->XL[i/2] = XL_temp;
inParam->XH[i/2] = XH_temp;
//inParam->outputBuffer[i/2] = inParam->XH[i/2];
}
}
DecideVad(inParam);
cepstra = melfcc(inParam->inputBuffer);
//melfcc(inParam);
/*for(i=0;i<stepsize;i++)
{
inParam->outputBuffer[i] = inParam->inputBuffer[overlap+i]*0.5f;
}*/
/*for(i=0;i<stepsize;i++)
{
inParam->outputBuffer[i] = XL[i];
}*/
stop(inParam->timer);
}
inline void Timer::restart(duration_t when, handler_t on_timeout) {
stop();
start(when, on_timeout);
}
bool start(const boost::filesystem::path &root) override
{
if (running_) {
if (root_ == root) {
return true;
} else {
return false;
}
}
SECURITY_ATTRIBUTES sa = {};
sa.nLength = sizeof(sa);
sa.bInheritHandle = TRUE;
cancel_event_ = ::CreateEventW(&sa, TRUE, FALSE, nullptr);
if (cancel_event_ == nullptr) {
return false;
}
HANDLE hstdout_read = nullptr;
HANDLE hstdout_write = nullptr;
HANDLE hstderr_write = nullptr;
if (::CreatePipe(&hstdout_read, &hstdout_write, &sa, 0) == FALSE) {
return false;
}
if (::DuplicateHandle(
::GetCurrentProcess(), hstdout_write, ::GetCurrentProcess(), &hstderr_write,
0, TRUE, DUPLICATE_SAME_ACCESS) == FALSE)
{
::CloseHandle(hstdout_read);
::CloseHandle(hstdout_write);
return false;
}
if (::DuplicateHandle(
::GetCurrentProcess(), hstdout_read, ::GetCurrentProcess(), &hstdout_,
0, FALSE, DUPLICATE_SAME_ACCESS) == FALSE)
{
::CloseHandle(hstdout_read);
::CloseHandle(hstdout_write);
::CloseHandle(hstderr_write);
return false;
}
STARTUPINFOW si = {};
si.cb = sizeof(STARTUPINFOW);
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
si.hStdOutput = hstdout_write;
si.hStdError = hstderr_write;
si.wShowWindow = SW_HIDE;
PROCESS_INFORMATION pi = {};
std::wstring command = L'\"' + (get_exe_path().remove_filename() / L"console-helper.exe").wstring();
command += L"\" ";
command += std::to_wstring(reinterpret_cast<std::uintptr_t>(cancel_event_));
command += L' ';
command += L"jupyter notebook --no-browser ";
command += L"--notebook-dir=\"";
command += root.wstring();
command += L'\"';
auto result = ::CreateProcessW(
nullptr,
const_cast<LPWSTR>(command.c_str()),
nullptr,
nullptr,
TRUE,
CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP,
nullptr,
nullptr,
&si,
&pi);
::CloseHandle(hstdout_read);
::CloseHandle(hstdout_write);
::CloseHandle(hstderr_write);
if (result == FALSE) {
::CloseHandle(hstdout_);
return false;
}
running_ = true;
helper_process_ = pi.hProcess;
char buf_array[256];
DWORD read;
std::string buf;
const char *text = "The Jupyter Notebook is running at: ";
auto text_len = ::strlen(text);
for (;;) {
if (::ReadFile(hstdout_, (LPVOID)buf_array, 255, &read, nullptr) == FALSE) {
return false;
}
buf_array[read] = '\0';
buf += buf_array;
auto pos = buf.find(text);
if (pos != std::string::npos) {
pos += text_len;
auto pos_end = buf.find_first_of("\r\n", pos);
if (pos_end != std::string::npos) {
auto s = buf.substr(pos + 7, pos_end - pos - 7);
pos = s.find(':');
pos_end = s.find('/', pos);
auto aa = s.substr(pos + 1, pos_end - pos - 1);
if (pos != std::string::npos && pos_end != std::string::npos) {
try {
port_ = static_cast<unsigned short>(std::stoul(s.substr(pos + 1, pos_end - pos - 1)));
} catch (std::exception &e) {
stop();
throw e;
}
}
break;
}
}
}
return port_ != 0;
}
void timerEvent(QTimerEvent *event)
{
if (event->timerId() == id)
stop();
}
HelpBrowser::HelpBrowser( QWidget * parent ):
QWidget(parent)
{
QRect availableScreenRect = qApp->desktop()->availableGeometry(this);
mSizeHint = QSize( availableScreenRect.width() * 0.4, availableScreenRect.height() * 0.7 );
QtCollider::WebPage *webPage = new QtCollider::WebPage(this);
webPage->setDelegateReload(true);
webPage->setLinkDelegationPolicy( QWebPage::DelegateAllLinks );
mWebView = new QWebView;
mWebView->setPage( webPage );
mWebView->settings()->setAttribute( QWebSettings::LocalStorageEnabled, true );
mWebView->setContextMenuPolicy( Qt::CustomContextMenu );
// Set the style's standard palette to avoid system's palette incoherencies
// get in the way of rendering web pages
mWebView->setPalette( style()->standardPalette() );
mWebView->installEventFilter(this);
mLoadProgressIndicator = new LoadProgressIndicator;
mLoadProgressIndicator->setIndent(10);
QVBoxLayout *layout = new QVBoxLayout;
layout->setContentsMargins(0,0,0,0);
layout->setSpacing(0);
layout->addWidget(mWebView);
setLayout(layout);
connect( mWebView, SIGNAL(linkClicked(QUrl)), this, SLOT(onLinkClicked(QUrl)) );
connect( mWebView, SIGNAL(loadStarted()), mLoadProgressIndicator, SLOT(start()) );
connect( mWebView, SIGNAL(loadFinished(bool)), mLoadProgressIndicator, SLOT(stop()) );
connect( mWebView, SIGNAL(customContextMenuRequested(QPoint)),
this, SLOT(onContextMenuRequest(QPoint)) );
connect( webPage->action(QWebPage::Reload), SIGNAL(triggered(bool)), this, SLOT(onReload()) );
connect( webPage, SIGNAL(jsConsoleMsg(QString,int,QString)),
this, SLOT(onJsConsoleMsg(QString,int,QString)) );
ScProcess * scProcess = Main::scProcess();
connect( scProcess, SIGNAL(response(QString,QString)),
this, SLOT(onScResponse(QString,QString)) );
connect( scProcess, SIGNAL(finished(int)), mLoadProgressIndicator, SLOT(stop()) );
// FIXME: should actually respond to class library shutdown, but we don't have that signal
connect( scProcess, SIGNAL(classLibraryRecompiled()), mLoadProgressIndicator, SLOT(stop()) );
createActions();
applySettings( Main::settings() );
}
receiver::status receiver::set_demod(rx_demod demod)
{
bool needs_restart = d_running;
bool wide_fm = (d_demod == RX_DEMOD_WFM_M) || (d_demod == RX_DEMOD_WFM_S);
status ret = STATUS_OK;
// Allow reconf using same demod to provide a workaround
// for the "jerky streaming" we may experience with rtl
// dongles (the jerkyness disappears when we run this function)
//if (demod == d_demod)
// return ret;
if (d_running)
stop();
switch (demod)
{
case RX_DEMOD_OFF:
tb->disconnect_all();
connect_all(RX_CHAIN_NONE);
break;
case RX_DEMOD_NONE:
if ((d_demod == RX_DEMOD_OFF) || wide_fm)
{
tb->disconnect_all();
connect_all(RX_CHAIN_NBRX);
}
rx->set_demod(nbrx::NBRX_DEMOD_NONE);
break;
case RX_DEMOD_AM:
if ((d_demod == RX_DEMOD_OFF) || wide_fm)
{
tb->disconnect_all();
connect_all(RX_CHAIN_NBRX);
}
rx->set_demod(nbrx::NBRX_DEMOD_AM);
break;
case RX_DEMOD_NFM:
if ((d_demod == RX_DEMOD_OFF) || wide_fm)
{
tb->disconnect_all();
connect_all(RX_CHAIN_NBRX);
}
rx->set_demod(nbrx::NBRX_DEMOD_FM);
break;
case RX_DEMOD_WFM_M:
if (!wide_fm)
{
tb->disconnect_all();
connect_all(RX_CHAIN_WFMRX);
}
rx->set_demod(wfmrx::WFMRX_DEMOD_MONO);
break;
case RX_DEMOD_WFM_S:
if (!wide_fm)
{
tb->disconnect_all();
connect_all(RX_CHAIN_WFMRX);
}
rx->set_demod(wfmrx::WFMRX_DEMOD_STEREO);
break;
case RX_DEMOD_SSB:
if ((d_demod == RX_DEMOD_OFF) || wide_fm)
{
tb->disconnect_all();
connect_all(RX_CHAIN_NBRX);
}
rx->set_demod(nbrx::NBRX_DEMOD_SSB);
break;
default:
ret = STATUS_ERROR;
break;
}
d_demod = demod;
if (needs_restart)
start();
return ret;
}
static void malloc_error(char *addr, size_t size, const char *file, int line)
{
stop("\nMemory allocation error! Addr: 0x%x, Size: 0x%x, File: %s, Line: %d\n",
(unsigned)addr, (unsigned)size, file, line);
}
void Player::reload()
{
stop();
start();
}
PopupWindow::PopupWindow(PopupWebView* view)
: QWidget()
, m_view(view)
, m_page(qobject_cast<PopupWebPage*>(view->page()))
, m_search(0)
{
m_layout = new QVBoxLayout(this);
m_layout->setContentsMargins(0, 0, 0, 0);
m_layout->setSpacing(0);
m_locationBar = new PopupLocationBar(this);
m_locationBar->setView(m_view);
m_statusBar = new QStatusBar(this);
m_statusBar->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Maximum);
m_progressBar = new ProgressBar(m_statusBar);
m_statusBar->addPermanentWidget(m_progressBar);
m_progressBar->hide();
m_view->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
m_statusBarMessage = new PopupStatusBarMessage(this);
m_menuBar = new QMenuBar(this);
QMenu* menuFile = new QMenu(tr("File"));
menuFile->addAction(QIcon::fromTheme("document-save"), tr("&Save Page As..."), m_view, SLOT(savePageAs()))->setShortcut(QKeySequence("Ctrl+S"));
menuFile->addAction(tr("Save Page Screen"), this, SLOT(savePageScreen()));
menuFile->addAction(QIcon::fromTheme("mail-message-new"), tr("Send Link..."), m_view, SLOT(sendPageByMail()));
menuFile->addAction(QIcon::fromTheme("document-print"), tr("&Print..."), m_view, SLOT(printPage()))->setShortcut(QKeySequence("Ctrl+P"));
menuFile->addSeparator();
menuFile->addAction(QIcon::fromTheme("window-close"), tr("Close"), this, SLOT(close()))->setShortcut(QKeySequence("Ctrl+W"));
m_menuBar->addMenu(menuFile);
m_menuEdit = new QMenu(tr("Edit"));
m_menuEdit->addAction(QIcon::fromTheme("edit-undo"), tr("&Undo"), this, SLOT(editUndo()))->setShortcut(QKeySequence("Ctrl+Z"));
m_menuEdit->addAction(QIcon::fromTheme("edit-redo"), tr("&Redo"), this, SLOT(editRedo()))->setShortcut(QKeySequence("Ctrl+Shift+Z"));
m_menuEdit->addSeparator();
m_menuEdit->addAction(QIcon::fromTheme("edit-cut"), tr("&Cut"), this, SLOT(editCut()))->setShortcut(QKeySequence("Ctrl+X"));
m_menuEdit->addAction(QIcon::fromTheme("edit-copy"), tr("C&opy"), this, SLOT(editCopy()))->setShortcut(QKeySequence("Ctrl+C"));
m_menuEdit->addAction(QIcon::fromTheme("edit-paste"), tr("&Paste"), this, SLOT(editPaste()))->setShortcut(QKeySequence("Ctrl+V"));
m_menuEdit->addSeparator();
m_menuEdit->addAction(QIcon::fromTheme("edit-select-all"), tr("Select All"), m_view, SLOT(selectAll()))->setShortcut(QKeySequence("Ctrl+A"));
m_menuEdit->addAction(QIcon::fromTheme("edit-find"), tr("Find"), this, SLOT(searchOnPage()))->setShortcut(QKeySequence("Ctrl+F"));
connect(m_menuEdit, SIGNAL(aboutToShow()), this, SLOT(aboutToShowEditMenu()));
m_menuBar->addMenu(m_menuEdit);
m_menuView = new QMenu(tr("View"));
m_actionStop = m_menuView->addAction(qIconProvider->standardIcon(QStyle::SP_BrowserStop), tr("&Stop"), m_view, SLOT(stop()));
m_actionStop->setShortcut(QKeySequence("Esc"));
m_actionReload = m_menuView->addAction(qIconProvider->standardIcon(QStyle::SP_BrowserReload), tr("&Reload"), m_view, SLOT(reload()));
m_actionReload->setShortcut(QKeySequence("F5"));
m_menuView->addSeparator();
m_menuView->addAction(QIcon::fromTheme("zoom-in"), tr("Zoom &In"), m_view, SLOT(zoomIn()))->setShortcut(QKeySequence("Ctrl++"));
m_menuView->addAction(QIcon::fromTheme("zoom-out"), tr("Zoom &Out"), m_view, SLOT(zoomOut()))->setShortcut(QKeySequence("Ctrl+-"));
m_menuView->addAction(QIcon::fromTheme("zoom-original"), tr("Reset"), m_view, SLOT(zoomReset()))->setShortcut(QKeySequence("Ctrl+0"));
m_menuView->addSeparator();
m_menuView->addAction(QIcon::fromTheme("text-html"), tr("&Page Source"), m_view, SLOT(showSource()))->setShortcut(QKeySequence("Ctrl+U"));
m_menuBar->addMenu(m_menuView);
// Make shortcuts available even with hidden menubar
QList<QAction*> actions = m_menuBar->actions();
foreach(QAction * action, actions) {
if (action->menu()) {
actions += action->menu()->actions();
}
addAction(action);
}
m_layout->insertWidget(0, m_menuBar);
m_layout->addWidget(m_locationBar);
m_layout->addWidget(m_view);
m_layout->addWidget(m_statusBar);
setLayout(m_layout);
connect(m_view, SIGNAL(showNotification(QWidget*)), this, SLOT(showNotification(QWidget*)));
connect(m_view, SIGNAL(titleChanged(QString)), this, SLOT(titleChanged()));
connect(m_view, SIGNAL(urlChanged(QUrl)), m_locationBar, SLOT(showUrl(QUrl)));
connect(m_view, SIGNAL(iconChanged()), m_locationBar, SLOT(showIcon()));
connect(m_view, SIGNAL(statusBarMessage(QString)), this, SLOT(showStatusBarMessage(QString)));
connect(m_view, SIGNAL(loadStarted()), this, SLOT(loadStarted()));
connect(m_view, SIGNAL(loadProgress(int)), this, SLOT(loadProgress(int)));
connect(m_view, SIGNAL(loadFinished(bool)), this, SLOT(loadFinished()));
connect(m_page, SIGNAL(linkHovered(QString, QString, QString)), this, SLOT(showStatusBarMessage(QString)));
connect(m_page, SIGNAL(geometryChangeRequested(QRect)), this, SLOT(setWindowGeometry(QRect)));
connect(m_page, SIGNAL(statusBarVisibilityChangeRequested(bool)), this, SLOT(setStatusBarVisibility(bool)));
connect(m_page, SIGNAL(menuBarVisibilityChangeRequested(bool)), this, SLOT(setMenuBarVisibility(bool)));
connect(m_page, SIGNAL(toolBarVisibilityChangeRequested(bool)), this, SLOT(setToolBarVisibility(bool)));
m_view->setFocus();
titleChanged();
QUrl urlToShow = m_view->url();
if (urlToShow.isEmpty()) {
urlToShow = m_view->page()->mainFrame()->requestedUrl();
}
m_locationBar->showUrl(urlToShow);
// Ensuring correct sizes for widgets in layout are calculated even
// before calling QWidget::show()
m_layout->invalidate();
m_layout->activate();
}
