//# MENU config
void ram(void){
uint8_t numentries = 0;
signed char menuselection = 0;
uint8_t visible_lines = 0;
uint8_t current_offset = 0;
for (int i=0;the_config[i].name!=NULL;i++){
if(!the_config[i].disabled)
numentries++;
};
visible_lines = ((RESY/getFontHeight())-1)/2;
while (1) {
// Display current menu page
lcdClear();
lcdPrint("Config");
lcdSetCrsrX(60);
lcdPrint("[");
lcdPrint(IntToStr((current_offset/visible_lines)+1,1,0));
lcdPrint("/");
lcdPrint(IntToStr(((numentries-1)/visible_lines)+1,1,0));
lcdPrint("]");
lcdNl();
lcdNl();
uint8_t j=0;
for (uint8_t i=0;i<current_offset;i++)
while (the_config[++j].disabled);
uint8_t t=0;
for (uint8_t i=0;i<menuselection;i++)
while (the_config[++t].disabled);
for (uint8_t i = current_offset; i < (visible_lines + current_offset) && i < numentries; i++,j++) {
while(the_config[j].disabled)j++;
if(i==0){
lcdPrintln("Save changes:");
if (i == t)
lcdPrint("*");
lcdSetCrsrX(14);
if (i == t)
lcdPrintln("YES");
else
lcdPrintln("no");
}else{
lcdPrintln(the_config[j].name);
if (j == t)
lcdPrint("*");
lcdSetCrsrX(14);
lcdPrint("<");
lcdPrint(IntToStr(the_config[j].value,3,F_LONG));
lcdPrintln(">");
};
lcdRefresh();
}
switch (getInputWaitRepeat()) {
case BTN_UP:
menuselection--;
if (menuselection < current_offset) {
if (menuselection < 0) {
menuselection = numentries-1;
current_offset = ((numentries-1)/visible_lines) * visible_lines;
} else {
current_offset -= visible_lines;
}
}
break;
case BTN_DOWN:
menuselection++;
if (menuselection > (current_offset + visible_lines-1) || menuselection >= numentries) {
if (menuselection >= numentries) {
menuselection = 0;
current_offset = 0;
} else {
current_offset += visible_lines;
}
}
break;
case BTN_LEFT:
if(the_config[t].value >
the_config[t].min)
the_config[t].value--;
if(the_config[t].value > the_config[t].max)
the_config[t].value=
the_config[t].max;
applyConfig();
break;
case BTN_RIGHT:
if(the_config[t].value <
the_config[t].max)
the_config[t].value++;
if(the_config[t].value < the_config[t].min)
the_config[t].value=
the_config[t].min;
applyConfig();
break;
case BTN_ENTER:
if(menuselection==0)
saveConfig();
return;
}
}
/* NOTREACHED */
}
PluginLoader::~PluginLoader() {
saveConfig();
unloadPlugins();
}
void CalibrationMain::on_SaveConfigButton_clicked()
{
saveConfig(currentFile);
}
void MultiLayerBGS::process(const cv::Mat &img_input, cv::Mat &img_output, cv::Mat &img_bgmodel)
{
if (img_input.empty())
return;
loadConfig();
CvSize img_size = cvSize(cvCeil((double)img_input.size().width), cvCeil((double)img_input.size().height));
if (firstTime)
{
if (disableDetectMode)
status = MLBGS_LEARN;
if (status == MLBGS_LEARN)
std::cout << "MultiLayerBGS in LEARN mode" << std::endl;
if (status == MLBGS_DETECT)
std::cout << "MultiLayerBGS in DETECT mode" << std::endl;
org_img = new IplImage(img_input);
fg_img = cvCreateImage(img_size, org_img->depth, org_img->nChannels);
bg_img = cvCreateImage(img_size, org_img->depth, org_img->nChannels);
fg_prob_img = cvCreateImage(img_size, org_img->depth, 1);
fg_mask_img = cvCreateImage(img_size, org_img->depth, 1);
fg_prob_img3 = cvCreateImage(img_size, org_img->depth, org_img->nChannels);
merged_img = cvCreateImage(cvSize(img_size.width * 2, img_size.height * 2), org_img->depth, org_img->nChannels);
BGS = new CMultiLayerBGS();
BGS->Init(img_size.width, img_size.height);
BGS->SetForegroundMaskImage(fg_mask_img);
BGS->SetForegroundProbImage(fg_prob_img);
if (bg_model_preload.empty() == false)
{
std::cout << "MultiLayerBGS loading background model: " << bg_model_preload << std::endl;
BGS->Load(bg_model_preload.c_str());
}
if (status == MLBGS_DETECT)
{
BGS->m_disableLearning = disableLearning;
if (disableLearning)
std::cout << "MultiLayerBGS disabled learning in DETECT mode" << std::endl;
else
std::cout << "MultiLayerBGS enabled learning in DETECT mode" << std::endl;
}
if (loadDefaultParams)
{
std::cout << "MultiLayerBGS loading default params" << std::endl;
max_mode_num = 5;
weight_updating_constant = 5.0;
texture_weight = 0.5;
bg_mode_percent = 0.6f;
pattern_neig_half_size = 4;
pattern_neig_gaus_sigma = 3.0f;
bg_prob_threshold = 0.2f;
bg_prob_updating_threshold = 0.2f;
robust_LBP_constant = 3;
min_noised_angle = 10.0 / 180.0 * PI; //0,01768
shadow_rate = 0.6f;
highlight_rate = 1.2f;
bilater_filter_sigma_s = 3.0f;
bilater_filter_sigma_r = 0.1f;
}
else
std::cout << "MultiLayerBGS loading config params" << std::endl;
BGS->m_nMaxLBPModeNum = max_mode_num;
BGS->m_fWeightUpdatingConstant = weight_updating_constant;
BGS->m_fTextureWeight = texture_weight;
BGS->m_fBackgroundModelPercent = bg_mode_percent;
BGS->m_nPatternDistSmoothNeigHalfSize = pattern_neig_half_size;
BGS->m_fPatternDistConvGaussianSigma = pattern_neig_gaus_sigma;
BGS->m_fPatternColorDistBgThreshold = bg_prob_threshold;
BGS->m_fPatternColorDistBgUpdatedThreshold = bg_prob_updating_threshold;
BGS->m_fRobustColorOffset = robust_LBP_constant;
BGS->m_fMinNoisedAngle = min_noised_angle;
BGS->m_fRobustShadowRate = shadow_rate;
BGS->m_fRobustHighlightRate = highlight_rate;
BGS->m_fSigmaS = bilater_filter_sigma_s;
BGS->m_fSigmaR = bilater_filter_sigma_r;
if (loadDefaultParams)
{
//frame_duration = 1.0 / 30.0;
//frame_duration = 1.0 / 25.0;
frame_duration = 1.0f / 10.0f;
}
BGS->SetFrameRate(frame_duration);
if (status == MLBGS_LEARN)
{
if (loadDefaultParams)
{
mode_learn_rate_per_second = 0.5;
weight_learn_rate_per_second = 0.5;
init_mode_weight = 0.05f;
}
else
{
mode_learn_rate_per_second = learn_mode_learn_rate_per_second;
weight_learn_rate_per_second = learn_weight_learn_rate_per_second;
init_mode_weight = learn_init_mode_weight;
}
}
if (status == MLBGS_DETECT)
{
if (loadDefaultParams)
{
mode_learn_rate_per_second = 0.01f;
weight_learn_rate_per_second = 0.01f;
init_mode_weight = 0.001f;
}
else
{
mode_learn_rate_per_second = detect_mode_learn_rate_per_second;
weight_learn_rate_per_second = detect_weight_learn_rate_per_second;
init_mode_weight = detect_init_mode_weight;
}
}
BGS->SetParameters(max_mode_num, mode_learn_rate_per_second, weight_learn_rate_per_second, init_mode_weight);
saveConfig();
delete org_img;
}
//IplImage* inputImage = new IplImage(img_input);
//IplImage* img = cvCreateImage(img_size, IPL_DEPTH_8U, 3);
//cvCopy(inputImage, img);
//delete inputImage;
if (detectAfter > 0 && detectAfter == frameNumber)
{
std::cout << "MultiLayerBGS in DETECT mode" << std::endl;
status = MLBGS_DETECT;
mode_learn_rate_per_second = 0.01f;
weight_learn_rate_per_second = 0.01f;
init_mode_weight = 0.001f;
BGS->SetParameters(max_mode_num, mode_learn_rate_per_second, weight_learn_rate_per_second, init_mode_weight);
BGS->m_disableLearning = disableLearning;
if (disableLearning)
std::cout << "MultiLayerBGS disabled learning in DETECT mode" << std::endl;
else
std::cout << "MultiLayerBGS enabled learning in DETECT mode" << std::endl;
}
IplImage* img = new IplImage(img_input);
BGS->SetRGBInputImage(img);
BGS->Process();
BGS->GetBackgroundImage(bg_img);
BGS->GetForegroundImage(fg_img);
BGS->GetForegroundProbabilityImage(fg_prob_img3);
BGS->GetForegroundMaskImage(fg_mask_img);
BGS->MergeImages(4, img, bg_img, fg_prob_img3, fg_img, merged_img);
img_merged = cv::Mat(merged_img);
img_foreground = cv::Mat(fg_mask_img);
img_background = cv::Mat(bg_img);
if (showOutput)
{
//cv::imshow("MLBGS Layers", img_merged);
// cv::imshow("MLBGS FG Mask", img_foreground);
}
img_foreground.copyTo(img_output);
img_background.copyTo(img_bgmodel);
delete img;
//cvReleaseImage(&img);
firstTime = false;
frameNumber++;
}
void Config::save() const
{
char filename[MAX_STRING_SIZE];
getConfigFileName(filename, MAX_STRING_SIZE);
saveConfig(filename);
}
bool MICCD::SetFilterNames()
{
// Cannot save it in hardware, so let's just save it in the config file to be loaded later
saveConfig();
return true;
}
void T2FMRF_UM::process(const cv::Mat &img_input, cv::Mat &img_output, cv::Mat &img_bgmodel)
{
if(img_input.empty())
return;
loadConfig();
if(firstTime)
saveConfig();
frame = new IplImage(img_input);
if(firstTime)
frame_data.ReleaseMemory(false);
frame_data = frame;
if(firstTime)
{
int width = img_input.size().width;
int height = img_input.size().height;
lowThresholdMask = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 1);
lowThresholdMask.Ptr()->origin = IPL_ORIGIN_BL;
highThresholdMask = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 1);
highThresholdMask.Ptr()->origin = IPL_ORIGIN_BL;
params.SetFrameSize(width, height);
params.LowThreshold() = threshold;
params.HighThreshold() = 2*params.LowThreshold();
params.Alpha() = alpha;
params.MaxModes() = gaussians;
params.Type() = TYPE_T2FMRF_UM;
params.KM() = km; // Factor control for the T2FMRF-UM [0,3] default: 2
params.KV() = kv; // Factor control for the T2FMRF-UV [0.3,1] default: 0.9
bgs.Initalize(params);
bgs.InitModel(frame_data);
old_labeling = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 1);
old = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 1);
mrf.height = height;
mrf.width = width;
mrf.Build_Classes_OldLabeling_InImage_LocalEnergy();
firstTime = false;
}
bgs.Subtract(frameNumber, frame_data, lowThresholdMask, highThresholdMask);
cvCopy(lowThresholdMask.Ptr(), old);
/************************************************************************/
/* the code for MRF, it can be noted when using other methods */
/************************************************************************/
//the optimization process is done when the foreground detection is stable,
if(frameNumber >= 10)
{
gmm = bgs.gmm();
hmm = bgs.hmm();
mrf.background2 = frame_data.Ptr();
mrf.in_image = lowThresholdMask.Ptr();
mrf.out_image = lowThresholdMask.Ptr();
mrf.InitEvidence2(gmm,hmm,old_labeling);
mrf.ICM2();
cvCopy(mrf.out_image, lowThresholdMask.Ptr());
}
cvCopy(old, old_labeling);
lowThresholdMask.Clear();
bgs.Update(frameNumber, frame_data, lowThresholdMask);
cv::Mat foreground(highThresholdMask.Ptr());
if(showOutput)
cv::imshow("T2FMRF-UM", foreground);
foreground.copyTo(img_output);
delete frame;
frameNumber++;
}
void VehicleCouting::process()
{
if(idspeeds.size()>0){
idspeeds.clear();
}
if(img_input.empty())
return;
img_w = img_input.size().width;
img_h = img_input.size().height;
loadConfig();
//--------------------------------------------------------------------------
if(FAV1::use_roi == true && FAV1::roi_defined == false && firstTime == true)
{
do
{
cv::putText(img_input, "Please, set the counting line", cv::Point(10,15), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(0,0,255));
cv::imshow("VehicleCouting", img_input);
FAV1::img_input1 = new IplImage(img_input);
cvSetMouseCallback("VehicleCouting", FAV1::VehicleCouting_on_mouse, NULL);
key = cvWaitKey(0);
delete FAV1::img_input1;
if(FAV1::roi_defined)
{
std::cout << "Counting line defined (" << FAV1::roi_x0 << "," << FAV1::roi_y0 << "," << FAV1::roi_x1 << "," << FAV1::roi_y1 << ")" << std::endl;
break;
}
else
std::cout << "Counting line undefined!" << std::endl;
}while(1);
}
if(FAV1::use_roi == true && FAV1::roi_defined == true)
cv::line(img_input, cv::Point(FAV1::roi_x0,FAV1::roi_y0), cv::Point(FAV1::roi_x1,FAV1::roi_y1), cv::Scalar(0,0,255));
bool ROI_OK = false;
if(FAV1::use_roi == true && FAV1::roi_defined == true)
ROI_OK = true;
if(ROI_OK)
{
LaneOrientation = LO_NONE;
if(abs(FAV1::roi_x0 - FAV1::roi_x1) < abs(FAV1::roi_y0 - FAV1::roi_y1))
{
if(!firstTime)
cv::putText(img_input, "HORIZONTAL", cv::Point(10,15), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
LaneOrientation = LO_HORIZONTAL;
cv::putText(img_input, "(A)", cv::Point(FAV1::roi_x0-32,FAV1::roi_y0), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
cv::putText(img_input, "(B)", cv::Point(FAV1::roi_x0+12,FAV1::roi_y0), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
}
if(abs(FAV1::roi_x0 - FAV1::roi_x1) > abs(FAV1::roi_y0 - FAV1::roi_y1))
{
if(!firstTime)
cv::putText(img_input, "VERTICAL", cv::Point(10,15), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
LaneOrientation = LO_VERTICAL;
cv::putText(img_input, "(A)", cv::Point(FAV1::roi_x0,FAV1::roi_y0+22), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
cv::putText(img_input, "(B)", cv::Point(FAV1::roi_x0,FAV1::roi_y0-12), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
}
}
//--------------------------------------------------------------------------
for(std::map<cvb::CvID,cvb::CvTrack*>::iterator it = tracks.begin() ; it != tracks.end(); it++)
{
//std::cout << (*it).first << " => " << (*it).second << std::endl;
cvb::CvID id = (*it).first;
cvb::CvTrack* track = (*it).second;
CvPoint2D64f centroid = track->centroid;
// std::cout << "---------------------------------------------------------------" << std::endl;
// std::cout << "0)id:" << id << " (" << centroid.x << "," << centroid.y << ")" << std::endl;
// std::cout << "track->active:" << track->active << std::endl;
// std::cout << "track->inactive:" << track->inactive << std::endl;
// std::cout << "track->lifetime:" << track->lifetime << std::endl;
if(1==track->lifetime)
{
// std::map<cvb::CvID, CarSpeed>::iterator speedit2 =carspeeds.find(id);
// if(speedit2 != NULL){
// }
// CarSpeed carspeed2 =speedit->second;
// time(&end);
// carspeed2.lasttime = end;
// carspeed2.lastcentroid = centroid;
// carspeeds.insert(std::pair<cvb::CvID, CarSpeed>(id,carspeed2));
// std::cout<<"lifetime==1-----------------------------------------";
CarSpeed carspeed;
time(&start);
carspeed.starttime = start;
carspeed.startcentroid = centroid;
std::map<cvb::CvID, CarSpeed>::iterator speeditupdatestartcentroid =carspeeds.find(id);
if(speeditupdatestartcentroid != carspeeds.end()){
carspeeds.erase(speeditupdatestartcentroid);
carspeeds.insert(std::pair<cvb::CvID, CarSpeed>(id,carspeed));
}else{
carspeeds.insert(std::pair<cvb::CvID, CarSpeed>(id,carspeed));
}
}
// if(1==track->active )
// {
// time(&start);
// startpoint=centroid;
// }
//----------------------------------------------------------------------------
if(track->inactive == 0)
{
if(positions.count(id) > 0)
{
std::map<cvb::CvID, VehiclePosition>::iterator it2 = positions.find(id);
VehiclePosition old_position = it2->second;
VehiclePosition current_position = getVehiclePosition(centroid);
if(current_position != old_position)
{
if(old_position == VP_A && current_position == VP_B)
countAB++;
if(old_position == VP_B && current_position == VP_A)
countBA++;
positions.erase(positions.find(id));
}
}
else
{
VehiclePosition vehiclePosition = getVehiclePosition(centroid);
if(vehiclePosition != VP_NONE)
positions.insert(std::pair<cvb::CvID, VehiclePosition>(id,vehiclePosition));
}
}
else
{
if(positions.count(id) > 0)
positions.erase(positions.find(id));
}
//----------------------------------------------------------------------------
if(points.count(id) > 0)
{
std::map<cvb::CvID, std::vector<CvPoint2D64f>>::iterator it2 = points.find(id);
std::vector<CvPoint2D64f> centroids = it2->second;
// if (centroids.size()==1){
// time(&start);
// }
std::vector<CvPoint2D64f> centroids2;
if(track->inactive == 0 && centroids.size() < 30)
{
centroids2.push_back(centroid); // the latest center point
// std::map<cvb::CvID, CarSpeed>::iterator speedit =carspeeds.find(id);
// CarSpeed carspeed2 =speedit->second;
// time(&end);
// carspeed2.lasttime = end;
// carspeed2.lastcentroid = centroid;
// carspeeds.insert(std::pair<cvb::CvID, CarSpeed>(id,carspeed2));
// std::cout << "latest center point...id:" << id <<" cost time: "<<difftime(carspeed2.lasttime,carspeed2.starttime) << " (" << carspeed2.startcentroid.x << "," << carspeed2.startcentroid.y << ")" << " (" << carspeed2.lastcentroid.x << "," << carspeed2.lastcentroid.y << ")" << std::endl;
// carspeeds.erase(speedit);
for(std::vector<CvPoint2D64f>::iterator it3 = centroids.begin() ; it3 != centroids.end(); it3++)
{
centroids2.push_back(*it3);
}
for(std::vector<CvPoint2D64f>::iterator it3 = centroids2.begin() ; it3 != centroids2.end(); it3++)
{
cv::circle(img_input, cv::Point((*it3).x,(*it3).y), 3, cv::Scalar(255,255,255), -1);
}
points.erase(it2);
points.insert(std::pair<cvb::CvID, std::vector<CvPoint2D64f>>(id,centroids2));
}
else
{
points.erase(it2);
}
}
else
{
if(track->inactive == 0)
{
std::vector<CvPoint2D64f> centroids;
centroids.push_back(centroid);
// time(&start);
points.insert(std::pair<cvb::CvID, std::vector<CvPoint2D64f>>(id,centroids));
}
//
std::map<cvb::CvID, CarSpeed>::iterator speedit =carspeeds.find(id);
CarSpeed carspeed2 =speedit->second;
time(&end);
carspeed2.lasttime = end;
carspeed2.lastcentroid = centroid;
carspeeds.insert(std::pair<cvb::CvID, CarSpeed>(id,carspeed2));
// std::cout << "latest center point...id:" << id <<" cost time: "<<difftime(carspeed2.lasttime,carspeed2.starttime) << " (" << carspeed2.startcentroid.x << "," << carspeed2.startcentroid.y << ")" << " (" << carspeed2.lastcentroid.x << "," << carspeed2.lastcentroid.y << ")" << std::endl;
//
if(difftime(carspeed2.lasttime,carspeed2.starttime)>0){
double costtime =difftime(carspeed2.lasttime,carspeed2.starttime);
double distance =sqrt((carspeed2.startcentroid.y - carspeed2.lastcentroid.y) *(carspeed2.startcentroid.y - carspeed2.lastcentroid.y)+(carspeed2.startcentroid.x - carspeed2.lastcentroid.x)*(carspeed2.startcentroid.x - carspeed2.lastcentroid.x));
// std::cout<<"ID:"<<id<<" Distance: "<<distance<<" Time: "<<costtime<<" speed: "<<distance/costtime<<std::endl;
IdSpeed is;
is.id=id;
is.speed=distance/costtime;
idspeeds.push_back(is);
}
}
// time(&end);
// double sec=difftime(end,start);
endpoint = centroid;
// double distance =sqrt((endpoint.y-startpoint.y) *(endpoint.y-startpoint.y)+(endpoint.x-startpoint.x)*(endpoint.x-startpoint.x));
// std::cout <<"track->id:"<<track->id << " track->lifetime: " << track->lifetime ;
// printf("distance : %f ",distance);
// printf("time cost: %lf \n ",sec);
//cv::waitKey(0);
}
//--------------------------------------------------------------------------
// std::cout<<"endtime"<<std::endl;
time(&endtime);
//if 30 second has passed ,please recount the car num.
if(difftime(endtime,origintime)>30){
std::cout<<"30 seconds has passed"<<std::endl;
countAB=0;
countBA=0;
std::cout<<"restarttime"<<std::endl;
time(&origintime);
}
if(showAB == 0)
{
cv::putText(img_input, "A->B: " + boost::lexical_cast<std::string>(countAB), cv::Point(10,img_h-20), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
cv::putText(img_input, "B->A: " + boost::lexical_cast<std::string>(countBA), cv::Point(10,img_h-8), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
}
if(showAB == 1){
cv::putText(img_input, "A->B: " + boost::lexical_cast<std::string>(countAB), cv::Point(10,img_h-8), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
}
if(showAB == 2)
{
cv::putText(img_input, "B->A: " + boost::lexical_cast<std::string>(countBA), cv::Point(10,img_h-8), cv::FONT_HERSHEY_PLAIN, 1, cv::Scalar(255,255,255));
}
if(showOutput)
cv::imshow("VehicleCouting", img_input);
if(firstTime)
saveConfig();
firstTime = false;
}
PRL_RESULT CDspDispConfigGuard::saveConfig( bool bNoSaveNetwork )
{
QString path = ParallelsDirs::getDispatcherConfigFilePath();
return saveConfig( path, bNoSaveNetwork );
}
ApokalypseApp::~ApokalypseApp(){
if (screen) delete screen;
if (!configfile.isEmpty())
saveConfig();
}
int realmain(int argc, char *argv[])
{
wzMain(argc, argv);
int utfargc = argc;
const char** utfargv = (const char**)argv;
#ifdef WZ_OS_MAC
cocoaInit();
#endif
debug_init();
debug_register_callback( debug_callback_stderr, NULL, NULL, NULL );
#if defined(WZ_OS_WIN) && defined(DEBUG_INSANE)
debug_register_callback( debug_callback_win32debug, NULL, NULL, NULL );
#endif // WZ_OS_WIN && DEBUG_INSANE
// *****
// NOTE: Try *NOT* to use debug() output routines without some other method of informing the user. All this output is sent to /dev/nul at this point on some platforms!
// *****
if (!getUTF8CmdLine(&utfargc, &utfargv))
{
return EXIT_FAILURE;
}
QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8")); // make Qt treat all C strings in Warzone as UTF-8
setupExceptionHandler(utfargc, utfargv, version_getFormattedVersionString());
/*** Initialize PhysicsFS ***/
initialize_PhysicsFS(utfargv[0]);
/*** Initialize translations ***/
initI18n();
// find early boot info
if (!ParseCommandLineEarly(utfargc, utfargv))
{
return EXIT_FAILURE;
}
/* Initialize the write/config directory for PhysicsFS.
* This needs to be done __after__ the early commandline parsing,
* because the user might tell us to use an alternative configuration
* directory.
*/
initialize_ConfigDir();
/*** Initialize directory structure ***/
make_dir(ScreenDumpPath, "screenshots", NULL);
make_dir(SaveGamePath, "savegames", NULL);
PHYSFS_mkdir("savegames/campaign");
PHYSFS_mkdir("savegames/skirmish");
make_dir(MultiCustomMapsPath, "maps", NULL); // MUST have this to prevent crashes when getting map
PHYSFS_mkdir("music");
PHYSFS_mkdir("logs"); // a place to hold our netplay, mingw crash reports & WZ logs
PHYSFS_mkdir("userdata"); // a place to store per-mod data user generated data
memset(rulesettag, 0, sizeof(rulesettag)); // tag to add to userdata to find user generated stuff
make_dir(MultiPlayersPath, "multiplay", NULL);
make_dir(MultiPlayersPath, "multiplay", "players");
if (!customDebugfile)
{
// there was no custom debug file specified (--debug-file=blah)
// so we use our write directory to store our logs.
time_t aclock;
struct tm *newtime;
char buf[PATH_MAX];
time( &aclock ); // Get time in seconds
newtime = localtime( &aclock ); // Convert time to struct
// Note: We are using fopen(), and not physfs routines to open the file
// log name is logs/(or \)WZlog-MMDD_HHMMSS.txt
snprintf(buf, sizeof(buf), "%slogs%sWZlog-%02d%02d_%02d%02d%02d.txt", PHYSFS_getWriteDir(), PHYSFS_getDirSeparator(),
newtime->tm_mon + 1, newtime->tm_mday, newtime->tm_hour, newtime->tm_min, newtime->tm_sec );
debug_register_callback( debug_callback_file, debug_callback_file_init, debug_callback_file_exit, buf );
// FIXME: Change this to LOG_WZ on next release
debug(LOG_INFO, "Using %s debug file", buf);
}
// NOTE: it is now safe to use debug() calls to make sure output gets captured.
check_Physfs();
debug(LOG_WZ, "Warzone 2100 - %s", version_getFormattedVersionString());
debug(LOG_WZ, "Using language: %s", getLanguage());
debug(LOG_WZ, "Backend: %s", BACKEND);
debug(LOG_MEMORY, "sizeof: SIMPLE_OBJECT=%ld, BASE_OBJECT=%ld, DROID=%ld, STRUCTURE=%ld, FEATURE=%ld, PROJECTILE=%ld",
(long)sizeof(SIMPLE_OBJECT), (long)sizeof(BASE_OBJECT), (long)sizeof(DROID), (long)sizeof(STRUCTURE), (long)sizeof(FEATURE), (long)sizeof(PROJECTILE));
/* Put in the writedir root */
sstrcpy(KeyMapPath, "keymap.map");
// initialise all the command line states
war_SetDefaultStates();
debug(LOG_MAIN, "initializing");
PhysicsEngineHandler engine; // register abstract physfs filesystem
loadConfig();
// parse the command line
if (!ParseCommandLine(utfargc, utfargv))
{
return EXIT_FAILURE;
}
// Save new (commandline) settings
saveConfig();
// Find out where to find the data
scanDataDirs();
// Now we check the mods to see if they exist or not (specified on the command line)
// They are all capped at 100 mods max(see clparse.c)
// FIX ME: I know this is a bit hackish, but better than nothing for now?
{
char *modname;
char modtocheck[256];
int i = 0;
int result = 0;
// check global mods
for(i=0; i < 100; i++)
{
modname = global_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/global/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The (global) mod (%s) you have specified doesn't exist!", modname);
}
else
{
info("(global) mod (%s) is enabled", modname);
}
}
// check campaign mods
for(i=0; i < 100; i++)
{
modname = campaign_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/campaign/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_ca (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_ca (%s) is enabled", modname);
}
}
// check multiplay mods
for(i=0; i < 100; i++)
{
modname = multiplay_mods[i];
if (modname == NULL)
{
break;
}
ssprintf(modtocheck, "mods/multiplay/%s", modname);
result = PHYSFS_exists(modtocheck);
result |= PHYSFS_isDirectory(modtocheck);
if (!result)
{
debug(LOG_ERROR, "The mod_mp (%s) you have specified doesn't exist!", modname);
}
else
{
info("mod_mp (%s) is enabled", modname);
}
}
}
if (!wzMain2())
{
return EXIT_FAILURE;
}
int w = pie_GetVideoBufferWidth();
int h = pie_GetVideoBufferHeight();
char buf[256];
ssprintf(buf, "Video Mode %d x %d (%s)", w, h, war_getFullscreen() ? "fullscreen" : "window");
addDumpInfo(buf);
debug(LOG_MAIN, "Final initialization");
if (!frameInitialise())
{
return EXIT_FAILURE;
}
war_SetWidth(pie_GetVideoBufferWidth());
war_SetHeight(pie_GetVideoBufferHeight());
// Fix up settings from the config file
// And initialize shader usage setting
if (!pie_GetShaderAvailability())
{
war_SetShaders(FALLBACK);
pie_SetShaderUsage(false);
}
else
{
if (war_GetShaders() == FALLBACK)
{
war_SetShaders(SHADERS_OFF);
}
if (!pie_GetFallbackAvailability())
{
war_SetShaders(SHADERS_ONLY);
pie_SetShaderUsage(true);
}
else if (war_GetShaders() == SHADERS_ONLY || war_GetShaders() == SHADERS_ON)
{
war_SetShaders(SHADERS_ON);
pie_SetShaderUsage(true);
}
else // (war_GetShaders() == SHADERS_OFF)
{
pie_SetShaderUsage(false);
}
}
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
pal_Init();
pie_LoadBackDrop(SCREEN_RANDOMBDROP);
pie_SetFogStatus(false);
pie_ScreenFlip(CLEAR_BLACK);
if (!systemInitialise())
{
return EXIT_FAILURE;
}
//set all the pause states to false
setAllPauseStates(false);
// Copy this info to be used by the crash handler for the dump file
ssprintf(buf,"Using Backend: %s", BACKEND);
addDumpInfo(buf);
ssprintf(buf,"Using language: %s", getLanguageName());
addDumpInfo(buf);
// Do the game mode specific initialisation.
switch(GetGameMode())
{
case GS_TITLE_SCREEN:
startTitleLoop();
break;
case GS_SAVEGAMELOAD:
initSaveGameLoad();
break;
case GS_NORMAL:
startGameLoop();
break;
default:
debug(LOG_ERROR, "Weirdy game status, I'm afraid!!");
break;
}
#if defined(WZ_CC_MSVC) && defined(DEBUG)
debug_MEMSTATS();
#endif
debug(LOG_MAIN, "Entering main loop");
wzMain3();
saveConfig();
systemShutdown();
#ifdef WZ_OS_WIN // clean up the memory allocated for the command line conversion
for (int i=0; i<argc; i++)
{
const char*** const utfargvF = &utfargv;
free((void *)(*utfargvF)[i]);
}
free(utfargv);
#endif
wzShutdown();
debug(LOG_MAIN, "Completed shutting down Warzone 2100");
return EXIT_SUCCESS;
}
KChatBaseModel::~KChatBaseModel()
{
// kDebug(11000) << "KChatBaseModelPrivate: DESTRUCT (" << this << ")";
saveConfig();
}
bool QHYCCD::ISNewNumber(const char *dev, const char *name, double values[], char *names[], int n)
{
// first check if it's for our device
//IDLog("INDI::CCD::ISNewNumber %s\n",name);
if (dev != nullptr && strcmp(dev, getDeviceName()) == 0)
{
if (strcmp(name, FilterSlotNP.name) == 0)
{
INDI::FilterInterface::processNumber(dev, name, values, names, n);
return true;
}
if (strcmp(name, GainNP.name) == 0)
{
IUUpdateNumber(&GainNP, values, names, n);
GainRequest = GainN[0].value;
if (LastGainRequest != GainRequest)
{
SetQHYCCDParam(camhandle, CONTROL_GAIN, GainN[0].value);
LastGainRequest = GainRequest;
}
DEBUGF(INDI::Logger::DBG_SESSION, "Current %s value %f", GainNP.name, GainN[0].value);
GainNP.s = IPS_OK;
IDSetNumber(&GainNP, NULL);
return true;
}
if (strcmp(name, OffsetNP.name) == 0)
{
IUUpdateNumber(&OffsetNP, values, names, n);
SetQHYCCDParam(camhandle, CONTROL_OFFSET, OffsetN[0].value);
DEBUGF(INDI::Logger::DBG_SESSION, "Current %s value %f", OffsetNP.name, OffsetN[0].value);
OffsetNP.s = IPS_OK;
IDSetNumber(&OffsetNP, NULL);
saveConfig(true, OffsetNP.name);
return true;
}
if (strcmp(name, SpeedNP.name) == 0)
{
IUUpdateNumber(&SpeedNP, values, names, n);
SetQHYCCDParam(camhandle, CONTROL_SPEED, SpeedN[0].value);
DEBUGF(INDI::Logger::DBG_SESSION, "Current %s value %f", SpeedNP.name, SpeedN[0].value);
SpeedNP.s = IPS_OK;
IDSetNumber(&SpeedNP, NULL);
saveConfig(true, SpeedNP.name);
return true;
}
if (strcmp(name, USBTrafficNP.name) == 0)
{
IUUpdateNumber(&USBTrafficNP, values, names, n);
SetQHYCCDParam(camhandle, CONTROL_USBTRAFFIC, USBTrafficN[0].value);
DEBUGF(INDI::Logger::DBG_SESSION, "Current %s value %f", USBTrafficNP.name, USBTrafficN[0].value);
USBTrafficNP.s = IPS_OK;
IDSetNumber(&USBTrafficNP, NULL);
saveConfig(true, USBTrafficNP.name);
return true;
}
}
// if we didn't process it, continue up the chain, let somebody else
// give it a shot
return INDI::CCD::ISNewNumber(dev, name, values, names, n);
}
/*! \brief Load new configuration.
* \param cfgfile
* \returns True if config is OK, False if not (e.g. no input device specified).
*
* If cfgfile is an absolute path it will be used as is, otherwise it is assumed to be the
* name of a file under m_cfg_dir.
*
* If cfgfile does not exist it will be created.
*
* If no input device is specified, we return false to signal that the I/O configuration
* dialog should be run.
*
* FIXME: Refactor.
*/
bool MainWindow::loadConfig(const QString cfgfile, bool check_crash)
{
bool conf_ok = false;
bool skipLoadingSettings = false;
qDebug() << "Loading configuration from:" << cfgfile;
if (m_settings)
delete m_settings;
if (QDir::isAbsolutePath(cfgfile))
m_settings = new QSettings(cfgfile, QSettings::IniFormat);
else
m_settings = new QSettings(QString("%1/%2").arg(m_cfg_dir).arg(cfgfile), QSettings::IniFormat);
qDebug() << "Configuration file:" << m_settings->fileName();
if (check_crash)
{
if (m_settings->value("crashed", false).toBool())
{
qDebug() << "Crash guard triggered!" << endl;
QMessageBox* askUserAboutConfig =
new QMessageBox(QMessageBox::Warning, tr("Crash Detected!"),
tr("<p>Gqrx has detected problems with the current configuration. "
"Loading the configuration again could cause the application to crash.</p>"
"<p>Do you want to edit the settings?</p>"),
QMessageBox::Yes | QMessageBox::No);
askUserAboutConfig->setDefaultButton(QMessageBox::Yes);
askUserAboutConfig->setTextFormat(Qt::RichText);
askUserAboutConfig->exec();
if (askUserAboutConfig->result() == QMessageBox::Yes)
skipLoadingSettings = true;
delete askUserAboutConfig;
}
else
{
m_settings->setValue("crashed", true); // clean exit will set this to FALSE
saveConfig(cfgfile);
}
}
if (skipLoadingSettings)
return false;
emit configChanged(m_settings);
// manual reconf (FIXME: check status)
bool conv_ok = false;
QString indev = m_settings->value("input/device", "").toString();
if (!indev.isEmpty())
{
conf_ok = true;
rx->set_input_device(indev.toStdString());
// Update window title
QRegExp regexp("'([a-zA-Z0-9 \\-\\_\\/\\.\\,\\(\\)]+)'");
QString devlabel;
if (regexp.indexIn(indev, 0) != -1)
devlabel = regexp.cap(1);
else
devlabel = indev; //"Unknown";
setWindowTitle(QString("Gqrx %1 - %2").arg(VERSION).arg(devlabel));
// Add available antenna connectors to the UI
std::vector<std::string> antennas = rx->get_antennas();
uiDockInputCtl->setAntennas(antennas);
}
QString outdev = m_settings->value("output/device", "").toString();
rx->set_output_device(outdev.toStdString());
int sr = m_settings->value("input/sample_rate", 0).toInt(&conv_ok);
if (conv_ok && (sr > 0))
{
double actual_rate = rx->set_input_rate(sr);
qDebug() << "Requested sample rate:" << sr;
qDebug() << "Actual sample rate :" << QString("%1").arg(actual_rate, 0, 'f', 6);
uiDockRxOpt->setFilterOffsetRange((qint64)(0.9*actual_rate));
ui->plotter->setSampleRate(actual_rate);
ui->plotter->setSpanFreq((quint32)actual_rate);
}
uiDockInputCtl->readSettings(m_settings);
uiDockRxOpt->readSettings(m_settings);
uiDockFft->readSettings(m_settings);
uiDockAudio->readSettings(m_settings);
ui->freqCtrl->setFrequency(m_settings->value("input/frequency", 144500000).toLongLong(&conv_ok));
setNewFrequency(ui->freqCtrl->getFrequency()); // ensure all GUI and RF is updated
return conf_ok;
}
bool CConfigFile::saveConfig(const std::string & filename)
{
return saveConfig(filename.c_str());
}
void FuzzySugenoIntegral::process(const cv::Mat &img_input, cv::Mat &img_output)
{
if(img_input.empty())
return;
cv::Mat img_input_f3(img_input.size(), CV_32F);
img_input.convertTo(img_input_f3, CV_32F, 1./255.);
loadConfig();
if(firstTime)
{
std::cout << "FuzzySugenoIntegral parameters:" << std::endl;
std::string colorSpaceName = "";
switch(colorSpace)
{
case 1: colorSpaceName = "RGB"; break;
case 2: colorSpaceName = "OHTA"; break;
case 3: colorSpaceName = "HSV"; break;
case 4: colorSpaceName = "YCrCb"; break;
}
std::cout << "Color space: " << colorSpaceName << std::endl;
if(option == 1)
std::cout << "Fuzzing by 3 color components" << std::endl;
if(option == 2)
std::cout << "Fuzzing by 2 color components + 1 texture component" << std::endl;
saveConfig();
}
if(frameNumber <= framesToLearn)
{
if(frameNumber == 0)
std::cout << "FuzzySugenoIntegral initializing background model by adaptive learning..." << std::endl;
if(img_background_f3.empty())
img_input_f3.copyTo(img_background_f3);
else
img_background_f3 = alphaLearn*img_input_f3 + (1-alphaLearn)*img_background_f3;
if(showOutput)
cv::imshow("SI BG Model", img_background_f3);
}
else
{
cv::Mat img_input_f1;
cv::cvtColor(img_input_f3, img_input_f1, CV_BGR2GRAY);
cv::Mat img_background_f1;
cv::cvtColor(img_background_f3, img_background_f1, CV_BGR2GRAY);
IplImage* input_f3 = new IplImage(img_input_f3);
IplImage* input_f1 = new IplImage(img_input_f1);
IplImage* background_f3 = new IplImage(img_background_f3);
IplImage* background_f1 = new IplImage(img_background_f1);
IplImage* lbp_input_f1 = cvCreateImage(cvSize(input_f1->width, input_f1->height), IPL_DEPTH_32F, 1);
cvFillImage(lbp_input_f1, 0.0);
fu.LBP(input_f1, lbp_input_f1);
IplImage* lbp_background_f1 = cvCreateImage(cvSize(background_f1->width, background_f1->height), IPL_DEPTH_32F , 1);
cvFillImage(lbp_background_f1, 0.0);
fu.LBP(background_f1, lbp_background_f1);
IplImage* sim_texture_f1 = cvCreateImage(cvSize(input_f1->width, input_f1->height), IPL_DEPTH_32F, 1);
fu.SimilarityDegreesImage(lbp_input_f1, lbp_background_f1, sim_texture_f1, 1, colorSpace);
IplImage* sim_color_f3 = cvCreateImage(cvSize(input_f3->width, input_f3->height), IPL_DEPTH_32F, 3);
fu.SimilarityDegreesImage(input_f3, background_f3, sim_color_f3, 3, colorSpace);
float* measureG = (float*) malloc(3*(sizeof(float)));
IplImage* integral_sugeno_f1 = cvCreateImage(cvSize(input_f1->width, input_f1->height), IPL_DEPTH_32F, 1);
// 3 color components
if(option == 1)
{
fu.FuzzyMeasureG(0.4, 0.3, 0.3, measureG);
fu.getFuzzyIntegralSugeno(sim_texture_f1, sim_color_f3, option, measureG, integral_sugeno_f1);
}
// 2 color components + 1 texture component
if(option == 2)
{
fu.FuzzyMeasureG(0.6, 0.3, 0.1, measureG);
fu.getFuzzyIntegralSugeno(sim_texture_f1, sim_color_f3, option, measureG, integral_sugeno_f1);
}
free(measureG);
cv::Mat img_integral_sugeno_f1(integral_sugeno_f1);
if(smooth)
cv::medianBlur(img_integral_sugeno_f1, img_integral_sugeno_f1, 3);
cv::Mat img_foreground_f1(img_input.size(), CV_32F);
cv::threshold(img_integral_sugeno_f1, img_foreground_f1, threshold, 255, cv::THRESH_BINARY_INV);
cv::Mat img_foreground_u1(img_input.size(), CV_8U);
double minVal = 0., maxVal = 1.;
img_foreground_f1.convertTo(img_foreground_u1, CV_8U, 255.0/(maxVal - minVal), -minVal);
img_foreground_u1.copyTo(img_output);
if(showOutput)
{
cvShowImage("SI LBP Input", lbp_input_f1);
cvShowImage("SI LBP Background", lbp_background_f1);
cvShowImage("SI Prob FG Mask", integral_sugeno_f1);
cv::imshow("SI BG Model", img_background_f3);
cv::imshow("SI FG Mask", img_foreground_u1);
}
if(frameNumber == (framesToLearn + 1))
std::cout << "FuzzySugenoIntegral updating background model by adaptive-selective learning..." << std::endl;
IplImage* updated_background_f3 = cvCreateImage(cvSize(input_f1->width, input_f1->height), IPL_DEPTH_32F, 3);
cvFillImage(updated_background_f3, 0.0);
fu.AdaptativeSelectiveBackgroundModelUpdate(input_f3, background_f3, updated_background_f3, integral_sugeno_f1, threshold, alphaUpdate);
cv::Mat img_updated_background_f3(updated_background_f3);
img_updated_background_f3.copyTo(img_background_f3);
cvReleaseImage(&lbp_input_f1);
cvReleaseImage(&lbp_background_f1);
cvReleaseImage(&sim_texture_f1);
cvReleaseImage(&sim_color_f3);
cvReleaseImage(&integral_sugeno_f1);
cvReleaseImage(&updated_background_f3);
delete background_f1;
delete background_f3;
delete input_f1;
delete input_f3;
}
firstTime = false;
frameNumber++;
}
int Server::run(const char * ini)
{
readServerData(ini);
//clients = new Client[maxPlayers];
clients = vector<Client*>();
clients.reserve(maxPlayers);
for (int i = 0; i < maxPlayers; i++) {
clients.push_back(new Client());
clients[i]->setID(i);
}
double elapsedTime = 0.0;
double timePerFrame = 1000.0 / updateRate;
double timePerRenderFrame = 1000.0 / renderRefreshRate;
static double timeSinceLastRender = 0.0;
long lastTime = 0;
double targetSleep = 0.0;
double sleepRemainder = 0.0;
double startSleep = 0.0;
double sleepTime = 0.0;
loadConfig();
initSDL();
initGlew();
initBullet();
initGLContexts();
initObjects();
running = true;
HANDLE listenThreadHandle = HostListener::start();
loadResources();
loadLevel("asdf");
while (running) {
frameCount++;
if (GetAsyncKeyState(VK_ESCAPE) && (GetForegroundWindow() == consoleWindow) &&
MessageBox(0, "Shutdown the Server?", "Rune Server Shutdown", MB_YESNO) == IDYES) break;
lastTime = lastTime = SDL_GetTicks();
serverEventsTCP->clearSendBuffer();
serverEventsTCP->clearReceiveBuffer();
serverEventsUDP->clearSendBuffer();
serverEventsUDP->clearReceiveBuffer();
//Get all commands from clients
for (int i = 0; i < maxPlayers; i++) {
DataBuffer * temp;
aquireClientsMutex(i);
temp = clients[i]->popReceiveData();
if (!clients[i]->isConnected() && playerObjects->at(i) != NULL) {
int index = -1;
int x = 0;
for (list<pair<unsigned long, GameObject*>>::iterator iter = gameObjects->begin(); iter != gameObjects->end(); iter++) {
if (playerObjects->at(i) == iter->second) {
index = x;
break;
}
x++;
}
/*for (int x = 0; x < gameObjects->size(); x++) {
if (playerObjects->at(i) == gameObjects->at(x))
index = x;
}*/
gameObjects->remove(playerObjects->at(i)->getNetID());
delete playerObjects->at(i);
playerObjects->at(i) = NULL;
//gameObjects->erase(gameObjects->begin() + index);
serverEventsTCP->appendToSendBuffer(NetworkFunctions::createDeleteObjectBuffer(index));
}
releaseClientsMutex(i);
serverEventsTCP->appendToReceiveBuffer(temp);
}
//Receive All UDP Events
sockaddr_in * originAddress = NULL;
DataBuffer * udpBuffer = UDPManager::recvDatagram(&originAddress);
while (udpBuffer != NULL) {
//origin Address matches client address?
unsigned long packetFrameCount = 0;
memcpy(&packetFrameCount, udpBuffer->getData(), 4);
int clientID = getClientIDByAddress(originAddress->sin_addr.s_addr, originAddress->sin_port);
if (clientID == -1) {
int asdfadsfasdf = 123123;
}
else {
//compare clientFrameCount to client->frameCount
unsigned long clientFrameCount;
aquireClientsMutex(clientID);
clientFrameCount = clients[clientID]->getFrameCount();
releaseClientsMutex(clientID);
if (packetFrameCount < clientFrameCount) {
//discard
printf("Packet from Client %d discarded\n", clientID);
}
else {
serverEventsUDP->appendToReceiveBuffer(udpBuffer->getData() + 4, udpBuffer->getSize() - 4);
aquireClientsMutex(clientID);
clients[clientID]->setFrameCount(packetFrameCount);
releaseClientsMutex(clientID);
}
}
delete udpBuffer; udpBuffer = NULL;
delete originAddress; originAddress = NULL;
udpBuffer = UDPManager::recvDatagram(&originAddress);
}
NetworkFunctions::translateReceivedEvents(serverEventsTCP);
NetworkFunctions::translateReceivedEvents(serverEventsUDP);
//Execute my own gamelogic commands
SDL_Event e;
while (SDL_PollEvent(&e)) {
if (e.key.keysym.sym == SDLK_ESCAPE)
running = false;
if (e.key.keysym.sym == SDLK_m) {
((RigidObject*)gameObjects->getValue(2))->setPosition(5, 10, 0);
((RigidObject*)gameObjects->getValue(3))->setPosition(0, 10, 0);
((RigidObject*)gameObjects->getValue(4))->setPosition(-5, 10, 0);
((RigidObject*)gameObjects->getValue(2))->setVelocity(0, 0, 0);
((RigidObject*)gameObjects->getValue(3))->setVelocity(0, 0, 0);
((RigidObject*)gameObjects->getValue(4))->setVelocity(0, 0, 0);
((RigidObject*)gameObjects->getValue(2))->setGravity(0, -9.81f*4.0f, 0);
((RigidObject*)gameObjects->getValue(3))->setGravity(0, -9.81f*4.0f, 0);
((RigidObject*)gameObjects->getValue(4))->setGravity(0, -9.81f*4.0f, 0);
printf("reset boxes\n");
}
}
//if (update((long)(elapsedTime + sleepTime)) == -1) break;
//dynamicsWorld->stepSimulation((float)(elapsedTime + sleepTime)*0.001f, 50, (float)(elapsedTime + sleepTime)*0.001f);
dynamicsWorld->stepSimulation(1.0f / 64.0f, 100, 1.0f / 64.0f); //1.0f/(float)Settings::getMaxFPS());
list<pair<unsigned long, GameObject*>>::iterator iter = gameObjects->begin();
while (iter != gameObjects->end())
{
iter->second->update(elapsedTime);
if (!iter->second->isAlive()) {
serverEventsTCP->appendToSendBuffer(NetworkFunctions::createDeleteObjectBuffer(iter->second->getNetID()));
for (int p = 0; p < maxPlayers; p++) {
if (playerObjects->at(p) != NULL && playerObjects->at(p) == iter->second) {
playerObjects->at(p) = NULL;
}
}
GameObject * tempObject = iter->second;
iter = gameObjects->erase(iter);
delete tempObject;
}
else iter++;
}
/*for (list<pair<unsigned long, GameObject*>>::iterator iter = gameObjects->begin(); iter != gameObjects->end(); iter++) {
iter->second->update(elapsedTime);
if (!iter->second->isAlive()) {
serverEventsTCP->appendToSendBuffer(NetworkFunctions::createDeleteObjectBuffer(iter->second->getNetID()));
for (int p = 0; p < maxPlayers; p++) {
if (playerObjects->at(p) != NULL && playerObjects->at(p) == iter->second) {
playerObjects->at(p) = NULL;
}
}
gameObjects->remove(iter->first, iter->second);
delete (*gameObjects)[i];
gameObjects->erase(gameObjects->begin() + i);
i--;
}
}*/
/*for (int i = 0; i < (int)gameObjects->size(); i++) {
(*gameObjects)[i]->update(elapsedTime);
if (!(*gameObjects)[i]->isAlive()) {
serverEventsTCP->appendToSendBuffer(NetworkFunctions::createDeleteObjectBuffer(i));
for (int p = 0; p < maxPlayers; p++) {
if (playerObjects->at(p) != NULL && playerObjects->at(p) == (*gameObjects)[i]) {
playerObjects->at(p) = NULL;
}
}
delete (*gameObjects)[i];
gameObjects->erase(gameObjects->begin() + i);
i--;
}
}*/
//Update each client
//for (int i = 0; i < gameObjects->size(); i++)
// serverEvents->appendToSendBuffer(NetworkFunctions::createUpdateObjectBuffer(i));
for (int i = 0; i < maxPlayers; i++) {
aquireClientsMutex(i);
if (clients[i]->isConnected()) {
if (clients[i]->requiresSynch()) {
synchClient(i);
clients[i]->setSynch(false);
}
else {
clients[i]->pushSendData(serverEventsTCP->getSendBuffer(), serverEventsTCP->getSendBufferSize());
}
}
releaseClientsMutex(i);
}
for (int i = 0; i < maxPlayers; i++) {
aquireClientsMutex(i);
if (clients[i]->isConnected()) {
//unsigned long clientPortUDP = clients[i]->getPortUDP();
if (!clients[i]->requiresSynch()) {
serverEventsUDP->clearSendBuffer();
for (list<pair<unsigned long, GameObject*>>::iterator iter = gameObjects->begin(); iter != gameObjects->end(); iter++) {
if (playerObjects->at(i) != iter->second /* && dont force player */) {
DataBuffer * temp = NetworkFunctions::createUpdateObjectBuffer(iter->second->getNetID());
serverEventsUDP->appendToSendBuffer(temp);
}
}
UDPManager::sendDatagram(serverEventsUDP->getSendBuffer(), serverEventsUDP->getSendBufferSize(), clients[i]->getIPAddress(), clients[i]->getPortUDP(), frameCount);
}
}
releaseClientsMutex(i);
}
/*timeSinceLastRender += elapsedTime;
if (timeSinceLastRender >= timePerRenderFrame) {
timeSinceLastRender = 0.0;
renderFrame();
}*/
renderFrame();
//Update Rate Calculations
//Framerate Limit Calculations
elapsedTime = SDL_GetTicks() - lastTime;
targetSleep = timePerFrame - elapsedTime + sleepRemainder;
if (targetSleep > 0) sleepRemainder = targetSleep - (Uint32)targetSleep;
//Sleep(1000.0 / 64.0);
startSleep = SDL_GetTicks();
while ((Uint32)(startSleep + targetSleep) > SDL_GetTicks());
sleepTime = SDL_GetTicks() - startSleep;
}
cout << "Shutting Down\n";
HostThread::stopAll();
HostListener::stop();
UDPManager::cleanup();
WSACleanup();
WaitForSingleObject(listenThreadHandle, INFINITE);
saveConfig();
cleanupObjects();
//saveConfig();
killBullet();
//delete [] clients;
return 0;
}
void SettingsDBManager::addSettings(const std::string& key, const std::string&value) {
config[key] = value;
//записать в файл сразу же!
saveConfig();
}
ThumbView::~ThumbView()
{
saveConfig();
}
ShareConfigMainWindow::ShareConfigMainWindow()
{
configuration = Share::Configuration::getInstance();
// Create de main window.
ShareConfigWidget *mainWidget = new ShareConfigWidget;
QMainWindow::setCentralWidget(mainWidget);
statusBar()->showMessage(tr("Loading..."));
connect(mainWidget,SIGNAL(quitRequest()),this,SIGNAL(quitRequest()));
// connect mainWidget with configuration instance
// Tab<System>.system
connect(configuration,SIGNAL(changeSystem_SystemDeamon(bool)),mainWidget,SLOT(setSystemSystemDeamon(bool)));
connect(configuration,SIGNAL(changeSystem_SystemCommunicationMode(Share::Communication::Type)),mainWidget,SLOT(setSystemSystemCommunicationMode(Share::Communication::Type)));
connect(configuration,SIGNAL(changeSystem_SystemListenPort(int)),mainWidget,SLOT(setSystemSystemListenPort(int)));
connect(configuration,SIGNAL(changeSystem_SystemLocalListenPort(int)),mainWidget,SLOT(setSystemSystemLocalListenPort(int)));
connect(configuration,SIGNAL(changeSystem_SystemCachePath(QString)),mainWidget,SLOT(setSystemSystemCachePath(QString)));
connect(configuration,SIGNAL(changeSystem_SystemCacheQuota(int)),mainWidget,SLOT(setSystemSystemCacheQuota(int)));
// Tab<System>.User
connect(configuration,SIGNAL(changeSystem_UserDeamon(bool)),mainWidget,SLOT(setSystemUserDeamon(bool)));
connect(configuration,SIGNAL(changeSystem_UserCommViaSystemDeamon(bool)),mainWidget,SLOT(setSystemUserCommViaSystemDeamon(bool)));
connect(configuration,SIGNAL(changeSystem_UserListenPort(int)),mainWidget,SLOT(setSystemUserListenPort(int)));
connect(configuration,SIGNAL(changeSystem_UserCommunicationMode(Share::Communication::Type)),mainWidget,SLOT(setSystemUserCommunicationMode(Share::Communication::Type)));
connect(configuration,SIGNAL(changeSystem_UserLocalListenPort(int)),mainWidget,SLOT(setSystemUserLocalListenPort(int)));
connect(configuration,SIGNAL(changeSystem_UserCachePath(QString)),mainWidget,SLOT(setSystemUserCachePath(QString)));
connect(configuration,SIGNAL(changeSystem_UserCacheQuota(int)),mainWidget,SLOT(setSystemUserCacheQuota(int)));
// Tab<User>
connect(configuration,SIGNAL(changeUser_UseSystemSettings(bool)),mainWidget,SLOT(setUserUseSystemSettings(bool)));
connect(configuration,SIGNAL(changeUser_UserDeamon(bool)),mainWidget,SLOT(setUserUserDeamon(bool)));
connect(configuration,SIGNAL(changeUser_UserCommunicationMode(Share::Communication::Type)),mainWidget,SLOT(setUserUserCommunicationMode(Share::Communication::Type)));
connect(configuration,SIGNAL(changeUser_UserListenPort(int)),mainWidget,SLOT(setUserUserListenPort(int)));
connect(configuration,SIGNAL(changeUser_UserLocalListenPort(int)),mainWidget,SLOT(setUserUserLocalListenPort(int)));
connect(configuration,SIGNAL(changeUser_UserCachePath(QString)),mainWidget,SLOT(setUserUserCachePath(QString)));
connect(configuration,SIGNAL(changeUser_UserCacheQuota(int)),mainWidget,SLOT(setUserUserCacheQuota(int)));
// Inform configuration class
connect(mainWidget,SIGNAL(validateConfig()),this,SLOT(startSaving()));
connect(mainWidget,SIGNAL(validateConfig()),configuration,SLOT(saveConfig()));
// Connect events saving...
connect(configuration,SIGNAL(configLoaded(bool)),this,SLOT(configLoaded(bool)));
connect(configuration,SIGNAL(configLoaded(bool)),mainWidget,SLOT(configLoaded(bool)));
connect(configuration,SIGNAL(configSaved(bool)),this,SLOT(configSaved(bool)));
connect(configuration,SIGNAL(configSaved(bool)),mainWidget,SLOT(configSaved(bool)));
// Connect changes on interface to the configuration class
connect(mainWidget,SIGNAL(changeSystemSystemDeamon(bool)),configuration,SLOT(setSystem_SystemDeamon(bool)));
connect(mainWidget,SIGNAL(changeSystemSystemListenPort(int)),configuration,SLOT(setSystem_SystemListenPort(int)));
connect(mainWidget,SIGNAL(changeSystemSystemCommunicationMode(Share::Communication::Type)),configuration,SLOT(setSystem_SystemCommunicationMode(Share::Communication::Type)));
connect(mainWidget,SIGNAL(changeSystemSystemLocalListenPort(int)),configuration,SLOT(setSystem_SystemLocalListenPort(int)));
connect(mainWidget,SIGNAL(changeSystemSystemCachePath(QString)),configuration,SLOT(setSystem_SystemCachePath(QString)));
connect(mainWidget,SIGNAL(changeSystemSystemCacheQuota(int)),configuration,SLOT(setSystem_SystemCacheQuota(int)));
connect(mainWidget,SIGNAL(changeSystemUserDeamon(bool)),configuration,SLOT(setSystem_UserDeamon(bool)));
connect(mainWidget,SIGNAL(changeSystemUserCommViaSystemDeamon(bool)),configuration,SLOT(setSystem_UserCommViaSystemDeamon(bool)));
connect(mainWidget,SIGNAL(changeSystemUserListenPort(int)),configuration,SLOT(setSystem_UserListenPort(int)));
connect(mainWidget,SIGNAL(changeSystemUserCommunicationMode(Share::Communication::Type)),configuration,SLOT(setSystem_UserCommunicationMode(Share::Communication::Type)));
connect(mainWidget,SIGNAL(changeSystemUserLocalListenPort(int)),configuration,SLOT(setSystem_UserLocalListenPort(int)));
connect(mainWidget,SIGNAL(changeSystemUserCachePath(QString)),configuration,SLOT(setSystem_UserCachePath(QString)));
connect(mainWidget,SIGNAL(changeSystemUserCacheQuota(int)),configuration,SLOT(setSystem_UserCacheQuota(int)));
connect(mainWidget,SIGNAL(changeUserUseSystemSettings(bool)),configuration,SLOT(setUser_UseSystemSettings(bool)));
connect(mainWidget,SIGNAL(changeUserUserDeamon(bool)),configuration,SLOT(setUser_UserDeamon(bool)));
connect(mainWidget,SIGNAL(changeUserUserCommunicationMode(Share::Communication::Type)),configuration,SLOT(setUser_UserCommunicationMode(Share::Communication::Type)));
connect(mainWidget,SIGNAL(changeUserUserListenPort(int)),configuration,SLOT(setUser_UserListenPort(int)));
connect(mainWidget,SIGNAL(changeUserUserLocalListenPort(int)),configuration,SLOT(setUser_UserLocalListenPort(int)));
connect(mainWidget,SIGNAL(changeUserUserCachePath(QString)),configuration,SLOT(setUser_UserCachePath(QString)));
connect(mainWidget,SIGNAL(changeUserUserCacheQuota(int)),configuration,SLOT(setUser_UserCacheQuota(int)));
// Send configuration
configuration->loadConfig();
}
//====================================
void openCommand()
//====================================
{
struct stat st;
int ch,nsteps=1000,x,i,n,stop=0,loop,projNo = 0,ok=0,tmp;
char *p,str[120],sstr[20],fileName[120],temp[120],syscom[120];
char command[40][40];
s_mode = S_ADMIN;
g_silent = 0;
readMsg(gplFile);
while(strstr(str,"ex") == NULL)
{
anyErrors();
unoInfo();
wmove(uno,board_h-2,1);
wprintw(uno," ");
if(g_silent==S_NO )mvwprintw(uno,board_h-2,1,"A%1d>",confWinMode);
if(g_silent==S_YES)mvwprintw(uno,board_h-2,1,"A%1d<",confWinMode);
strcpy(command[0],"");
wgetstr(uno,str);
n = tokCommand(command,str);
strcpy(sstr,command[0]);
p = str;
projNo = atoi(sstr);
if(strstr(sstr,"gpl"))
{
readMsg(gplFile);
}
else if(strstr(sstr,"err"))
{
readMsg(fileTemp);
}
else if(strstr(sstr,"run"))
{
stop = 1;
if(n == 2)stop = atoi(command[1]);
stop = checkRange(HEAL,"step",stop);
runMode(stop);
if(stop==0)putMsg(2,"Back in Admin Mode!");
}
else if(strstr(sstr,"res")) // reset simulation
{
resetSim();
init(confWinMode);
unoInfo();
readMsg(currentConf);
}
else if(strstr(sstr,"help")) //
{
strcpy(fileName,fileInfoAdmin);
readMsg(fileName);
}
else if(strstr(sstr,"rem")) //
{
if(n == 4)
{
if(strstr(command[1],"a"))g_pinType = ANA;
if(strstr(command[1],"d"))g_pinType = DIG;
g_pinNo = atoi(command[2]);
g_pinStep = atoi(command[3]);
if(g_pinType == ANA)
ok = checkRange(S_OK,"anapin",g_pinNo);
if(g_pinType == DIG)
ok = checkRange(S_OK,"digpin",g_pinNo);
if(ok == S_OK)
{
g_scenSource = 1;
sprintf(syscom,"cd servuino;./servuino %d %d %d %d %d %d %d;",confSteps,g_scenSource,g_pinType,g_pinNo,0,g_pinStep,S_DELETE);
//putMsg(2,syscom);
tmp=system(syscom);
initSim();
readSketchInfo();
readSimulation();
runStep(S_FORWARD);
readMsg(fileServScen);
}
else
putMsg(2,"Wrong pin number or pin type!");
}
else
putMsg(2,"Syntax: rem <a or d> <pin> <step>");
}
else if(strstr(sstr,"add")) //
{
if(n == 5)
{
if(strstr(command[1],"a"))g_pinType = ANA;
if(strstr(command[1],"d"))g_pinType = DIG;
g_pinNo = atoi(command[2]);
g_pinStep = atoi(command[3]);
g_pinValue = atoi(command[4]);
ok = S_OK;
if(g_pinType == ANA)
ok = checkRange(S_OK,"anapin",g_pinNo);
if(g_pinType == DIG)
ok = checkRange(S_OK,"digpin",g_pinNo);
ok = ok + checkRange(S_OK,"step",g_pinStep);
if(ok == S_OK)
{
g_scenSource = 1;
sprintf(syscom,"cd servuino;./servuino %d %d %d %d %d %d %d;",confSteps,g_scenSource,g_pinType,g_pinNo,g_pinValue,g_pinStep,S_ADD);
tmp=system(syscom);
initSim();
readSketchInfo();
readSimulation();
runStep(S_FORWARD);
readMsg(fileServScen);
}
}
else
putMsg(2,"Syntax: add <a or d> <pin> <step> <value>");
}
else if(strstr(sstr,"info"))
{
if(n == 2)
{
if(strstr(command[1],"conf"))
{
readMsg(fileDefault);
}
else if(strstr(command[1],"err"))
{
readMsg(fileServError);
}
else if(strstr(command[1],"g++"))
{
readMsg(fileServComp);
}
else if(strstr(command[1],"help"))
{
readMsg(fileInfoAdmin);
}
else if(strstr(command[1],"loop"))
{
showLoops();
}
else if(strstr(command[1],"scen")) // scenario
{
readMsg(fileServScen);
}
}
else
{
readMsg(fileInfoAdmin);
}
}
else if(strstr(sstr,"proj"))
{
if(n == 2)
{
strcpy(currentConf,command[1]);
strcat(currentConf,".conf");
readConfig(currentConf);
g_warning = S_YES;
unoInfo();
}
readMsg(currentConf);
}
else if(strstr(sstr,"list"))
{
readMsg(fileProjList);
}
else if(strstr(sstr,"sketch"))
{
if(n == 2)
{
if(strstr(command[1],"conf"))
{
readMsg(confSketchFile);
}
else if(strstr(command[1],"work"))
{
readMsg(fileServSketch);
}
}
else
readMsg(fileServSketch);
}
else if(strstr(sstr,"conf"))
{
if(n == 3)
{
if(strstr(command[1],"sim"))
{
confSteps = atoi(command[2]);
}
else if(strstr(command[1],"win"))
{
confWinMode = atoi(command[2]);
if(confWinMode > WIN_MODES)confWinMode = 0;
init(confWinMode);
unoInfo();
}
else if(strstr(command[1],"sketch"))
{
strcpy(temp,command[2]);
if(stat(temp,&st) == 0)
{
strcpy(confSketchFile,command[2]);
}
else
{
sprintf(temp,"Sketch not found: %s",command[2]);// Issue 16
putMsg(msg_h-2,temp);
}
}
saveConfig(currentConf);
}
readMsg(currentConf);
}
else if(strstr(sstr,"sav")) //save config
{
if(n == 2)
{
strcpy(currentConf,command[1]);
strcat(currentConf,".conf");
}
saveConfig(currentConf);
readMsg(currentConf);
sprintf(syscom,"ls *.conf > %s;",fileProjList);
x=system(syscom);
}
else if(strstr(sstr,"del")) //delete config
{
if(n == 2)
{
strcpy(currentConf,command[1]);
strcat(currentConf,".conf");
}
if(strstr(currentConf,"default") == NULL)
{
sprintf(syscom,"rm %s;",currentConf);
x=system(syscom);
sprintf(syscom,"ls *.conf > %s;",fileProjList);
x=system(syscom);
readMsg(fileProjList);
strcpy(currentConf,fileDefault);
}
}
else if(strstr(sstr,"win")) //windows layout
{
if(n == 2)
{
confWinMode = atoi(command[1]);
if(confWinMode > WIN_MODES)confWinMode = 0;
init(confWinMode);
unoInfo();
}
}
else if(strstr(sstr,"loop"))
{
if(n == 2)loop = atoi(command[1]);
loop = checkRange(HEAL,"loop",loop);
runLoops(loop);
}
else if(strstr(sstr,"clear"))
{
sprintf(syscom,"rm servuino/sketch.ino;rm servuino/data.su;rm servuino/data.scen;");
x=system(syscom);
}
else if(strstr(sstr,"load"))
{
if(n == 2)
{
confSteps = atoi(command[1]);
}
g_scenSource = 0;
loadCurrentProj();
}
else if(projNo > 0 && projNo < 10)
{
selectProj(projNo,currentConf);
readConfig(currentConf);
g_warning = S_YES;
unoInfo();
readMsg(currentConf);
}
else if(strstr(sstr,"data"))
{
if(n == 2)
{
if(strstr(command[1],"ard"))
{
readMsg(fileServArduino);
}
else if(strstr(command[1],"cus"))
{
readMsg(fileServCustom);
}
else if(strstr(command[1],"cod"))
{
readMsg(fileServCode);
}
else if(strstr(command[1],"err"))
{
readMsg(fileServError);
}
else if(strstr(command[1],"sce"))
{
readMsg(fileServScen);
}
}
else
readMsg(fileServArduino);
}
else
{
putMsg(msg_h-2,"Unknown Admin command");
}
}
}
void CALLBACK dispatchEvents(SIMCONNECT_RECV* pData, DWORD cbData, void * pContext)
{
HRESULT hr;
switch (pData->dwID)
{
case SIMCONNECT_RECV_ID_EVENT:
{
SIMCONNECT_RECV_EVENT *evt = (SIMCONNECT_RECV_EVENT*)pData;
switch (evt->uEventID)
{
case STARTUP:
stats.lastDeleted = 0;
stats.nrOfDeletions = 0;
stats.nrOfRequests = 0;
// Now the sim is running, request information on the user aircraft
hr = SimConnect_RequestDataOnSimObjectType(hSimConnect, R1, AIPARKDATA, conf.radius, SIMCONNECT_SIMOBJECT_TYPE_AIRCRAFT);
++stats.nrOfRequests;
break;
case R2:
fsecCnt++;
if (fsecCnt >= (conf.requestEveryXSec/4))
{
fsecCnt = 0;
if (SUCCEEDED(SimConnect_RequestDataOnSimObjectType(hSimConnect, R1, AIPARKDATA, conf.radius, SIMCONNECT_SIMOBJECT_TYPE_AIRCRAFT)))
{
++stats.nrOfRequests;
}
}
break;
case MENU:
getMenu(menu, sizeof(menu));
SimConnect_Text(hSimConnect, SIMCONNECT_TEXT_TYPE_MENU, 0, SELECTION, sizeof(menu), (void*)menu);
break;
case SELECTION:
res = (SIMCONNECT_TEXT_RESULT)(evt->dwData);
switch (res) {
case SIMCONNECT_TEXT_RESULT_MENU_SELECT_1:
if (conf.requestEveryXSec < 3600)
{
conf.requestEveryXSec += 30;
}
getMenu(menu, sizeof(menu));
SimConnect_Text(hSimConnect, SIMCONNECT_TEXT_TYPE_MENU, 0, SELECTION, sizeof(menu), (void*)menu);
break;
case SIMCONNECT_TEXT_RESULT_MENU_SELECT_2:
if (conf.requestEveryXSec > 45)
{
conf.requestEveryXSec -= 30;
}
getMenu(menu, sizeof(menu));
SimConnect_Text(hSimConnect, SIMCONNECT_TEXT_TYPE_MENU, 0, SELECTION, sizeof(menu), (void*)menu);
break;
case SIMCONNECT_TEXT_RESULT_MENU_SELECT_3:
if (conf.radius < 190000)
{
conf.radius += 5000;
}
getMenu(menu, sizeof(menu));
SimConnect_Text(hSimConnect, SIMCONNECT_TEXT_TYPE_MENU, 0, SELECTION, sizeof(menu), (void*)menu);
break;
case SIMCONNECT_TEXT_RESULT_MENU_SELECT_4:
if (conf.radius > 5000)
{
conf.radius -= 5000;
}
getMenu(menu, sizeof(menu));
SimConnect_Text(hSimConnect, SIMCONNECT_TEXT_TYPE_MENU, 0, SELECTION, sizeof(menu), (void*)menu);
break;
case SIMCONNECT_TEXT_RESULT_MENU_SELECT_5:
if (conf.maxetd > 5400)
{
conf.maxetd -= 3600;
}
getMenu(menu, sizeof(menu));
SimConnect_Text(hSimConnect, SIMCONNECT_TEXT_TYPE_MENU, 0, SELECTION, sizeof(menu), (void*)menu);
break;
case SIMCONNECT_TEXT_RESULT_MENU_SELECT_6:
if (conf.maxetd < 7*86400) // must be smaller than a week
{
conf.maxetd += 3600;
}
getMenu(menu, sizeof(menu));
SimConnect_Text(hSimConnect, SIMCONNECT_TEXT_TYPE_MENU, 0, SELECTION, sizeof(menu), (void*)menu);
break;
case SIMCONNECT_TEXT_RESULT_MENU_SELECT_8:
SimConnect_Text(hSimConnect, SIMCONNECT_TEXT_TYPE_MENU, 0, SELECTION, sizeof(empty), (void*)empty);
break;
default: //default cannot be close as displayed is also an event
break;
}
saveConfig(conf);
break;
default:
break;
}
break;
}
case SIMCONNECT_RECV_ID_SIMOBJECT_DATA_BYTYPE:
{
SIMCONNECT_RECV_SIMOBJECT_DATA_BYTYPE *pObjData = (SIMCONNECT_RECV_SIMOBJECT_DATA_BYTYPE*)pData;
switch (pObjData->dwRequestID)
{
case R1:
{
DWORD ObjectID = pObjData->dwObjectID;
DWORD entry = pObjData->dwentrynumber;
DWORD outof = pObjData->dwoutof;
DWORD length = pObjData->dwDefineCount;
AIData *pS = (AIData*)&pObjData->dwData;
if (ObjectID != SIMCONNECT_OBJECT_ID_USER)
{
if (strcmp(pS->state, "sleep") == 0 && pS->ETD > conf.maxetd)
{
if (FS10DeleteAIAircraft != NULL)
{
FS10DeleteAIAircraft(ObjectID, 1);
++stats.nrOfDeletions;
deletedSome = true;
}
}
}
if (entry == outof)
{
if (deletedSome)
{
stats.lastDeleted = GetTickCount64();
}
deletedSome = false;
}
}
default:
break;
}
break;
}
case SIMCONNECT_RECV_ID_EXCEPTION:
{
SIMCONNECT_RECV_EXCEPTION *except = (SIMCONNECT_RECV_EXCEPTION*)pData;
printf("\n\n***** EXCEPTION=%d SendID=%d Index=%d cbData=%d\n", except->dwException, except->dwSendID, except->dwIndex, cbData);
break;
}
case SIMCONNECT_RECV_ID_QUIT:
{
quit = 1;
break;
}
default:
printf("\nReceived:%d", pData->dwID);
break;
}
}
int main(int argc, char* argv[])
{
u8 *tex_ptrone=GRRLIB_LoadTexture(handpointerred_png);
u8 *tex_ptrtwo=GRRLIB_LoadTexture(handpointergreen_png);
u8 *tex_back=GRRLIB_LoadJPG(bigmenuback_jpg, bigmenuback_jpg_size);
u8 *tex_fore=GRRLIB_LoadTexture(credits_png);
fatInitDefault();
GRRLIB_InitVideo();
WPAD_Init();
SYS_SetResetCallback(WiiResetPressed);
SYS_SetPowerCallback(WiiPowerPressed);
WPAD_SetPowerButtonCallback(WiimotePowerPressed);
rmode = VIDEO_GetPreferredMode(NULL);
AESND_Init(NULL);
MODPlay_Init(&mod_track);
Init_Voice();
AESND_Pause(0); // the sound loop is running now
// set the MOD song
if (MODPlay_SetMOD (&mod_track, dojo_dan_oriental_mod) < 0 ) {
MODPlay_Unload (&mod_track);
} else {
// set the music volume to the minimum so we don't hear the music before saved volume is known
MODPlay_SetVolume( &mod_track, 0,0);
MODPlay_Start (&mod_track);// Play the MOD
}
WPAD_SetDataFormat(WPAD_CHAN_ALL, WPAD_FMT_BTNS_ACC_IR);
WPAD_SetVRes(WPAD_CHAN_ALL, rmode->fbWidth, rmode->xfbHeight);
initMain();
MODPlay_SetVolume( &mod_track, opt_music, opt_music);
while( HWButton == 0) {
WPAD_ScanPads();
u32 wpad_one_down = WPAD_ButtonsDown(0);
u32 wpad_two_down = WPAD_ButtonsDown(1);
u32 type;
WPADData *wd_one, *wd_two;
WPAD_ReadPending(WPAD_CHAN_ALL, countevs);
WPAD_Probe(WPAD_CHAN_ALL, &type);
wd_one = WPAD_Data(0);
wd_two = WPAD_Data(1);
switch(main_mode) {
case STARTUP :
GRRLIB_FillScreen(0xFF000000);
GRRLIB_DrawImg(0, 0, 640, 480, tex_back, 0, 1, 1, alpha>255?255:alpha);
GRRLIB_DrawImg(68,308, 256, 80, tex_fore, 0, 1, 1, alpha>255?255:alpha);
if(alpha++>394 || wpad_one_down > 0) {
main_mode=MENU;
if(tex_back) free(tex_back);
if(tex_fore) free(tex_fore);
initMenu();
}
break;
case MENU :
GRRLIB_FillScreen(0xFF000000);
int menuopt = menuWiimote(wd_one,wpad_one_down);
if(menuopt==EXIT) {
if(tex_ptrone) free(tex_ptrone);
if(tex_ptrtwo) free(tex_ptrtwo);
}
if(menuopt>NOTHING) {
processMenuOption(menuopt);
if(main_mode==GAME) {
MODPlay_Unload (&mod_track);
if(opt_tileset==SPOOKY)
MODPlay_SetMOD (&mod_track, graveyard_mod);
else
if(opt_tileset==EGYPTIAN)
MODPlay_SetMOD (&mod_track, egypt_crap_mod);
else
if(opt_tileset==SIMPLE)
MODPlay_SetMOD (&mod_track, childhood_mod);
else
if(opt_tileset==SPACE)
MODPlay_SetMOD (&mod_track, nebulos_mod);
else
MODPlay_SetMOD (&mod_track, sushi_mod);
MODPlay_SetVolume( &mod_track, opt_music, opt_music);
MODPlay_Start (&mod_track);
}
else
drawMenu(wd_one);
}
else
drawMenu(wd_one);
break;
case GAME :
if(gameWiimote(wd_one,wpad_one_down,wd_two,wpad_two_down)) {
// we are exiting the game back to the menu
main_mode=MENU;
MODPlay_Unload (&mod_track);
MODPlay_SetMOD (&mod_track, dojo_dan_oriental_mod);
MODPlay_SetVolume( &mod_track, opt_music, opt_music);
MODPlay_Start (&mod_track);
killGame();
initMenu();
}
else {
drawGame();
}
break;
}
// alternate which pointer is on top every frame to not give the advantage to player one in two player mode
static int ticktock=0;
ticktock++;
if(wd_two->ir.valid && ticktock%2==0) {
if(main_mode==GAME && whatGameMode()==ONE_PLAYER_GAME) {
// don't display second pointer in one player mode
}
else
GRRLIB_DrawColImg(wd_two->ir.x - 9,wd_two->ir.y - 7,68,80,tex_ptrtwo,0,1,1,0xEEFFFFFF);
}
if(wd_one->ir.valid) {
GRRLIB_DrawColImg(wd_one->ir.x - 9,wd_one->ir.y - 7,68,80,tex_ptrone,0,1,1,0xEEFFFFFF);
}
if(wd_two->ir.valid && ticktock%2!=0) {
if(main_mode==GAME && whatGameMode()==ONE_PLAYER_GAME) {
// don't display second pointer in one player mode
}
else
GRRLIB_DrawColImg(wd_two->ir.x - 9,wd_two->ir.y - 7,68,80,tex_ptrtwo,0,1,1,0xEEFFFFFF);
}
if(wd_one->btns_h & WPAD_BUTTON_1) {
GRRLIB_ScrShot("MahjonggWii_Screen_%y%m%d_%H%M%S.png",time(NULL));
}
GRRLIB_Render();
}
// we are exiting, free the mallocs
switch( main_mode) {
case GAME:
killGame();
}
if(tex_ptrone) free(tex_ptrone);
if(tex_ptrtwo) free(tex_ptrtwo);
killMenuLanguages();
MODPlay_Unload (&mod_track);
Free_Voice();
WPAD_Shutdown();
GRRLIB_Stop();
saveConfig(FILE_CFG);
SYS_ResetSystem(HWButton, 0, 0);
return 0;
}
int CLCDD::main(int argc, char **argv)
{
debugoutput = true;
printf("Network LCD-Driver $Id: lcdd.cpp,v 1.57 2002/10/17 10:16:35 thegoodguy Exp $\n\n");
InitNewClock();
loadConfig();
if(!lcdPainter.init())
{
//fehler beim lcd-init aufgetreten
return -1;
}
//network-setup
int listenfd, connfd;
struct sockaddr_un servaddr;
int clilen;
std::string filename = LCDD_UDS_NAME;
memset(&servaddr, 0, sizeof(struct sockaddr_un));
servaddr.sun_family = AF_UNIX;
strcpy(servaddr.sun_path, filename.c_str());
clilen = sizeof(servaddr.sun_family) + strlen(servaddr.sun_path);
unlink(filename.c_str());
//network-setup
if ((listenfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
{
perror("socket");
return -1;
}
if ( bind(listenfd, (struct sockaddr*) &servaddr, clilen) <0 )
{
perror("[lcdd] bind failed...\n");
return -1;
}
if (listen(listenfd, 5) !=0)
{
perror("[lcdd] listen failed...\n");
return -1;
}
switch (fork())
{
case -1: /* can't fork */
perror("[lcdd] fork");
return -1;
case 0: /* child, process becomes a daemon */
if (setsid() == -1)
{
perror("[lcdd] setsid");
return -1;
}
break;
default: /* parent returns to calling process */
return 0;
}
signal(SIGHUP,sig_catch);
signal(SIGINT,sig_catch);
signal(SIGQUIT,sig_catch);
signal(SIGTERM, sig_catch);
/* Thread erst nach dem forken erstellen, da sonst Abbruch */
if (pthread_create (&thrTime, NULL, TimeThread, NULL) != 0 )
{
perror("[lcdd]: pthread_create(TimeThread)");
return -1;
}
shall_exit = false;
while(!shall_exit)
{
connfd = accept(listenfd, (struct sockaddr*) &servaddr, (socklen_t*) &clilen);
CLcddMsg::Header rmsg;
read(connfd,&rmsg,sizeof(rmsg));
parse_command(connfd, rmsg);
close(connfd);
}
close(listenfd);
saveConfig();
return 0;
}
void KWatchGnuPGConfig::slotSave()
{
saveConfig();
emit reconfigure();
}
void CLCDD::parse_command(int connfd, CLcddMsg::Header rmsg)
{
if(rmsg.version != CLcddMsg::ACTVERSION)
{
printf("[lcdd] unknown version\n");
return;
}
switch (rmsg.cmd)
{
case CLcddMsg::CMD_SHUTDOWN:
saveConfig();
exit(0);
break;
case CLcddMsg::CMD_SETSERVICENAME:
CLcddMsg::commandServiceName msg;
read(connfd, &msg, sizeof(msg));
lcdPainter.show_servicename( msg.servicename);
break;
case CLcddMsg::CMD_SETVOLUME:
CLcddMsg::commandVolume msg2;
read(connfd, &msg2, sizeof(msg2));
lcdPainter.show_volume(msg2.volume);
break;
case CLcddMsg::CMD_SETMUTE:
CLcddMsg::commandMute msg3;
read(connfd, &msg3, sizeof(msg3));
lcdPainter.setMuted(msg3.mute);
break;
case CLcddMsg::CMD_SETMODE:
CLcddMsg::commandMode msg4;
read(connfd, &msg4, sizeof(msg4));
lcdPainter.set_mode((CLcddTypes::mode) msg4.mode, msg4.text);
break;
case CLcddMsg::CMD_SETMENUTEXT:
CLcddMsg::commandMenuText msg5;
read(connfd, &msg5, sizeof(msg5));
lcdPainter.show_menu(msg5.position, msg5.text, msg5.highlight);
break;
case CLcddMsg::CMD_SETLCDBRIGHTNESS:
CLcddMsg::commandSetBrightness msg6;
read(connfd, &msg6, sizeof(msg6));
lcdPainter.setBrightness(msg6.brightness);
break;
case CLcddMsg::CMD_SETLCDCONTRAST:
CLcddMsg::commandSetBrightness msg7;
read(connfd, &msg7, sizeof(msg7));
lcdPainter.setContrast(msg7.brightness);
break;
case CLcddMsg::CMD_SETSTANDBYLCDBRIGHTNESS:
CLcddMsg::commandSetBrightness msg8;
read(connfd, &msg8, sizeof(msg8));
lcdPainter.setBrightnessStandby(msg8.brightness);
break;
case CLcddMsg::CMD_GETLCDBRIGHTNESS:
CLcddMsg::responseGetBrightness msg9;
msg9.brightness = lcdPainter.getBrightness();
write(connfd, &msg9, sizeof(msg9));
break;
case CLcddMsg::CMD_GETLCDCONTRAST:
CLcddMsg::responseGetBrightness msg10;
msg10.brightness = lcdPainter.getContrast();
write(connfd, &msg10, sizeof(msg10));
break;
case CLcddMsg::CMD_GETSTANDBYLCDBRIGHTNESS:
CLcddMsg::responseGetBrightness msg11;
msg11.brightness = lcdPainter.getBrightnessStandby();
write(connfd, &msg11, sizeof(msg11));
break;
case CLcddMsg::CMD_SETLCDPOWER:
CLcddMsg::commandPower msg12;
read(connfd, &msg12, sizeof(msg12));
lcdPainter.setPower(msg12.power);
break;
case CLcddMsg::CMD_GETLCDPOWER:
CLcddMsg::commandPower msg13;
msg13.power = lcdPainter.getPower();
write(connfd, &msg13, sizeof(msg13));
break;
case CLcddMsg::CMD_SETLCDINVERSE:
CLcddMsg::commandInverse msg14;
read(connfd, &msg14, sizeof(msg14));
lcdPainter.setInverse(msg14.inverse);
break;
case CLcddMsg::CMD_GETLCDINVERSE:
CLcddMsg::commandInverse msg15;
msg15.inverse = lcdPainter.getInverse();
write(connfd, &msg15, sizeof(msg15));
break;
case CLcddMsg::CMD_UPDATE:
lcdPainter.update();
break;
case CLcddMsg::CMD_PAUSE:
lcdPainter.pause();
break;
case CLcddMsg::CMD_RESUME:
lcdPainter.resume();
break;
default:
printf("unknown command %i\n", rmsg.cmd);
}
}
bool SynscanDriver::sendLocation()
{
char res[SYN_RES] = {0};
LOG_DEBUG("Reading mount location...");
if (isSimulation())
{
LocationN[LOCATION_LATITUDE].value = 29.5;
LocationN[LOCATION_LONGITUDE].value = 48;
IDSetNumber(&LocationNP, nullptr);
return true;
}
if (!sendCommand("w", res))
return false;
double lat, lon;
// lets parse this data now
int a, b, c, d, e, f, g, h;
a = res[0];
b = res[1];
c = res[2];
d = res[3];
e = res[4];
f = res[5];
g = res[6];
h = res[7];
double t1, t2, t3;
t1 = c;
t2 = b;
t3 = a;
t1 = t1 / 3600.0;
t2 = t2 / 60.0;
lat = t1 + t2 + t3;
t1 = g;
t2 = f;
t3 = e;
t1 = t1 / 3600.0;
t2 = t2 / 60.0;
lon = t1 + t2 + t3;
if (d == 1)
lat = lat * -1;
if (h == 1)
lon = 360 - lon;
LocationN[LOCATION_LATITUDE].value = lat;
LocationN[LOCATION_LONGITUDE].value = lon;
IDSetNumber(&LocationNP, nullptr);
saveConfig(true, "GEOGRAPHIC_COORD");
char LongitudeStr[32] = {0}, LatitudeStr[32] = {0};
fs_sexa(LongitudeStr, lon, 2, 3600);
fs_sexa(LatitudeStr, lat, 2, 3600);
LOGF_INFO("Mount Longitude %s Latitude %s", LongitudeStr, LatitudeStr);
return true;
}
MainWindow::MainWindow()
: m_settings(QString::fromAscii("Doxygen.org"), QString::fromAscii("Doxywizard"))
{
QMenu *file = menuBar()->addMenu(tr("File"));
file->addAction(tr("Open..."),
this, SLOT(openConfig()), Qt::CTRL+Qt::Key_O);
m_recentMenu = file->addMenu(tr("Open recent"));
file->addAction(tr("Save"),
this, SLOT(saveConfig()), Qt::CTRL+Qt::Key_S);
file->addAction(tr("Save as..."),
this, SLOT(saveConfigAs()), Qt::SHIFT+Qt::CTRL+Qt::Key_S);
file->addAction(tr("Quit"),
this, SLOT(quit()), Qt::CTRL+Qt::Key_Q);
QMenu *settings = menuBar()->addMenu(tr("Settings"));
settings->addAction(tr("Reset to factory defaults"),
this,SLOT(resetToDefaults()));
settings->addAction(tr("Use current settings at startup"),
this,SLOT(makeDefaults()));
settings->addAction(tr("Clear recent list"),
this,SLOT(clearRecent()));
QMenu *help = menuBar()->addMenu(tr("Help"));
help->addAction(tr("Online manual"),
this, SLOT(manual()), Qt::Key_F1);
help->addAction(tr("About"),
this, SLOT(about()) );
m_expert = new Expert;
m_wizard = new Wizard(m_expert->modelData());
// ----------- top part ------------------
QWidget *topPart = new QWidget;
QVBoxLayout *rowLayout = new QVBoxLayout(topPart);
// select working directory
QHBoxLayout *dirLayout = new QHBoxLayout;
m_workingDir = new QLineEdit;
m_selWorkingDir = new QPushButton(tr("Select..."));
dirLayout->addWidget(m_workingDir);
dirLayout->addWidget(m_selWorkingDir);
//------------- bottom part --------------
QWidget *runTab = new QWidget;
QVBoxLayout *runTabLayout = new QVBoxLayout(runTab);
// run doxygen
QHBoxLayout *runLayout = new QHBoxLayout;
m_run = new QPushButton(tr("Run doxygen"));
m_run->setEnabled(false);
m_runStatus = new QLabel(tr("Status: not running"));
m_saveLog = new QPushButton(tr("Save log..."));
m_saveLog->setEnabled(false);
QPushButton *showSettings = new QPushButton(tr("Show configuration"));
runLayout->addWidget(m_run);
runLayout->addWidget(m_runStatus);
runLayout->addStretch(1);
runLayout->addWidget(showSettings);
runLayout->addWidget(m_saveLog);
// output produced by doxygen
runTabLayout->addLayout(runLayout);
runTabLayout->addWidget(new QLabel(tr("Output produced by doxygen")));
QGridLayout *grid = new QGridLayout;
m_outputLog = new QTextEdit;
m_outputLog->setReadOnly(true);
m_outputLog->setFontFamily(QString::fromAscii("courier"));
m_outputLog->setMinimumWidth(600);
grid->addWidget(m_outputLog,0,0);
grid->setColumnStretch(0,1);
grid->setRowStretch(0,1);
QHBoxLayout *launchLayout = new QHBoxLayout;
m_launchHtml = new QPushButton(tr("Show HTML output"));
launchLayout->addWidget(m_launchHtml);
launchLayout->addStretch(1);
grid->addLayout(launchLayout,1,0);
runTabLayout->addLayout(grid);
QTabWidget *tabs = new QTabWidget;
tabs->addTab(m_wizard,tr("Wizard"));
tabs->addTab(m_expert,tr("Expert"));
tabs->addTab(runTab,tr("Run"));
rowLayout->addWidget(new QLabel(tr("Step 1: Specify the working directory from which doxygen will run")));
rowLayout->addLayout(dirLayout);
rowLayout->addWidget(new QLabel(tr("Step 2: Configure doxygen using the Wizard and/or Expert tab, then switch to the Run tab to generate the documentation")));
rowLayout->addWidget(tabs);
setCentralWidget(topPart);
statusBar()->showMessage(tr("Welcome to Doxygen"),messageTimeout);
m_runProcess = new QProcess;
m_running = false;
m_timer = new QTimer;
// connect signals and slots
connect(tabs,SIGNAL(currentChanged(int)),SLOT(selectTab(int)));
connect(m_selWorkingDir,SIGNAL(clicked()),SLOT(selectWorkingDir()));
connect(m_recentMenu,SIGNAL(triggered(QAction*)),SLOT(openRecent(QAction*)));
connect(m_workingDir,SIGNAL(returnPressed()),SLOT(updateWorkingDir()));
connect(m_runProcess,SIGNAL(readyReadStandardOutput()),SLOT(readStdout()));
connect(m_runProcess,SIGNAL(finished(int, QProcess::ExitStatus)),SLOT(runComplete()));
connect(m_timer,SIGNAL(timeout()),SLOT(readStdout()));
connect(m_run,SIGNAL(clicked()),SLOT(runDoxygen()));
connect(m_launchHtml,SIGNAL(clicked()),SLOT(showHtmlOutput()));
connect(m_saveLog,SIGNAL(clicked()),SLOT(saveLog()));
connect(showSettings,SIGNAL(clicked()),SLOT(showSettings()));
connect(m_expert,SIGNAL(changed()),SLOT(configChanged()));
loadSettings();
updateLaunchButtonState();
m_modified = false;
updateTitle();
m_wizard->refresh();
}
/** Load configuration values from file. */
bool UserConfig::loadConfig()
{
const std::string filename = file_manager->getUserConfigFile(m_filename);
XMLNode* root = file_manager->createXMLTree(filename);
if(!root || root->getName() != "stkconfig")
{
Log::error("UserConfig",
"Could not read user config file '%s'.", filename.c_str());
if(root) delete root;
// Create a default config file - just in case that stk crashes later
// there is a config file that can be modified (to e.g. disable
// shaders)
saveConfig();
return false;
}
// ---- Read config file version
int config_file_version = m_current_config_version;
if(root->get("version", &config_file_version) < 1)
{
GUIEngine::showMessage( _("Your config file was malformed, so it was deleted and a new one will be created."), 10.0f);
Log::error("UserConfig",
"Warning, malformed user config file! Contains no version");
}
if (config_file_version < m_current_config_version)
{
// current version (8) is 100% incompatible with other versions (which were lisp)
// so we just delete the old config. in the future, for smaller updates, we can
// add back the code previously there that upgraded the config file to the new
// format instead of overwriting it.
GUIEngine::showMessage(_("Your config file was too old, so it was deleted and a new one will be created."), 10.0f);
Log::info("UserConfig", "Your config file was too old, so it was deleted and a new one will be created.");
delete root;
return false;
} // if configFileVersion<SUPPORTED_CONFIG_VERSION
// ---- Read parameters values (all parameter objects must have been created before this point if
// you want them automatically read from the config file)
const int paramAmount = all_params.size();
for(int i=0; i<paramAmount; i++)
{
all_params[i].findYourDataInAChildOf(root);
}
// ---- Read Saved GP's
UserConfigParams::m_saved_grand_prix_list.clearAndDeleteAll();
std::vector<XMLNode*> saved_gps;
root->getNodes("SavedGP", saved_gps);
const int gp_amount = saved_gps.size();
for (int i=0; i<gp_amount; i++)
{
UserConfigParams::m_saved_grand_prix_list.push_back(
new SavedGrandPrix( saved_gps[i]) );
}
delete root;
return true;
} // loadConfig
CIoConfig::CIoConfig(QSettings * settings,
std::map<QString, QVariant> &devList,
QWidget *parent) :
QDialog(parent),
ui(new Ui::CIoConfig),
m_settings(settings)
{
unsigned int i=0;
QString devstr;
bool cfgmatch=false; //flag to indicate that device from config was found
ui->setupUi(this);
QString indev = settings->value("input/device", "").toString();
// insert the device list in device combo box
std::map<QString, QVariant>::iterator I = devList.begin();
i = 0;
while (I != devList.end())
{
devstr = (*I).second.toString();
ui->inDevCombo->addItem((*I).first, devstr);
// is this the device stored in config?
if (indev == devstr)
{
ui->inDevCombo->setCurrentIndex(i);
ui->inDevEdit->setText(devstr);
cfgmatch = true;
}
++I;
++i;
}
ui->inDevCombo->addItem(tr("Other..."), QVariant(""));
// If device string from config is not one of the detected devices
// it could be that device is not plugged in (in which case we select
// other) or that this is the first time (select the first detected device).
if (!cfgmatch)
{
if (indev.isEmpty())
{
// First time config: select the first detected device
ui->inDevCombo->setCurrentIndex(0);
ui->inDevEdit->setText(ui->inDevCombo->itemData(0).toString());
if (ui->inDevEdit->text().isEmpty())
ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
}
else
{
// Select other
ui->inDevCombo->setCurrentIndex(i);
ui->inDevEdit->setText(indev);
}
}
// input rate
updateInputSampleRates(settings->value("input/sample_rate", 0).toInt());
// decimation
int idx = decim2idx(settings->value("input/decimation", 0).toInt());
ui->decimCombo->setCurrentIndex(idx);
decimationChanged(idx);
// Analog bandwidth
ui->bwSpinBox->setValue(1.0e-6*settings->value("input/bandwidth", 0.0).toDouble());
// LNB LO
ui->loSpinBox->setValue(1.0e-6 * settings->value("input/lnb_lo", 0.0).toDouble());
// Output device
QString outdev = settings->value("output/device", "").toString();
// get list of audio output devices
#ifdef WITH_PULSEAUDIO
pa_device_list devices;
outDevList = devices.get_output_devices();
qDebug() << __FUNCTION__ << ": Available output devices:";
for (i = 0; i < outDevList.size(); i++)
{
qDebug() << " " << i << ":" << QString(outDevList[i].get_description().c_str());
//qDebug() << " " << QString(outDevList[i].get_name().c_str());
ui->outDevCombo->addItem(QString(outDevList[i].get_description().c_str()));
// note that item #i in devlist will be item #(i+1)
// in combo box due to "default"
if (outdev == QString(outDevList[i].get_name().c_str()))
ui->outDevCombo->setCurrentIndex(i+1);
}
#elif WITH_PORTAUDIO
portaudio_device_list devices;
outDevList = devices.get_output_devices();
for (i = 0; i < outDevList.size(); i++)
{
ui->outDevCombo->addItem(QString(outDevList[i].get_description().c_str()));
// note that item #i in devlist will be item #(i+1)
// in combo box due to "default"
if (outdev == QString(outDevList[i].get_name().c_str()))
ui->outDevCombo->setCurrentIndex(i+1);
}
//ui->outDevCombo->setEditable(true);
#elif defined(GQRX_OS_MACX)
osxaudio_device_list devices;
outDevList = devices.get_output_devices();
qDebug() << __FUNCTION__ << ": Available output devices:";
for (i = 0; i < outDevList.size(); i++)
{
qDebug() << " " << i << ":" << QString(outDevList[i].get_name().c_str());
ui->outDevCombo->addItem(QString(outDevList[i].get_name().c_str()));
// note that item #i in devlist will be item #(i+1)
// in combo box due to "default"
if (outdev == QString(outDevList[i].get_name().c_str()))
ui->outDevCombo->setCurrentIndex(i+1);
}
#else
ui->outDevCombo->addItem(settings->value("output/device", "Default").toString(),
settings->value("output/device", "Default").toString());
ui->outDevCombo->setEditable(true);
#endif // WITH_PULSEAUDIO
// Signals and slots
connect(this, SIGNAL(accepted()), this, SLOT(saveConfig()));
connect(ui->inDevCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(inputDeviceSelected(int)));
connect(ui->inDevEdit, SIGNAL(textChanged(QString)), this, SLOT(inputDevstrChanged(QString)));
connect(ui->inSrCombo, SIGNAL(editTextChanged(QString)), this, SLOT(inputRateChanged(QString)));
connect(ui->decimCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(decimationChanged(int)));
}
