void NetworkAnalyzerPanel::changeCurrentPage()
{
bool enable = mainWindow()->currentTab()->page()->hasNetworkAnalyzerEnabled();
toggle(enable);
}
AudioTest::AudioTest()
{
QWidget *window = new QWidget;
QVBoxLayout* layout = new QVBoxLayout;
deviceBox = new QComboBox(this);
foreach (const QAudioDeviceInfo &deviceInfo, QAudioDeviceInfo::availableDevices(QAudio::AudioOutput))
deviceBox->addItem(deviceInfo.deviceName(), qVariantFromValue(deviceInfo));
connect(deviceBox,SIGNAL(activated(int)),SLOT(deviceChanged(int)));
layout->addWidget(deviceBox);
button = new QPushButton(this);
button->setText(tr("Click for Push Mode"));
connect(button,SIGNAL(clicked()),SLOT(toggle()));
layout->addWidget(button);
button2 = new QPushButton(this);
button2->setText(tr("Click To Suspend"));
connect(button2,SIGNAL(clicked()),SLOT(togglePlay()));
layout->addWidget(button2);
window->setLayout(layout);
setCentralWidget(window);
window->show();
buffer = new char[BUFFER_SIZE];
gen = new Generator(this);
pullMode = true;
timer = new QTimer(this);
connect(timer,SIGNAL(timeout()),SLOT(writeMore()));
gen->start();
settings.setFrequency(SYSTEM_FREQ);
settings.setChannels(1);
settings.setSampleSize(16);
settings.setCodec("audio/pcm");
settings.setByteOrder(QAudioFormat::LittleEndian);
settings.setSampleType(QAudioFormat::SignedInt);
QAudioDeviceInfo info(QAudioDeviceInfo::defaultOutputDevice());
if (!info.isFormatSupported(settings)) {
qWarning()<<"default format not supported try to use nearest";
settings = info.nearestFormat(settings);
}
if(settings.sampleSize() != 16) {
qWarning()<<"audio device doesn't support 16 bit samples, example cannot run";
button->setDisabled(true);
button2->setDisabled(true);
audioOutput = 0;
return;
}
audioOutput = new QAudioOutput(settings,this);
connect(audioOutput,SIGNAL(notify()),SLOT(status()));
connect(audioOutput,SIGNAL(stateChanged(QAudio::State)),SLOT(state(QAudio::State)));
audioOutput->start(gen);
}
void def_debug()
{
if(key_alt)
{
diag_status();
return;
}
if(key_shift)
{
diag_status();
freeze_mode = !freeze_mode;
if (freeze_mode)
{
def_oldmouse = mouse_mode;
mouse_mode = 4;
mouse_pointer = 2;
}
else
mouse_mode = def_oldmouse;
while (freeze_mode)
{
if(mouse_left)
watched = mouse_ent;
wait(1);
}
return;
}
if (key_ctrl) {
toggle(viewMap,SHOW);
while is(viewMap,SHOW) {
vec_set(&viewMap->x,&camera->x);
viewMap->z += 10000;
wait(1);
}
return;
}
if(d3d_lines) {
reset(def_debug_pan,SHOW);
d3d_lines = 0;
diag_mode &= ~1;
} else {
if is(def_debug_pan,SHOW) {
d3d_lines = 3;
} else {
set(def_debug_pan,SHOW);
diag_mode |= 1;
while is(def_debug_pan,SHOW) {
def_dfps = 0.9*def_dfps+0.1/time_frame;
def_dtlv = time_level+time_sky;
def_dtcs = time_client+time_server;
def_dtrf = time_update+time_idle;
def_dtac = time_actions+time_pfuncs;
def_cang.pan = cycle(camera->pan,0,360);
def_cang.tilt = cycle(camera->tilt,-180,180);
def_cang.roll = cycle(camera->roll,-180,180);
pan_setcolor(def_debug_pan, 1, 3, vector(0, 255, 0));
wait(1);
}
}
}
}
void ofxSimpleGuiToggle::onKeyEnter() {
toggle();
}
void MButton::modelClick()
{
toggle();
emit clicked(isChecked());
}
int chaser_window(int xcha,int ycha)
{
ol::Rect ChaserPanel(ol::Vec2D(xcha, ycha), ol::Vec2D( 620,(160+(nbre_track_visualisables*40))));
ChaserPanel.SetRoundness(15);
ChaserPanel.SetLineWidth(triple_epaisseur_ligne_fader);
ChaserPanel.Draw(CouleurFond);
if(window_focus_id==W_CHASERS)
{
ChaserPanel.DrawOutline(CouleurFader);
}
else {ChaserPanel.DrawOutline(CouleurLigne); }
neuro.Print("CHASERS",xcha+100,ycha+30);
//////PARTIE GENERALE DU CHASER///////////////////////////////////////////////
//UP DOWN bangers number selected
ol::Circle ChazePlus(ol::Vec2D(xcha+300,ycha+25),12);
ol::Circle ChazeMinus(ol::Vec2D(xcha+220,ycha+25),12);
petitchiffre.Print("-",xcha+217,ycha+28);
petitchiffre.Print("+",xcha+295,ycha+28);
neuro.Print(ol::ToString(chaser_selected+1),xcha+250,ycha+32);
ChazePlus.DrawOutline(CouleurLigne);
ChazeMinus.DrawOutline(CouleurLigne);
if( Midi_Faders_Affectation_Type!=0 && window_focus_id==923)//config midi
{
if( mouse_x>xcha+208 && mouse_x<xcha+232 && mouse_y>ycha+13 && mouse_y<ycha+37)
{ChazeMinus.DrawOutline(CouleurBlind);}
if(mouse_x>xcha+288 && mouse_x<xcha+312 && mouse_y>ycha+13 && mouse_y<ycha+37)
{ChazePlus.DrawOutline(CouleurBlind);}
}
//////////////////////TEXT////////////////////////////////////////////
ol::Rect GiveNameOfchaser(ol::Vec2D(xcha+330,ycha+10), ol::Vec2D( 185,30));
GiveNameOfchaser.SetRoundness(7.5);
GiveNameOfchaser.Draw(CouleurSurvol);
petitchiffre.Print( chaser_name[chaser_selected],(xcha+335), (ycha+30));
//////////////EDIT MODE
ol::Rect ChazeEditEnable( ol::Vec2D((xcha+560),(ycha+10)),ol::Vec2D(50,20));
ChazeEditEnable.SetRoundness(7.5);
if(index_enable_edit_chaser==1)
{
ChazeEditEnable.Draw(CouleurFader);
}
ChazeEditEnable.DrawOutline(CouleurLigne);
petitchiffre.Print("edit",xcha+570 ,ycha+22);
////////////////////////////
////////////////////////////////boutons d action de la lecture globale du chaser
//play
play_button_view(xcha+10,ycha+50,chaser_is_playing[chaser_selected]);
//seek to begin
if(mouse_x>xcha+40 && mouse_x<xcha+60 && mouse_y>ycha+50 && mouse_y<ycha+70 && window_focus_id==923 && mouse_button==1 && mouse_released==0)
{
seek_button_view(xcha+40,ycha+50,1);//seek , affichage avant le bouton
mouse_released=1;
}
seek_button_view(xcha+40,ycha+50,0);
//loop
loop_button_view(xcha+70,ycha+50,chaser_is_in_loop[chaser_selected]);
//forward sens
if(chaser_way[chaser_selected]==0)
{set_forward_sens_view(xcha+110,ycha+50,1);}
else {set_forward_sens_view(xcha+110,ycha+50,0);}
//backward sens
if(chaser_way[chaser_selected]==1)
{set_backward_sens_view(xcha+140,ycha+50,1);}
else {set_backward_sens_view(xcha+140,ycha+50,0);}
//backward and forward sens
if(chaser_aller_retour[chaser_selected]==1)
{set_back_and_forward_sens_view(xcha+170,ycha+50,1);}
else {set_back_and_forward_sens_view(xcha+170,ycha+50,0);}
///AFFECT TO DOCK/////////////////////////////////////////////////////
char temp_str_chi[36];
sprintf(temp_str_chi,"Last Affect: Fader %d Dock %d",view_chaser_affected_to_fader[chaser_selected][0]+1,view_chaser_affected_to_fader[chaser_selected][1]+1);
petitpetitchiffregris.Print(temp_str_chi,xcha+5,ycha+120);
sprintf(temp_str_chi,"Step Is: %d Evolution: %.2f",chaser_step_is[chaser_selected]+1,index_progression_chaser_step[chaser_selected]);
petitpetitchiffregris.Print(temp_str_chi,xcha+5,ycha+137);
sprintf(temp_str_chi,"Chaser LFO Slaviness: %.2f",chaser_slaviness[chaser_selected]);
petitpetitchiffregris.Print(temp_str_chi,xcha+5,ycha+150);
ol::Rect Affectchaser(ol::Vec2D(xcha+430,ycha+80), ol::Vec2D(110,20));
Affectchaser.SetRoundness(7.5);
if(index_affect_chaser_to_dock==1){Affectchaser.Draw(CouleurFader);}
Affectchaser.DrawOutline(CouleurLigne);
petitchiffre.Print( "Affect To Dock",(xcha+440), (ycha+95));
/////////////ACTIONS SUR ON TRACK ET SELECTIONS
if(mouse_x>xcha+10 && mouse_x<xcha+30 && mouse_y>ycha+80 && mouse_y<ycha+100 && window_focus_id==923)
{
if(mouse_button==1 && mouse_released==0)
{
bouton_text_view(xcha+10, ycha+80,"all", 1);
}
}
bouton_text_view(xcha+10, ycha+80,"all", 0);
//selections//////////////////////////////////////////////////
if(mouse_x>xcha+40 && mouse_x<xcha+60 && mouse_y>ycha+80 && mouse_y<ycha+100 && window_focus_id==923)
{
if(mouse_button==1 && mouse_released==0)
{
bouton_text_view(xcha+40, ycha+80,"inv", 1);
}
}
bouton_text_view(xcha+40, ycha+80,"inv", 0);
if(mouse_x>xcha+70 && mouse_x<xcha+90 && mouse_y>ycha+80 && mouse_y<ycha+100 && window_focus_id==923)
{
if(mouse_button==1 && mouse_released==0)
{
bouton_text_view(xcha+70, ycha+80,"off", 1);
}
}
bouton_text_view(xcha+70, ycha+80,"off", 0);
/////////////////presets de selection////////////////////////////////////////
char tl[8];
for(int po=0;po<4;po++)
{
sprintf(tl,"P%d",po+1);
if(mouse_x>xcha+110+(po*30) && mouse_x<xcha+150+(po*30) && mouse_y>ycha+80 && mouse_y<ycha+100 && window_focus_id==923)
{
if(mouse_button==1 && mouse_released==0)
{
bouton_text_view(xcha+110+(po*30), ycha+80,tl, 1);
}
}
bouton_text_view(xcha+110+(po*30), ycha+80,tl, 0);
}
/////////////////OPTIONS
ol::Rect RelyToFaderMode(ol::Vec2D(xcha+345,ycha+50),ol::Vec2D(40,20));
RelyToFaderMode.SetRoundness(5);
if(index_slave_chaser_to_accelerometre[chaser_selected]==1)
{RelyToFaderMode.Draw(CouleurFader); }
RelyToFaderMode.DrawOutline(CouleurLigne);
petitpetitchiffre.Print("Slave",xcha+350,ycha+65);
////////////////////Time unit////////////////////////////////////////
char temp_tunit[24];
ol::Rect Tunit(ol::Vec2D(xcha+245,ycha+50),ol::Vec2D(50,20));
Tunit.SetRoundness(5);
if(mouse_x>xcha+245 && mouse_x<xcha+295 && mouse_y>ycha+50 && mouse_y<ycha+70)
{
Tunit.Draw(CouleurBleuProcedure.WithAlpha(0.4));
}
Tunit.DrawOutline(CouleurLigne);
switch(index_affichage_digit_time_unit)
{
case 0:
sprintf(temp_tunit,"T.Unit: %.1f",time_unit[chaser_selected]*chaser_slaviness[chaser_selected]);
break;
case 1:
sprintf(temp_tunit,"T.Unit: %.2f",time_unit[chaser_selected]*chaser_slaviness[chaser_selected]);
break;
case 2:
sprintf(temp_tunit,"T.Unit: %.3f",time_unit[chaser_selected]*chaser_slaviness[chaser_selected]);
break;
case 3:
sprintf(temp_tunit,"T.Unit: %.4f",time_unit[chaser_selected]*chaser_slaviness[chaser_selected]);
break;
}
petitpetitchiffre.Print(temp_tunit,xcha+200,ycha+64);
///time joint mode//////////////////////////////////////////////////////
ol::Rect TMode(ol::Vec2D(xcha+305,ycha+50),ol::Vec2D(30,20));
TMode.SetRoundness(5);
if(chaser_time_mode[chaser_selected]==1)
{
TMode.Draw(CouleurFader);
petitpetitchiffre.Print("TJoin",xcha+306,ycha+65);
}
else {petitpetitchiffre.Print("T.Std",xcha+305,ycha+65);}
TMode.DrawOutline(CouleurLigne);
/////////////////////CHASER OPERATOR/////////////////////////////////////
switch (chaser_operator_is)
{
case 1://up
bouton_track_up(xcha+245, ycha+80, 1);
bouton_track_stay(xcha+295, ycha+80, 0);
bouton_track_down(xcha+345, ycha+80, 0);
break;
case 2://stay
bouton_track_up(xcha+245, ycha+80, 0);
bouton_track_stay(xcha+295, ycha+80, 1);
bouton_track_down(xcha+345, ycha+80, 0);
break;
case 3: //down
bouton_track_up(xcha+245, ycha+80, 0);
bouton_track_stay(xcha+295, ycha+80, 0);
bouton_track_down(xcha+345, ycha+80, 1);
break;
default:
bouton_track_up(xcha+245, ycha+80, 0);
bouton_track_stay(xcha+295, ycha+80, 0);
bouton_track_down(xcha+345, ycha+80, 0);
break;
}
//BEGIN POINT // END POINT
ol::Rect CurseurBeginPoint(ol::Vec2D(xcha+175+(chaser_begin_step_is[chaser_selected]*12),ycha+115),ol::Vec2D(12,12));
CurseurBeginPoint.Draw(CouleurFader);
if( Midi_Faders_Affectation_Type!=0 && mouse_x>xcha+175+(chaser_begin_step_is[chaser_selected]*12) && mouse_x<xcha+187+(chaser_begin_step_is[chaser_selected]*12)
&& mouse_y>ycha+115 && mouse_y<ycha+127)//config midi
{
CurseurBeginPoint.SetLineWidth(2);
CurseurBeginPoint.DrawOutline(CouleurRed);
}
ol::Rect CurseurEndPoint(ol::Vec2D(xcha+175+(chaser_end_step_is[chaser_selected]*12),ycha+127),ol::Vec2D(12,12));
CurseurEndPoint.Draw(CouleurRed);
if( Midi_Faders_Affectation_Type!=0 && mouse_x>xcha+175+(chaser_end_step_is[chaser_selected]*12) && mouse_x<xcha+187+(chaser_end_step_is[chaser_selected]*12)
&& mouse_y>ycha+127 && mouse_y<ycha+139)//config midi
{
CurseurEndPoint.SetLineWidth(2);
CurseurEndPoint.Draw(CouleurFond);
CurseurEndPoint.DrawOutline(CouleurRed);
}
/////////////////////VIEW TRACK BUTTON////////////////////////////////////////////////
bouton_view_track_downup(xcha+580, ycha+35, 0);
int upsidedown=1;
/////////POSITION TIME LINE + IN OUT POINT VIEW//////////////////////////////////////////////////
for(int chcase=0;chcase<nbre_de_cases_par_track;chcase++)
{
upsidedown=toggle(upsidedown);
ol::Line(ol::Vec2D(xcha+175+(chcase*12),ycha+115),ol::Vec2D(xcha+175+(chcase*12),ycha+135)).Draw(CouleurLigne.WithAlpha(0.2));
petitpetitchiffre.Print(ol::ToString(chcase+1),xcha+175+(chcase*12),ycha+123+(upsidedown*12));
}
ol::Line(ol::Vec2D(xcha+10,ycha+125),ol::Vec2D(xcha+590,ycha+125)).Draw(CouleurLigne.WithAlpha(0.3));
////////////////////////TRACK/////////////////////////////////////////////
for(int track_num=0;track_num<nbre_track_visualisables;track_num++)
{
Track_draw(xcha+5,ycha+165+(track_num*40),position_affichage_track_num[chaser_selected]+track_num);
}
//CURSEUR TIME
ol::Rect TimelineChaser(ol::Vec2D(xcha+175,ycha+145),ol::Vec2D(36*12,10));
TimelineChaser.Draw(CouleurLigne.WithAlpha(0.2));
if( Midi_Faders_Affectation_Type!=0)//config midi
{
if(mouse_x>xcha+175 && mouse_x<xcha+175+(nbre_de_cases_par_track*12) && mouse_y>ycha+145 && mouse_y<ycha+155)
{
TimelineChaser.DrawOutline(CouleurBlind);
}
}
int id_way=0;
switch(chaser_way[chaser_selected])
{
case 0://FORWARD
id_way=1;
ol::Line(ol::Vec2D(xcha+175+(chaser_step_is[chaser_selected]*12)+(index_progression_chaser_step[chaser_selected]*12*id_way),ycha+115),ol::Vec2D(xcha+175+(chaser_step_is[chaser_selected]*12)+(index_progression_chaser_step[chaser_selected]*12*id_way),ycha+145+(nbre_track_visualisables*40))).Draw(CouleurFader);
ol::Line(ol::Vec2D(xcha+176+(chaser_step_is[chaser_selected]*12)+(index_progression_chaser_step[chaser_selected]*12*id_way),ycha+115),ol::Vec2D(xcha+176+(chaser_step_is[chaser_selected]*12)+(index_progression_chaser_step[chaser_selected]*12*id_way),ycha+145+(nbre_track_visualisables*40))).Draw(CouleurFader);
break;
case 1://BACKWARD
id_way=-1;
ol::Line(ol::Vec2D(xcha+175+((chaser_step_is[chaser_selected]+1)*12)+(index_progression_chaser_step[chaser_selected]*12*id_way),ycha+115),ol::Vec2D(xcha+175+((chaser_step_is[chaser_selected]+1)*12)+(index_progression_chaser_step[chaser_selected]*12*id_way),ycha+145+(nbre_track_visualisables*40))).Draw(CouleurFader);
ol::Line(ol::Vec2D(xcha+176+((chaser_step_is[chaser_selected]+1)*12)+(index_progression_chaser_step[chaser_selected]*12*id_way),ycha+115),ol::Vec2D(xcha+176+((chaser_step_is[chaser_selected]+1)*12)+(index_progression_chaser_step[chaser_selected]*12*id_way),ycha+145+(nbre_track_visualisables*40))).Draw(CouleurFader);
break;
}
ol::Rect PosCurseur(ol::Vec2D(xcha+175+(chaser_step_is[chaser_selected]*12)+(12*index_progression_chaser_step[chaser_selected]*id_way),ycha+145),ol::Vec2D(12,10));
PosCurseur.Draw(CouleurLigne.WithAlpha(0.3));
////////LAUNCHPAD
ol::Rect LaunchpadAllowB(ol::Vec2D(xcha+410,ycha+50),ol::Vec2D(40,20));
LaunchpadAllowB.SetRoundness(5);
if( launchpad_chaser_mode==1)
{
LaunchpadAllowB.Draw(CouleurFader);
bouton_view_launchpad_pos(xcha+450, ycha+35,0);
}
LaunchpadAllowB.DrawOutline(CouleurLigne);
petitpetitchiffre.Print("LchPad",xcha+411,ycha+65);
//refresh midi
ol::Rect refreshMidiB(ol::Vec2D(xcha+520,ycha+50),ol::Vec2D(40,20));
refreshMidiB.SetRoundness(5);
refreshMidiB.Draw(CouleurSurvol.WithAlpha( refresh_midi_chasers));
refreshMidiB.DrawOutline(CouleurLigne);
petitpetitchiffre.Print("Refresh",xcha+520,ycha+58);
petitpetitchiffre.Print("Midi",xcha+527,ycha+67);
return(0);
}
int menu_setup(int timeout) {
FBWidth = currentWindow->framebuffer.width;
FBHeight = currentWindow->framebuffer.height;
imgiPhoneOS = framebuffer_load_image(dataiPhoneOSPNG, dataiPhoneOSPNG_size, &imgiPhoneOSWidth, &imgiPhoneOSHeight, TRUE);
imgiPhoneOSSelected = framebuffer_load_image(dataiPhoneOSSelectedPNG, dataiPhoneOSSelectedPNG_size, &imgiPhoneOSWidth, &imgiPhoneOSHeight, TRUE);
imgConsole = framebuffer_load_image(dataConsolePNG, dataConsolePNG_size, &imgConsoleWidth, &imgConsoleHeight, TRUE);
imgConsoleSelected = framebuffer_load_image(dataConsoleSelectedPNG, dataConsoleSelectedPNG_size, &imgConsoleWidth, &imgConsoleHeight, TRUE);
imgAndroidOS_unblended = framebuffer_load_image(dataAndroidOSPNG, dataAndroidOSPNG_size, &imgAndroidOSWidth, &imgAndroidOSHeight, TRUE);
imgAndroidOSSelected_unblended = framebuffer_load_image(dataAndroidOSSelectedPNG, dataAndroidOSSelectedPNG_size, &imgAndroidOSWidth, &imgAndroidOSHeight, TRUE);
imgHeader = framebuffer_load_image(dataHeaderPNG, dataHeaderPNG_size, &imgHeaderWidth, &imgHeaderHeight, TRUE);
bufferPrintf("menu: images loaded\r\n");
imgiPhoneOSX = (FBWidth - imgiPhoneOSWidth) / 2;
imgiPhoneOSY = 84;
imgConsoleX = (FBWidth - imgConsoleWidth) / 2;
imgConsoleY = 207;
imgAndroidOSX = (FBWidth - imgAndroidOSWidth) / 2;
imgAndroidOSY = 330;
imgHeaderX = (FBWidth - imgHeaderWidth) / 2;
imgHeaderY = 17;
framebuffer_draw_image(imgHeader, imgHeaderX, imgHeaderY, imgHeaderWidth, imgHeaderHeight);
framebuffer_draw_rect_hgradient(0, 42, 0, 360, FBWidth, (FBHeight - 12) - 360);
framebuffer_draw_rect_hgradient(0x22, 0x22, 0, FBHeight - 12, FBWidth, 12);
framebuffer_setloc(0, 47);
framebuffer_setcolors(COLOR_WHITE, 0x222222);
framebuffer_print_force(OPENIBOOT_VERSION_STR);
framebuffer_setcolors(COLOR_WHITE, COLOR_BLACK);
framebuffer_setloc(0, 0);
imgAndroidOS = malloc(imgAndroidOSWidth * imgAndroidOSHeight * sizeof(uint32_t));
imgAndroidOSSelected = malloc(imgAndroidOSWidth * imgAndroidOSHeight * sizeof(uint32_t));
framebuffer_capture_image(imgAndroidOS, imgAndroidOSX, imgAndroidOSY, imgAndroidOSWidth, imgAndroidOSHeight);
framebuffer_capture_image(imgAndroidOSSelected, imgAndroidOSX, imgAndroidOSY, imgAndroidOSWidth, imgAndroidOSHeight);
framebuffer_blend_image(imgAndroidOS, imgAndroidOSWidth, imgAndroidOSHeight, imgAndroidOS_unblended, imgAndroidOSWidth, imgAndroidOSHeight, 0, 0);
framebuffer_blend_image(imgAndroidOSSelected, imgAndroidOSWidth, imgAndroidOSHeight, imgAndroidOSSelected_unblended, imgAndroidOSWidth, imgAndroidOSHeight, 0, 0);
Selection = MenuSelectioniPhoneOS;
OtherFramebuffer = CurFramebuffer;
CurFramebuffer = (volatile uint32_t*) NextFramebuffer;
drawSelectionBox();
pmu_set_iboot_stage(0);
memcpy((void*)NextFramebuffer, (void*) CurFramebuffer, NextFramebuffer - (uint32_t)CurFramebuffer);
uint64_t startTime = timer_get_system_microtime();
while(TRUE) {
if(buttons_is_pushed(BUTTONS_HOLD)) {
toggle(TRUE);
startTime = timer_get_system_microtime();
udelay(200000);
}
#ifndef CONFIG_IPOD
if(!buttons_is_pushed(BUTTONS_VOLUP)) {
toggle(FALSE);
startTime = timer_get_system_microtime();
udelay(200000);
}
if(!buttons_is_pushed(BUTTONS_VOLDOWN)) {
toggle(TRUE);
startTime = timer_get_system_microtime();
udelay(200000);
}
#endif
if(buttons_is_pushed(BUTTONS_HOME)) {
break;
}
if(timeout > 0 && has_elapsed(startTime, (uint64_t)timeout * 1000)) {
bufferPrintf("menu: timed out, selecting current item\r\n");
break;
}
udelay(10000);
}
if(Selection == MenuSelectioniPhoneOS) {
Image* image = images_get(fourcc("ibox"));
if(image == NULL)
image = images_get(fourcc("ibot"));
void* imageData;
images_read(image, &imageData);
chainload((uint32_t)imageData);
}
if(Selection == MenuSelectionConsole) {
// Reset framebuffer back to original if necessary
if((uint32_t) CurFramebuffer == NextFramebuffer)
{
CurFramebuffer = OtherFramebuffer;
currentWindow->framebuffer.buffer = CurFramebuffer;
lcd_window_address(2, (uint32_t) CurFramebuffer);
}
framebuffer_setdisplaytext(TRUE);
framebuffer_clear();
}
if(Selection == MenuSelectionAndroidOS) {
// Reset framebuffer back to original if necessary
if((uint32_t) CurFramebuffer == NextFramebuffer)
{
CurFramebuffer = OtherFramebuffer;
currentWindow->framebuffer.buffer = CurFramebuffer;
lcd_window_address(2, (uint32_t) CurFramebuffer);
}
framebuffer_setdisplaytext(TRUE);
framebuffer_clear();
#ifndef NO_HFS
radio_setup();
nand_setup();
fs_setup();
if(globalFtlHasBeenRestored) /* if ftl has been restored, sync it, so kernel doesn't have to do a ftl_restore again */
{
if(ftl_sync())
{
bufferPrintf("ftl synced successfully");
}
else
{
bufferPrintf("error syncing ftl");
}
}
pmu_set_iboot_stage(0);
startScripting("linux"); //start script mode if there is a script file
boot_linux_from_files();
#endif
}
return 0;
}
void UDoor::close()
{
if (is_open())
toggle();
}
int Grider_Box(int xb, int yb)
{
Rect GriderBack(Vec2D(xb,yb),Vec2D(largeurGrider,hauteurGrider));
GriderBack.SetRoundness(15);
GriderBack.SetLineWidth(triple_epaisseur_ligne_fader);
GriderBack.Draw(CouleurFond);
if(window_focus_id==926)
{
GriderBack.DrawOutline(CouleurFader);
}
else
{
GriderBack.DrawOutline(CouleurLigne);
}
neuro.Print( "Grid",(xb+90), (yb+15));
neuro.Print( "Players",(xb+90), (yb+35));
//definition debut chan du grider
Rect BackGriderChan(Vec2D(xb+245,yb+15),Vec2D(40,20));
BackGriderChan.SetRoundness(4);
BackGriderChan.Draw(CouleurBleuProcedure.WithAlpha(0.5));
petitchiffre.Print("Beg.Chan.",xb+180,yb+30);
petitchiffre.Print(ol::ToString(grider_begin_channel_is),xb+250,yb+30);
//def number row and cols
Rect BackGriderCol(Vec2D(xb+315,yb+15),Vec2D(30,20));
BackGriderCol.SetRoundness(4);
BackGriderCol.Draw(CouleurBleuProcedure.WithAlpha(0.5));
petitchiffre.Print("Col.:",xb+290,yb+30);
petitchiffre.Print(ol::ToString(grider_nb_col),xb+320,yb+30);
Rect BackGriderRow(Vec2D(xb+385,yb+15),Vec2D(30,20));
BackGriderRow.SetRoundness(4);
BackGriderRow.Draw(CouleurBleuProcedure.WithAlpha(0.5));
petitchiffre.Print("Rows:",xb+347,yb+30);
petitchiffre.Print(ol::ToString(grider_nb_row),xb+390,yb+30);
//////////////EDIT MODE///////////////////////////////
Rect GriderEditEnable( Vec2D((xb+430),(yb+15)),Vec2D(50,20));
GriderEditEnable.SetRoundness(7.5);
if(index_enable_edit_Grider==1)
{
GriderEditEnable.Draw(CouleurFader);
}
GriderEditEnable.DrawOutline(CouleurLigne);
petitchiffre.Print("edit",xb+440 ,yb+27);
/////////////nbre Gridplayers affichage///////////////////////////
petitpetitchiffre.Print("GridPlayers",xb+535,yb+13);
for(int o=0;o<core_user_define_nb_gridplayers;o++)
{
Rect ShowGridB(Vec2D(xb+540+(o*15),yb+20),Vec2D(10,10));
if(index_show_grid_player[o]==1)
{ShowGridB.Draw(CouleurFader);}
ShowGridB.DrawOutline(CouleurLigne.WithAlpha(0.7));
if(window_focus_id==W_GRID && mouse_x>xb+540+(o*15) && mouse_x<xb+540+(o*15)+10 && mouse_y>yb+20 && mouse_y<yb+30)
{
if(Midi_Faders_Affectation_Type!=0)
{
char sttmp[24];
sprintf(sttmp,"View GridPlayer %d",o+1);
show_type_midi(1472+o,sttmp );
ShowGridB.SetLineWidth(2.0);
ShowGridB.DrawOutline(CouleurBlind);
}
}
}
if( window_focus_id==W_GRID && mouse_y>yb+15 && mouse_y<yb+35)
{
if(mouse_x>xb+245 && mouse_x<xb+285 && index_enable_edit_Grider==1)//chan edit
{
BackGriderChan.DrawOutline(CouleurLigne);
}
if(mouse_x>xb+315 && mouse_x<xb+355 && index_enable_edit_Grider==1)//col edit
{
BackGriderCol.DrawOutline(CouleurLigne);
}
if(mouse_x>xb+385 && mouse_x<xb+425 && index_enable_edit_Grider==1)//rows edit
{
BackGriderRow.DrawOutline(CouleurLigne);
}
}
//Global grid viewer
petitpetitchiffre.Print("View",xb+495,yb+13);
Rect AllowGridViewerB(Vec2D(xb+495,yb+20),Vec2D(40,10));
AllowGridViewerB.Draw(CouleurFader.WithAlpha(show_global_view_grider));
AllowGridViewerB.DrawOutline(CouleurLigne);
if( window_focus_id==W_GRID && mouse_b&1 && mouse_released==0)
{
if(mouse_x>xb+495 && mouse_x<xb+535 && mouse_y>yb+20 && mouse_y<yb+30)
{
show_global_view_grider=toggle(show_global_view_grider);
refresh_hauteur_fenetre_grider();
mouse_released=1;
}
}
if(show_global_view_grider==1)
{GlobalGridViewer(xb,yb+40); }
//AFFICHAGE DES GRID PLAYERS
int numerodeplayer_affiche=0;
for(int yo=0;yo<core_user_define_nb_gridplayers;yo++)
{
if(index_show_grid_player[yo]==1)
{
Grid_player(xb, yb+50+hauteurGlobalGridviewer+(numerodeplayer_affiche*(60+(grider_facteur_hauteur*size_grille))), yo);
numerodeplayer_affiche++;
}
}
return(0);
}
int main(int argc, char *argv[]) {
#if __TBB_FLOW_GRAPH_CPP11_FEATURES
try {
utility::thread_number_range threads(get_default_num_threads);
utility::parse_cli_arguments(argc, argv,
utility::cli_argument_pack()
//"-h" option for displaying help is present implicitly
.positional_arg(threads,"#threads",utility::thread_number_range_desc)
.arg(verbose,"verbose"," print diagnostic output to screen")
.arg(silent,"silent"," limits output to timing info; overrides verbose")
);
if (silent) verbose = false; // make silent override verbose
tick_count start = tick_count::now();
for(int p = threads.first; p <= threads.last; p = threads.step(p)) {
task_scheduler_init init(p);
if (!silent) cout << "graph test running on " << p << " threads.\n";
graph g;
{ // test buffer: 0, 1
buffer b(g);
toggle input(g);
led output(g, "OUTPUT", false); // false means we will explicitly call display to see LED
make_edge(input.get_out(), input_port<0>(b));
make_edge(output_port<0>(b), output.get_in());
if (!silent) printf("Testing buffer...\n");
input.activate(); // 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
input.flip(); // 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
}
{ // test not_gate: 0, 1
not_gate n(g);
toggle input(g);
led output(g, "OUTPUT", false);
make_edge(input.get_out(), input_port<0>(n));
make_edge(output_port<0>(n), output.get_in());
if (!silent) printf("Testing not_gate...\n");
input.activate(); // 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input.flip(); // 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
}
{ // test two-input and_gate: 00, 01, 10, 11
and_gate<2> a(g);
toggle input0(g);
toggle input1(g);
led output(g, "OUTPUT", false);
make_edge(input0.get_out(), input_port<0>(a));
make_edge(input1.get_out(), input_port<1>(a));
make_edge(output_port<0>(a), output.get_in());
if (!silent) printf("Testing and_gate...\n");
input1.activate(); input0.activate(); // 0 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
input0.flip(); // 0 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
input1.flip(); input0.flip(); // 1 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
input0.flip(); // 1 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
}
{ // test three-input or_gate: 000, 001, 010, 100, 011, 101, 110, 111
or_gate<3> o(g);
toggle input0(g);
toggle input1(g);
toggle input2(g);
led output(g, "OUTPUT", false);
make_edge(input0.get_out(), input_port<0>(o));
make_edge(input1.get_out(), input_port<1>(o));
make_edge(input2.get_out(), input_port<2>(o));
make_edge(output_port<0>(o), output.get_in());
if (!silent) printf("Testing or_gate...\n");
input2.activate(); input1.activate(); input0.activate(); // 0 0 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
input0.flip(); // 0 0 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input1.flip(); input0.flip(); // 0 1 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input2.flip(); input1.flip(); // 1 0 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input2.flip(); input1.flip(); input0.flip(); // 0 1 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input2.flip(); input1.flip(); // 1 0 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input1.flip(); input0.flip(); // 1 1 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input0.flip(); // 1 1 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
}
{ // test two-input xor_gate: 00, 01, 10, 11
xor_gate<2> x(g);
toggle input0(g);
toggle input1(g);
led output(g, "OUTPUT", false);
make_edge(input0.get_out(), input_port<0>(x));
make_edge(input1.get_out(), input_port<1>(x));
make_edge(output_port<0>(x), output.get_in());
if (!silent) printf("Testing xor_gate...\n");
input1.activate(); input0.activate(); // 0 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
input0.flip(); // 0 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input1.flip(); input0.flip(); // 1 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input0.flip(); // 1 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
}
{ // test two-input nor_gate: 00, 01, 10, 11
nor_gate<2> n(g);
toggle input0(g);
toggle input1(g);
led output(g, "OUTPUT", false);
make_edge(input0.get_out(), input_port<0>(n));
make_edge(input1.get_out(), input_port<1>(n));
make_edge(output_port<0>(n), output.get_in());
if (!silent) printf("Testing nor_gate...\n");
input1.activate(); input0.activate(); // 0 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == high);
input0.flip(); // 0 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
input1.flip(); input0.flip(); // 1 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
input0.flip(); // 1 1
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == low);
}
{ // test steady_signal and digit
steady_signal input0(g, high);
steady_signal input1(g, low);
and_gate<2> a(g);
or_gate<2> o(g);
xor_gate<2> x(g);
nor_gate<2> n(g);
digit output(g, "OUTPUT", false);
make_edge(input0.get_out(), input_port<0>(a));
make_edge(input1.get_out(), input_port<1>(a));
make_edge(output_port<0>(a), input_port<0>(output));
make_edge(input0.get_out(), input_port<0>(o));
make_edge(input1.get_out(), input_port<1>(o));
make_edge(output_port<0>(o), input_port<1>(output));
make_edge(input0.get_out(), input_port<0>(x));
make_edge(input1.get_out(), input_port<1>(x));
make_edge(output_port<0>(x), input_port<2>(output));
make_edge(input0.get_out(), input_port<0>(n));
make_edge(input1.get_out(), input_port<1>(n));
make_edge(output_port<0>(n), input_port<3>(output));
if (!silent) printf("Testing steady_signal...\n");
input0.activate(); // 1
input1.activate(); // 0
g.wait_for_all();
if (!silent) output.display();
assert(output.get_value() == 6);
}
{ // test push_button
push_button p(g);
buffer b(g);
led output(g, "OUTPUT", !silent); // true means print all LED state changes
make_edge(p.get_out(), input_port<0>(b));
make_edge(output_port<0>(b), output.get_in());
if (!silent) printf("Testing push_button...\n");
p.press();
p.release();
p.press();
p.release();
g.wait_for_all();
}
{ // test one_bit_adder
one_bit_adder my_adder(g);
toggle A(g);
toggle B(g);
toggle CarryIN(g);
led Sum(g, "SUM");
led CarryOUT(g, "CarryOUT");
make_edge(A.get_out(), input_port<P::A0>(my_adder));
make_edge(B.get_out(), input_port<P::B0>(my_adder));
make_edge(CarryIN.get_out(), input_port<P::CI>(my_adder));
make_edge(output_port<P::S0>(my_adder), Sum.get_in());
make_edge(output_port<1>(my_adder), CarryOUT.get_in());
A.activate();
B.activate();
CarryIN.activate();
if (!silent) printf("A on\n");
A.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == high) && (CarryOUT.get_value() == low));
if (!silent) printf("A off\n");
A.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == low));
if (!silent) printf("B on\n");
B.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == high) && (CarryOUT.get_value() == low));
if (!silent) printf("B off\n");
B.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == low));
if (!silent) printf("CarryIN on\n");
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == high) && (CarryOUT.get_value() == low));
if (!silent) printf("CarryIN off\n");
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == low));
if (!silent) printf("A&B on\n");
A.flip();
B.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == high));
if (!silent) printf("A&B off\n");
A.flip();
B.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == low));
if (!silent) printf("A&CarryIN on\n");
A.flip();
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == high));
if (!silent) printf("A&CarryIN off\n");
A.flip();
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == low));
if (!silent) printf("B&CarryIN on\n");
B.flip();
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == high));
if (!silent) printf("B&CarryIN off\n");
B.flip();
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == low));
if (!silent) printf("A&B&CarryIN on\n");
A.flip();
B.flip();
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == high) && (CarryOUT.get_value() == high));
if (!silent) printf("A&B&CarryIN off\n");
A.flip();
B.flip();
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == low) && (CarryOUT.get_value() == low));
}
#if USE_TWO_BIT_FULL_ADDER
{ // test two_bit_adder
if (!silent) printf("testing two_bit adder\n");
two_bit_adder two_adder(g);
std::vector<toggle> A(2, toggle(g));
std::vector<toggle> B(2, toggle(g));
toggle CarryIN(g);
digit Sum(g, "SUM");
led CarryOUT(g, "CarryOUT");
make_edge(A[0].get_out(), input_port<P::A0>(two_adder));
make_edge(B[0].get_out(), input_port<P::B0>(two_adder));
make_edge(output_port<P::S0>(two_adder), input_port<0>(Sum));
make_edge(A[1].get_out(), input_port<P::A1>(two_adder));
make_edge(B[1].get_out(), input_port<P::B1>(two_adder));
make_edge(output_port<P::S1>(two_adder), input_port<1>(Sum));
make_edge(CarryIN.get_out(), input_port<P::CI>(two_adder));
make_edge(output_port<P::CO>(two_adder), CarryOUT.get_in());
// Activate all switches at low state
for (int i=0; i<2; ++i) {
A[i].activate();
B[i].activate();
}
CarryIN.activate();
if (!silent) printf("1+0\n");
A[0].flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 1) && (CarryOUT.get_value() == low));
if (!silent) printf("0+1\n");
A[0].flip();
B[0].flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 1) && (CarryOUT.get_value() == low));
}
#else
{ // test four_bit_adder
four_bit_adder four_adder(g);
std::vector<toggle> A(4, toggle(g));
std::vector<toggle> B(4, toggle(g));
toggle CarryIN(g);
digit Sum(g, "SUM");
led CarryOUT(g, "CarryOUT");
make_edge(A[0].get_out(), input_port<P::A0>(four_adder));
make_edge(B[0].get_out(), input_port<P::B0>(four_adder));
make_edge(output_port<P::S0>(four_adder), input_port<0>(Sum));
make_edge(A[1].get_out(), input_port<P::A1>(four_adder));
make_edge(B[1].get_out(), input_port<P::B1>(four_adder));
make_edge(output_port<P::S1>(four_adder), input_port<1>(Sum));
make_edge(A[2].get_out(), input_port<P::A2>(four_adder));
make_edge(B[2].get_out(), input_port<P::B2>(four_adder));
make_edge(output_port<P::S2>(four_adder), input_port<2>(Sum));
make_edge(A[3].get_out(), input_port<P::A3>(four_adder));
make_edge(B[3].get_out(), input_port<P::B3>(four_adder));
make_edge(output_port<P::S3>(four_adder), input_port<3>(Sum));
make_edge(CarryIN.get_out(), input_port<P::CI>(four_adder));
make_edge(output_port<P::CO>(four_adder), CarryOUT.get_in());
// Activate all switches at low state
for (int i=0; i<4; ++i) {
A[i].activate();
B[i].activate();
}
CarryIN.activate();
if (!silent) printf("1+0\n");
A[0].flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 1) && (CarryOUT.get_value() == low));
if (!silent) printf("0+1\n");
A[0].flip();
B[0].flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 1) && (CarryOUT.get_value() == low));
if (!silent) printf("3+4\n");
A[0].flip();
A[1].flip();
B[0].flip();
B[2].flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 7) && (CarryOUT.get_value() == low));
if (!silent) printf("6+1\n");
A[0].flip();
A[2].flip();
B[0].flip();
B[2].flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 7) && (CarryOUT.get_value() == low));
if (!silent) printf("0+0+carry\n");
A[1].flip();
A[2].flip();
B[0].flip();
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 1) && (CarryOUT.get_value() == low));
if (!silent) printf("15+15+carry\n");
A[0].flip();
A[1].flip();
A[2].flip();
A[3].flip();
B[0].flip();
B[1].flip();
B[2].flip();
B[3].flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 0xf) && (CarryOUT.get_value() == high));
if (!silent) printf("8+8\n");
A[0].flip();
A[1].flip();
A[2].flip();
B[0].flip();
B[1].flip();
B[2].flip();
CarryIN.flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 0) && (CarryOUT.get_value() == high));
if (!silent) printf("0+0\n");
A[3].flip();
B[3].flip();
g.wait_for_all();
if (!silent) Sum.display();
if (!silent) CarryOUT.display();
assert((Sum.get_value() == 0) && (CarryOUT.get_value() == low));
}
#endif
{ // test D_latch
D_latch my_d_latch(g);
toggle D(g);
pulse E(g, 500, 4); // clock changes every 500ms; stops after 4 changes
led Q(g, " Q", verbose); // if true, LEDs print at every state change
led notQ(g, "~Q", verbose);
make_edge(D.get_out(), input_port<0>(my_d_latch));
make_edge(E.get_out(), input_port<1>(my_d_latch));
make_edge(output_port<0>(my_d_latch), Q.get_in());
make_edge(output_port<1>(my_d_latch), notQ.get_in());
D.activate();
if (!silent) printf("Toggling D\n");
E.activate();
D.flip();
g.wait_for_all();
if (!silent && !verbose) { Q.display(); notQ.display(); }
assert((Q.get_value() == high) && (notQ.get_value() == low));
E.reset();
if (!silent) printf("Toggling D\n");
E.activate();
D.flip();
g.wait_for_all();
if (!silent && !verbose) { Q.display(); notQ.display(); }
assert((Q.get_value() == low) && (notQ.get_value() == high));
E.reset();
if (!silent) printf("Toggling D\n");
E.activate();
D.flip();
g.wait_for_all();
if (!silent && !verbose) { Q.display(); notQ.display(); }
assert((Q.get_value() == high) && (notQ.get_value() == low));
E.reset();
if (!silent) printf("Toggling D\n");
E.activate();
D.flip();
g.wait_for_all();
if (!silent && !verbose) { Q.display(); notQ.display(); }
assert((Q.get_value() == low) && (notQ.get_value() == high));
E.reset();
if (!silent) printf("Toggling D\n");
E.activate();
D.flip();
g.wait_for_all();
if (!silent && !verbose) { Q.display(); notQ.display(); }
assert((Q.get_value() == high) && (notQ.get_value() == low));
}
}
utility::report_elapsed_time((tbb::tick_count::now() - start).seconds());
return 0;
} catch(std::exception& e) {
cerr<<"error occurred. error text is :\"" <<e.what()<<"\"\n";
return 1;
}
#else
utility::report_skipped();
return 0;
#endif // __TBB_FLOW_GRAPH_CPP11_FEATURES
}
bool KIWAY_PLAYER::ShowModal( wxString* aResult, wxWindow* aResultantFocusWindow )
{
wxASSERT_MSG( IsModal(), wxT( "ShowModal() shouldn't be called on non-modal frame" ) );
/*
This function has a nice interface but a necessarily unsightly implementation.
Now the implementation is encapsulated, localizing future changes.
It works in tandem with DismissModal(). But only ShowModal() is in the
vtable and therefore cross-module capable.
*/
// This is an exception safe way to zero a pointer before returning.
// Yes, even though DismissModal() clears this first normally, this is
// here in case there's an exception before the dialog is dismissed.
struct NULLER
{
void*& m_what;
NULLER( void*& aPtr ) : m_what( aPtr ) {}
~NULLER() { m_what = 0; } // indeed, set it to NULL on destruction
} clear_this( (void*&) m_modal_loop );
m_modal_resultant_parent = aResultantFocusWindow;
Show( true );
Raise(); // Needed on some Window managers to always display the frame
SetFocus();
{
// We have to disable all frames but the the modal one.
// wxWindowDisabler does that, but it also disables all top level windows
// We do not want to disable top level windows which are child of the modal one,
// if they are enabled.
// An example is an aui toolbar which was moved
// or a dialog or an other frame or miniframe opened by the modal one.
wxWindowList wlist = GetChildren();
std::vector<wxWindow*> enabledTopLevelWindows;
for( unsigned ii = 0; ii < wlist.size(); ii++ )
if( wlist[ii]->IsTopLevel() && wlist[ii]->IsEnabled() )
enabledTopLevelWindows.push_back( wlist[ii] );
// exception safe way to disable all top level windows except the modal one,
// re-enables only those that were disabled on exit
wxWindowDisabler toggle( this );
for( unsigned ii = 0; ii < enabledTopLevelWindows.size(); ii++ )
enabledTopLevelWindows[ii]->Enable( true );
WX_EVENT_LOOP event_loop;
m_modal_loop = &event_loop;
event_loop.Run();
} // End of scope for some variables.
// End nesting before setting focus below.
if( aResult )
*aResult = m_modal_string;
DBG(printf( "~%s: aResult:'%s' ret:%d\n",
__func__, TO_UTF8( m_modal_string ), m_modal_ret_val );)
if( aResultantFocusWindow )
/**
* Switches on / off the given layer.
* Listeners are notified.
*/
void RS_LayerList::toggle(const QString& name) {
toggle(find(name));
}
void toggle_led(uint8_t num){
if (num < 6){
toggle(led_portmap[num], led_pinmap[num]);
}
}
int do_logical_ChannelsMenuSelection(int chx, int chy)
{
//LOGIQUE
//if(window_focus_id==0 && index_over_A_window==0 && index_over_faderspace==0 && mouse_button==1 && mouse_released==0)
if(window_focus_id==0 && index_over_faderspace==0 && mouse_button==1 && mouse_released==0)
{
if( mouse_y>chy+1 && mouse_y<chy+1+18 && mouse_x>chx+70 && mouse_x<chx+70+60 )
{
if(Midi_Faders_Affectation_Type!=0)
{
attribute_midi_solo_affectation(1644,Midi_Faders_Affectation_Mode);
}
else
{
ClassicalChannelView=toggle(ClassicalChannelView);
}
mouse_released=1;
}
for(int lv=0;lv<2;lv++)
{
for(int i=0;i<8;i++)
{
if(mouse_x>chx+140+(i*15) && mouse_x<chx+140+(i*15)+10 && mouse_y>chy+1+(15*lv) && mouse_y<chy+1+(15*lv)+10)
{
if(Midi_Faders_Affectation_Type!=0)
{
attribute_midi_to_control(1628+i+(lv*8),Midi_Faders_Affectation_Type,Midi_Faders_Affectation_Mode);
}
else
{
if(index_do_dock==0 && index_do_modify==0 && index_main_clear==0)
{
if(ClassicalChannelView==1){ClassicalChannelView=0;if(Channel_View_MODE[i+(lv*8)]==0){Channel_View_MODE[i+(lv*8)]=1;}}
else
{
Channel_View_MODE[i+(lv*8)]=toggle(Channel_View_MODE[i+(lv*8)]);
ClassicalChannelView=0;
}
}
else if(index_do_dock==1 && i+(lv*8)!=0)//=vue patch
{
channel_view_is=i+(lv*8);
index_ask_record_selection_of_view=i+(lv*8);
index_ask_confirm=1;
}
else if(index_do_modify==1 && i+(lv*8)!=0)//=vue patch
{
channel_view_is=i+(lv*8);
index_ask_modify_selection_of_view=1;
index_ask_confirm=1;
}
else if(index_main_clear==1 && i+(lv*8)!=0)//=vue patch
{
channel_view_is=i+(lv*8);
index_ask_confirm=1;
index_ask_clear_selection_of_view=1;
}
}
mouse_released=1;
}
}
}
command_button_logical(chx+270,chy+1,index_blind,"Blind","Shift-F10",754,110);
command_button_logical(chx+340,chy+1,index_direct_chan,"Direct CH.","",1333,111);
command_button_logical(chx+410,chy+1,index_inspekt,"View","",1334,112);// int x, inty ,bool state, char *textedesc, int midiaffectation
command_button_logical(chx+480,chy+1,index_do_hipass,"HiPass","",1542,113);// int x, inty ,bool state, char *textedesc, int midiaffectation
command_button_logical(chx+550,chy+1,index_do_fgroup,"FGroup","",1592,114);// int x, inty ,bool state, char *textedesc, int midiaffectation
command_button_logical(chx+620,chy+1,Midi_Faders_Affectation_Type,"MidiAffect","",1625,106);// int x, inty ,bool state, char *textedesc, int midiaffectation
command_button_logical(chx+690,chy+1,index_midi_mute,"MidiMute","",1277,107);// int x, inty ,bool state, char *textedesc, int midiaffectation
command_button_logical(chx+760,chy+1,index_global_midi_send_on_faders,"M.Out Fad.","",1593,109);// int x, inty ,bool state, char *textedesc, int midiaffectation
command_button_logical(chx+830,chy+1,index_do_dock,"STORE","F1",743,102);// int x, inty ,bool state, char *textedesc, int midiaffectation
command_button_logical(chx+900,chy+1,index_do_modify,"MODIFY","F2",744,103);
command_button_logical(chx+970,chy+1,index_do_report,"REPORT","F3",745,104);
command_button_logical(chx+1040,chy+1,index_main_clear,"CLEAR","F4",746,105);
command_button_logical(chx+1110,chy+1,index_show_main_menu,"MENUS","RIGHT CLICK",1626,108);
}
//fin windows focus
return(0);
}
int do_logical_Draw_Channel_Preset_Title(int xchan, int ychan, int prst_v)
{
if(window_focus_id==0 && mouse_button==1 && mouse_released==0 && prst_v!=0 )
{
if(mouse_y>ychan && mouse_y<ychan+20 )
{
//TITRE VIEW
if(mouse_x> xchan+40 && mouse_x<xchan+40+210)
{
if(prst_v>0 && index_type==1 )
{
sprintf( channel_view_Name[prst_v],numeric);
reset_numeric_entry();
numeric_postext=0;
mouse_released=1;
}
}
// Mem sel
else if(mouse_x> xchan+435 && mouse_x<xchan+435+20)
{
if(channel_view_type_of_behaviour[prst_v]!=1){channel_view_type_of_behaviour[prst_v]=1;}
else{channel_view_type_of_behaviour[prst_v]=0;}
mouse_released=1;
}
// fader sel
else if(mouse_x> xchan+460 && mouse_x<xchan+460+20 )
{
if(channel_view_type_of_behaviour[prst_v]!=2){channel_view_type_of_behaviour[prst_v]=2;}
else{channel_view_type_of_behaviour[prst_v]=0;}
mouse_released=1;
}
//All sel
else if(mouse_x> xchan+485 && mouse_x<xchan+485+30 )
{
channel_view_mode_builder[prst_v]=toggle(channel_view_mode_builder[prst_v]);
mouse_released=1;
}
//do build logique sortie car plantage grave à la reconstruction. il faut garder ca dans la boucle affichage
/* else if(mouse_x> xchan+520 && mouse_x<xchan+520+55 )
{
channel_view_is=prst_v;
if(index_do_dock==1)
{
if(channel_view_type_of_behaviour[channel_view_is]==0 && channel_view_mode_builder[channel_view_is]==0)
{index_ask_record_selection_of_view=1 ; index_ask_confirm=1; mouse_released=1;}
else {index_ask_build_view=1; index_ask_confirm=1; mouse_released=1; }
}
else if(index_do_modify==1)
{
index_ask_modify_selection_of_view=1 ;index_ask_confirm=1; mouse_released=1;
}
else if(index_do_report==1)
{
index_ask_report_selection_of_view=1;index_ask_confirm=1; mouse_released=1;
}
else if(index_main_clear==1)
{
index_ask_clear_selection_of_view=1; mouse_released=1;
}
} */
}
}
return(0);
}
/* inputs going to ISP1301 */
static void otg_update_isp(struct isp1301 *isp)
{
u32 otg_ctrl, otg_change;
u8 set = OTG1_DM_PULLDOWN, clr = OTG1_DM_PULLUP;
otg_ctrl = OTG_CTRL_REG;
otg_change = otg_ctrl ^ isp->last_otg_ctrl;
isp->last_otg_ctrl = otg_ctrl;
otg_ctrl = otg_ctrl & OTG_XCEIV_INPUTS;
switch (isp->otg.state) {
case OTG_STATE_B_IDLE:
case OTG_STATE_B_PERIPHERAL:
case OTG_STATE_B_SRP_INIT:
if (!(otg_ctrl & OTG_PULLUP)) {
// if (otg_ctrl & OTG_B_HNPEN) {
if (isp->otg.gadget->b_hnp_enable) {
isp->otg.state = OTG_STATE_B_WAIT_ACON;
pr_debug(" --> b_wait_acon\n");
}
goto pulldown;
}
pullup:
set |= OTG1_DP_PULLUP;
clr |= OTG1_DP_PULLDOWN;
break;
case OTG_STATE_A_SUSPEND:
case OTG_STATE_A_PERIPHERAL:
if (otg_ctrl & OTG_PULLUP)
goto pullup;
/* FALLTHROUGH */
// case OTG_STATE_B_WAIT_ACON:
default:
pulldown:
set |= OTG1_DP_PULLDOWN;
clr |= OTG1_DP_PULLUP;
break;
}
# define toggle(OTG,ISP) do { \
if (otg_ctrl & OTG) set |= ISP; \
else clr |= ISP; \
} while (0)
if (!(isp->otg.host))
otg_ctrl &= ~OTG_DRV_VBUS;
switch (isp->otg.state) {
case OTG_STATE_A_SUSPEND:
if (otg_ctrl & OTG_DRV_VBUS) {
set |= OTG1_VBUS_DRV;
break;
}
/* HNP failed for some reason (A_AIDL_BDIS timeout) */
notresponding(isp);
/* FALLTHROUGH */
case OTG_STATE_A_VBUS_ERR:
isp->otg.state = OTG_STATE_A_WAIT_VFALL;
pr_debug(" --> a_wait_vfall\n");
/* FALLTHROUGH */
case OTG_STATE_A_WAIT_VFALL:
/* FIXME usbcore thinks port power is still on ... */
clr |= OTG1_VBUS_DRV;
break;
case OTG_STATE_A_IDLE:
if (otg_ctrl & OTG_DRV_VBUS) {
isp->otg.state = OTG_STATE_A_WAIT_VRISE;
pr_debug(" --> a_wait_vrise\n");
}
/* FALLTHROUGH */
default:
toggle(OTG_DRV_VBUS, OTG1_VBUS_DRV);
}
toggle(OTG_PU_VBUS, OTG1_VBUS_CHRG);
toggle(OTG_PD_VBUS, OTG1_VBUS_DISCHRG);
# undef toggle
isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, set);
isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, clr);
/* HNP switch to host or peripheral; and SRP */
if (otg_change & OTG_PULLUP) {
switch (isp->otg.state) {
case OTG_STATE_B_IDLE:
if (clr & OTG1_DP_PULLUP)
break;
isp->otg.state = OTG_STATE_B_PERIPHERAL;
pr_debug(" --> b_peripheral\n");
break;
case OTG_STATE_A_SUSPEND:
if (clr & OTG1_DP_PULLUP)
break;
isp->otg.state = OTG_STATE_A_PERIPHERAL;
pr_debug(" --> a_peripheral\n");
break;
default:
break;
}
OTG_CTRL_REG |= OTG_PULLUP;
}
check_state(isp, __func__);
dump_regs(isp, "otg->isp1301");
}
AudioTest::AudioTest(QString main, QString passthrough,
int channels, AudioOutputSettings settings)
: VerticalConfigurationGroup(false, true, false, false),
m_channels(channels),
m_frontleft(NULL), m_frontright(NULL), m_center(NULL),
m_surroundleft(NULL), m_surroundright(NULL),
m_rearleft(NULL), m_rearright(NULL), m_lfe(NULL),
m_main(main), m_passthrough(passthrough), m_settings(settings),
m_quality(false)
{
setLabel(QObject::tr("Audio Configuration Testing"));
m_at = new AudioTestThread(this, main, passthrough, channels,
settings, m_quality);
if (!m_at->result().isEmpty())
{
QString msg = main + QObject::tr(" is invalid or not "
"useable.");
MythPopupBox::showOkPopup(
GetMythMainWindow(), QObject::tr("Warning"), msg);
return;
}
m_button = new TransButtonSetting("start");
m_button->setLabel(QObject::tr("Test All"));
m_button->setHelpText(QObject::tr("Start all channels test"));
connect(m_button, SIGNAL(pressed(QString)), this, SLOT(toggle(QString)));
ConfigurationGroup *frontgroup =
new HorizontalConfigurationGroup(false,
false);
ConfigurationGroup *middlegroup =
new HorizontalConfigurationGroup(false,
false);
ConfigurationGroup *reargroup =
new HorizontalConfigurationGroup(false,
false);
m_frontleft = new TransButtonSetting("0");
m_frontleft->setLabel(QObject::tr("Front Left"));
connect(m_frontleft,
SIGNAL(pressed(QString)), this, SLOT(toggle(QString)));
m_frontright = new TransButtonSetting(m_channels == 2 ? "1" : "2");
m_frontright->setLabel(QObject::tr("Front Right"));
connect(m_frontright,
SIGNAL(pressed(QString)), this, SLOT(toggle(QString)));
m_center = new TransButtonSetting("1");
m_center->setLabel(QObject::tr("Center"));
connect(m_center,
SIGNAL(pressed(QString)), this, SLOT(toggle(QString)));
frontgroup->addChild(m_frontleft);
switch(m_channels)
{
case 8:
m_rearleft = new TransButtonSetting("5");
m_rearleft->setLabel(QObject::tr("Rear Left"));
connect(m_rearleft,
SIGNAL(pressed(QString)), this, SLOT(toggle(QString)));
m_rearright = new TransButtonSetting("4");
m_rearright->setLabel(QObject::tr("Rear Right"));
connect(m_rearright,
SIGNAL(pressed(QString)), this, SLOT(toggle(QString)));
reargroup->addChild(m_rearleft);
reargroup->addChild(m_rearright);
case 6:
m_surroundleft = new TransButtonSetting(m_channels == 6 ?
"4" : "6");
m_surroundleft->setLabel(QObject::tr("Surround Left"));
connect(m_surroundleft,
SIGNAL(pressed(QString)), this, SLOT(toggle(QString)));
m_surroundright = new TransButtonSetting("3");
m_surroundright->setLabel(QObject::tr("Surround Right"));
connect(m_surroundright,
SIGNAL(pressed(QString)), this, SLOT(toggle(QString)));
m_lfe = new TransButtonSetting(m_channels == 6 ? "5" : "7");
m_lfe->setLabel(QObject::tr("LFE"));
connect(m_lfe,
SIGNAL(pressed(QString)), this, SLOT(toggle(QString)));
frontgroup->addChild(m_center);
middlegroup->addChild(m_surroundleft);
middlegroup->addChild(m_lfe);
middlegroup->addChild(m_surroundright);
case 2:
break;
}
frontgroup->addChild(m_frontright);
addChild(frontgroup);
addChild(middlegroup);
addChild(reargroup);
addChild(m_button);
m_hd = new TransCheckBoxSetting();
m_hd->setLabel(QObject::tr("Use Highest Quality Mode"));
m_hd->setHelpText(QObject::tr("Use the highest audio quality settings "
"supported by your audio card. This will be "
"a good place to start troubleshooting "
"potential errors"));
addChild(m_hd);
connect(m_hd, SIGNAL(valueChanged(QString)), this, SLOT(togglequality()));
}
Menu::Menu() {
MenuWrapper * fileMenu = addMenu("File");
#ifdef Q_OS_MAC
addActionToQMenuAndActionHash(fileMenu, MenuOption::AboutApp, 0, qApp, SLOT(aboutApp()), QAction::AboutRole);
#endif
auto dialogsManager = DependencyManager::get<DialogsManager>();
AccountManager& accountManager = AccountManager::getInstance();
{
addActionToQMenuAndActionHash(fileMenu, MenuOption::Login);
// connect to the appropriate signal of the AccountManager so that we can change the Login/Logout menu item
connect(&accountManager, &AccountManager::profileChanged,
dialogsManager.data(), &DialogsManager::toggleLoginDialog);
connect(&accountManager, &AccountManager::logoutComplete,
dialogsManager.data(), &DialogsManager::toggleLoginDialog);
}
addDisabledActionAndSeparator(fileMenu, "Scripts");
addActionToQMenuAndActionHash(fileMenu, MenuOption::LoadScript, Qt::CTRL | Qt::Key_O,
qApp, SLOT(loadDialog()));
addActionToQMenuAndActionHash(fileMenu, MenuOption::LoadScriptURL,
Qt::CTRL | Qt::SHIFT | Qt::Key_O, qApp, SLOT(loadScriptURLDialog()));
addActionToQMenuAndActionHash(fileMenu, MenuOption::StopAllScripts, 0, qApp, SLOT(stopAllScripts()));
addActionToQMenuAndActionHash(fileMenu, MenuOption::ReloadAllScripts, Qt::CTRL | Qt::Key_R,
qApp, SLOT(reloadAllScripts()));
addActionToQMenuAndActionHash(fileMenu, MenuOption::RunningScripts, Qt::CTRL | Qt::Key_J,
qApp, SLOT(toggleRunningScriptsWidget()));
addDisabledActionAndSeparator(fileMenu, "Location");
qApp->getBookmarks()->setupMenus(this, fileMenu);
addActionToQMenuAndActionHash(fileMenu,
MenuOption::AddressBar,
Qt::CTRL | Qt::Key_L,
dialogsManager.data(),
SLOT(toggleAddressBar()));
auto addressManager = DependencyManager::get<AddressManager>();
addActionToQMenuAndActionHash(fileMenu, MenuOption::CopyAddress, 0,
addressManager.data(), SLOT(copyAddress()));
addActionToQMenuAndActionHash(fileMenu, MenuOption::CopyPath, 0,
addressManager.data(), SLOT(copyPath()));
addActionToQMenuAndActionHash(fileMenu,
MenuOption::Quit,
Qt::CTRL | Qt::Key_Q,
qApp,
SLOT(quit()),
QAction::QuitRole);
MenuWrapper* editMenu = addMenu("Edit");
QUndoStack* undoStack = qApp->getUndoStack();
QAction* undoAction = undoStack->createUndoAction(editMenu);
undoAction->setShortcut(Qt::CTRL | Qt::Key_Z);
addActionToQMenuAndActionHash(editMenu, undoAction);
QAction* redoAction = undoStack->createRedoAction(editMenu);
redoAction->setShortcut(Qt::CTRL | Qt::SHIFT | Qt::Key_Z);
addActionToQMenuAndActionHash(editMenu, redoAction);
addActionToQMenuAndActionHash(editMenu,
MenuOption::Preferences,
Qt::CTRL | Qt::Key_Comma,
dialogsManager.data(),
SLOT(editPreferences()),
QAction::PreferencesRole);
addActionToQMenuAndActionHash(editMenu, MenuOption::Attachments, 0,
dialogsManager.data(), SLOT(editAttachments()));
addActionToQMenuAndActionHash(editMenu, MenuOption::Animations, 0,
dialogsManager.data(), SLOT(editAnimations()));
MenuWrapper* toolsMenu = addMenu("Tools");
addActionToQMenuAndActionHash(toolsMenu, MenuOption::ScriptEditor, Qt::ALT | Qt::Key_S,
dialogsManager.data(), SLOT(showScriptEditor()));
#if defined(Q_OS_MAC) || defined(Q_OS_WIN)
auto speechRecognizer = DependencyManager::get<SpeechRecognizer>();
QAction* speechRecognizerAction = addCheckableActionToQMenuAndActionHash(toolsMenu, MenuOption::ControlWithSpeech,
Qt::CTRL | Qt::SHIFT | Qt::Key_C,
speechRecognizer->getEnabled(),
speechRecognizer.data(),
SLOT(setEnabled(bool)));
connect(speechRecognizer.data(), SIGNAL(enabledUpdated(bool)), speechRecognizerAction, SLOT(setChecked(bool)));
#endif
addActionToQMenuAndActionHash(toolsMenu, MenuOption::Chat,
0, // QML Qt::Key_Backslash,
dialogsManager.data(), SLOT(showIRCLink()));
addActionToQMenuAndActionHash(toolsMenu, MenuOption::AddRemoveFriends, 0,
qApp, SLOT(showFriendsWindow()));
MenuWrapper* visibilityMenu = toolsMenu->addMenu("I Am Visible To");
{
QActionGroup* visibilityGroup = new QActionGroup(toolsMenu);
auto discoverabilityManager = DependencyManager::get<DiscoverabilityManager>();
QAction* visibleToEveryone = addCheckableActionToQMenuAndActionHash(visibilityMenu, MenuOption::VisibleToEveryone,
0, discoverabilityManager->getDiscoverabilityMode() == Discoverability::All,
discoverabilityManager.data(), SLOT(setVisibility()));
visibilityGroup->addAction(visibleToEveryone);
QAction* visibleToFriends = addCheckableActionToQMenuAndActionHash(visibilityMenu, MenuOption::VisibleToFriends,
0, discoverabilityManager->getDiscoverabilityMode() == Discoverability::Friends,
discoverabilityManager.data(), SLOT(setVisibility()));
visibilityGroup->addAction(visibleToFriends);
QAction* visibleToNoOne = addCheckableActionToQMenuAndActionHash(visibilityMenu, MenuOption::VisibleToNoOne,
0, discoverabilityManager->getDiscoverabilityMode() == Discoverability::None,
discoverabilityManager.data(), SLOT(setVisibility()));
visibilityGroup->addAction(visibleToNoOne);
connect(discoverabilityManager.data(), &DiscoverabilityManager::discoverabilityModeChanged,
discoverabilityManager.data(), &DiscoverabilityManager::visibilityChanged);
}
addActionToQMenuAndActionHash(toolsMenu,
MenuOption::ToolWindow,
Qt::CTRL | Qt::ALT | Qt::Key_T,
dialogsManager.data(),
SLOT(toggleToolWindow()));
addActionToQMenuAndActionHash(toolsMenu,
MenuOption::Console,
Qt::CTRL | Qt::ALT | Qt::Key_J,
DependencyManager::get<StandAloneJSConsole>().data(),
SLOT(toggleConsole()));
addActionToQMenuAndActionHash(toolsMenu,
MenuOption::ResetSensors,
0, // QML Qt::Key_Apostrophe,
qApp,
SLOT(resetSensors()));
addActionToQMenuAndActionHash(toolsMenu, MenuOption::PackageModel, 0,
qApp, SLOT(packageModel()));
MenuWrapper* avatarMenu = addMenu("Avatar");
QObject* avatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
MenuWrapper* avatarSizeMenu = avatarMenu->addMenu("Size");
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::IncreaseAvatarSize,
0, // QML Qt::Key_Plus,
avatar,
SLOT(increaseSize()));
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::DecreaseAvatarSize,
0, // QML Qt::Key_Minus,
avatar,
SLOT(decreaseSize()));
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::ResetAvatarSize,
0, // QML Qt::Key_Equal,
avatar,
SLOT(resetSize()));
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::KeyboardMotorControl,
Qt::CTRL | Qt::SHIFT | Qt::Key_K, true, avatar, SLOT(updateMotionBehavior()));
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::ScriptedMotorControl, 0, true,
avatar, SLOT(updateMotionBehavior()));
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::NamesAboveHeads, 0, true);
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::GlowWhenSpeaking, 0, true);
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::BlueSpeechSphere, 0, true);
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::EnableCharacterController, 0, true,
avatar, SLOT(updateMotionBehavior()));
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::ShiftHipsForIdleAnimations, 0, false,
avatar, SLOT(updateMotionBehavior()));
MenuWrapper* viewMenu = addMenu("View");
addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::Fullscreen,
#ifdef Q_OS_MAC
Qt::CTRL | Qt::META | Qt::Key_F,
#else
Qt::CTRL | Qt::Key_F,
#endif
false,
qApp,
SLOT(setFullscreen(bool)));
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::FirstPerson,
0, // QML Qt::Key_P,
true, qApp, SLOT(cameraMenuChanged()));
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::Mirror,
0, //QML Qt::SHIFT | Qt::Key_H,
true);
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::FullscreenMirror,
0, // QML Qt::Key_H,
false, qApp, SLOT(cameraMenuChanged()));
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::HMDTools,
#ifdef Q_OS_MAC
Qt::META | Qt::Key_H,
#else
Qt::CTRL | Qt::Key_H,
#endif
false,
dialogsManager.data(),
SLOT(hmdTools(bool)));
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::EnableVRMode, 0,
false,
qApp,
SLOT(setEnableVRMode(bool)));
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::Enable3DTVMode, 0,
false,
qApp,
SLOT(setEnable3DTVMode(bool)));
MenuWrapper* nodeBordersMenu = viewMenu->addMenu("Server Borders");
NodeBounds& nodeBounds = qApp->getNodeBoundsDisplay();
addCheckableActionToQMenuAndActionHash(nodeBordersMenu, MenuOption::ShowBordersEntityNodes,
Qt::CTRL | Qt::SHIFT | Qt::Key_1, false,
&nodeBounds, SLOT(setShowEntityNodes(bool)));
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::TurnWithHead, 0, false);
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::Stats);
addActionToQMenuAndActionHash(viewMenu, MenuOption::Log,
Qt::CTRL | Qt::SHIFT | Qt::Key_L,
qApp, SLOT(toggleLogDialog()));
addActionToQMenuAndActionHash(viewMenu, MenuOption::BandwidthDetails, 0,
dialogsManager.data(), SLOT(bandwidthDetails()));
addActionToQMenuAndActionHash(viewMenu, MenuOption::OctreeStats, 0,
dialogsManager.data(), SLOT(octreeStatsDetails()));
MenuWrapper* developerMenu = addMenu("Developer");
MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render");
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Atmosphere,
0, // QML Qt::SHIFT | Qt::Key_A,
true);
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::AmbientOcclusion);
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::DontFadeOnOctreeServerChanges);
MenuWrapper* ambientLightMenu = renderOptionsMenu->addMenu(MenuOption::RenderAmbientLight);
QActionGroup* ambientLightGroup = new QActionGroup(ambientLightMenu);
ambientLightGroup->setExclusive(true);
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLightGlobal, 0, true));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight0, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight1, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight2, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight3, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight4, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight5, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight6, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight7, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight8, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight9, 0, false));
MenuWrapper* shadowMenu = renderOptionsMenu->addMenu("Shadows");
QActionGroup* shadowGroup = new QActionGroup(shadowMenu);
shadowGroup->addAction(addCheckableActionToQMenuAndActionHash(shadowMenu, "None", 0, true));
shadowGroup->addAction(addCheckableActionToQMenuAndActionHash(shadowMenu, MenuOption::SimpleShadows, 0, false));
shadowGroup->addAction(addCheckableActionToQMenuAndActionHash(shadowMenu, MenuOption::CascadedShadows, 0, false));
{
MenuWrapper* framerateMenu = renderOptionsMenu->addMenu(MenuOption::RenderTargetFramerate);
QActionGroup* framerateGroup = new QActionGroup(framerateMenu);
framerateGroup->setExclusive(true);
framerateGroup->addAction(addCheckableActionToQMenuAndActionHash(framerateMenu, MenuOption::RenderTargetFramerateUnlimited, 0, true));
framerateGroup->addAction(addCheckableActionToQMenuAndActionHash(framerateMenu, MenuOption::RenderTargetFramerate60, 0, false));
framerateGroup->addAction(addCheckableActionToQMenuAndActionHash(framerateMenu, MenuOption::RenderTargetFramerate50, 0, false));
framerateGroup->addAction(addCheckableActionToQMenuAndActionHash(framerateMenu, MenuOption::RenderTargetFramerate40, 0, false));
framerateGroup->addAction(addCheckableActionToQMenuAndActionHash(framerateMenu, MenuOption::RenderTargetFramerate30, 0, false));
#if defined(Q_OS_MAC)
#else
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::RenderTargetFramerateVSyncOn, 0, true,
qApp, SLOT(setVSyncEnabled()));
#endif
}
MenuWrapper* resolutionMenu = renderOptionsMenu->addMenu(MenuOption::RenderResolution);
QActionGroup* resolutionGroup = new QActionGroup(resolutionMenu);
resolutionGroup->setExclusive(true);
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionOne, 0, true));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionTwoThird, 0, false));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionHalf, 0, false));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionThird, 0, false));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionQuarter, 0, false));
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Stars,
0, // QML Qt::Key_Asterisk,
true);
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::EnableGlowEffect, 0, true,
DependencyManager::get<GlowEffect>().data(), SLOT(toggleGlowEffect(bool)));
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Wireframe, Qt::ALT | Qt::Key_W, false);
addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::LodTools,
0, // QML Qt::SHIFT | Qt::Key_L,
dialogsManager.data(), SLOT(lodTools()));
MenuWrapper* avatarDebugMenu = developerMenu->addMenu("Avatar");
MenuWrapper* faceTrackingMenu = avatarDebugMenu->addMenu("Face Tracking");
{
QActionGroup* faceTrackerGroup = new QActionGroup(avatarDebugMenu);
bool defaultNoFaceTracking = true;
#ifdef HAVE_DDE
defaultNoFaceTracking = false;
#endif
QAction* noFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::NoFaceTracking,
0, defaultNoFaceTracking,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(noFaceTracker);
#ifdef HAVE_FACESHIFT
QAction* faceshiftFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::Faceshift,
0, false,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(faceshiftFaceTracker);
#endif
#ifdef HAVE_DDE
QAction* ddeFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseCamera,
0, true,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(ddeFaceTracker);
#endif
}
#ifdef HAVE_DDE
faceTrackingMenu->addSeparator();
QAction* binaryEyelidControl = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::BinaryEyelidControl, 0, true);
binaryEyelidControl->setVisible(true); // DDE face tracking is on by default
QAction* useAudioForMouth = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseAudioForMouth, 0, true);
useAudioForMouth->setVisible(true); // DDE face tracking is on by default
QAction* ddeFiltering = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::VelocityFilter, 0, true);
ddeFiltering->setVisible(true); // DDE face tracking is on by default
QAction* ddeCalibrate = addActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CalibrateCamera, 0,
DependencyManager::get<DdeFaceTracker>().data(), SLOT(calibrate()));
ddeCalibrate->setVisible(true); // DDE face tracking is on by default
#endif
#if defined(HAVE_FACESHIFT) || defined(HAVE_DDE)
faceTrackingMenu->addSeparator();
addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::MuteFaceTracking,
Qt::CTRL | Qt::SHIFT | Qt::Key_F, true, // DDE face tracking is on by default
qApp, SLOT(toggleFaceTrackerMute()));
#endif
auto avatarManager = DependencyManager::get<AvatarManager>();
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AvatarReceiveStats, 0, false,
avatarManager.data(), SLOT(setShouldShowReceiveStats(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderSkeletonCollisionShapes);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderHeadCollisionShapes);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderBoundingCollisionShapes);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderLookAtVectors, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderFocusIndicator, 0, false);
MenuWrapper* handOptionsMenu = developerMenu->addMenu("Hands");
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::AlignForearmsWithWrists, 0, false);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::AlternateIK, 0, false);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHands, 0, true);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHandTargets, 0, false);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::ShowIKConstraints, 0, false);
MenuWrapper* sixenseOptionsMenu = handOptionsMenu->addMenu("Sixense");
#ifdef __APPLE__
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu,
MenuOption::SixenseEnabled,
0, false,
&SixenseManager::getInstance(),
SLOT(toggleSixense(bool)));
#endif
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu,
MenuOption::FilterSixense,
0,
true,
&SixenseManager::getInstance(),
SLOT(setFilter(bool)));
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu,
MenuOption::LowVelocityFilter,
0,
true,
qApp,
SLOT(setLowVelocityFilter(bool)));
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu, MenuOption::SixenseMouseInput, 0, true);
addCheckableActionToQMenuAndActionHash(sixenseOptionsMenu, MenuOption::SixenseLasers, 0, false);
MenuWrapper* leapOptionsMenu = handOptionsMenu->addMenu("Leap Motion");
addCheckableActionToQMenuAndActionHash(leapOptionsMenu, MenuOption::LeapMotionOnHMD, 0, false);
#ifdef HAVE_RSSDK
MenuWrapper* realSenseOptionsMenu = handOptionsMenu->addMenu("RealSense");
addActionToQMenuAndActionHash(realSenseOptionsMenu, MenuOption::LoadRSSDKFile, 0,
RealSense::getInstance(), SLOT(loadRSSDKFile()));
#endif
MenuWrapper* networkMenu = developerMenu->addMenu("Network");
addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::DisableNackPackets, 0, false);
addCheckableActionToQMenuAndActionHash(networkMenu,
MenuOption::DisableActivityLogger,
0,
false,
&UserActivityLogger::getInstance(),
SLOT(disable(bool)));
addActionToQMenuAndActionHash(networkMenu, MenuOption::CachesSize, 0,
dialogsManager.data(), SLOT(cachesSizeDialog()));
addActionToQMenuAndActionHash(networkMenu, MenuOption::DiskCacheEditor, 0,
dialogsManager.data(), SLOT(toggleDiskCacheEditor()));
MenuWrapper* timingMenu = developerMenu->addMenu("Timing and Stats");
MenuWrapper* perfTimerMenu = timingMenu->addMenu("Performance Timer");
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::DisplayDebugTimingDetails, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::OnlyDisplayTopTen, 0, true);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandUpdateTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarSimulateTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandOtherAvatarTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandPaintGLTiming, 0, false);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::TestPing, 0, true);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::FrameTimer);
addActionToQMenuAndActionHash(timingMenu, MenuOption::RunTimingTests, 0, qApp, SLOT(runTests()));
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::PipelineWarnings);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings);
auto audioIO = DependencyManager::get<AudioClient>();
MenuWrapper* audioDebugMenu = developerMenu->addMenu("Audio");
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioNoiseReduction,
0,
true,
audioIO.data(),
SLOT(toggleAudioNoiseReduction()));
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoServerAudio, 0, false,
audioIO.data(), SLOT(toggleServerEcho()));
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoLocalAudio, 0, false,
audioIO.data(), SLOT(toggleLocalEcho()));
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::MuteAudio,
Qt::CTRL | Qt::Key_M,
false,
audioIO.data(),
SLOT(toggleMute()));
addActionToQMenuAndActionHash(audioDebugMenu,
MenuOption::MuteEnvironment,
0,
audioIO.data(),
SLOT(sendMuteEnvironmentPacket()));
auto scope = DependencyManager::get<AudioScope>();
MenuWrapper* audioScopeMenu = audioDebugMenu->addMenu("Audio Scope");
addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScope,
Qt::CTRL | Qt::Key_P, false,
scope.data(),
SLOT(toggle()));
addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopePause,
Qt::CTRL | Qt::SHIFT | Qt::Key_P ,
false,
scope.data(),
SLOT(togglePause()));
addDisabledActionAndSeparator(audioScopeMenu, "Display Frames");
{
QAction *fiveFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiveFrames,
0,
true,
scope.data(),
SLOT(selectAudioScopeFiveFrames()));
QAction *twentyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeTwentyFrames,
0,
false,
scope.data(),
SLOT(selectAudioScopeTwentyFrames()));
QAction *fiftyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiftyFrames,
0,
false,
scope.data(),
SLOT(selectAudioScopeFiftyFrames()));
QActionGroup* audioScopeFramesGroup = new QActionGroup(audioScopeMenu);
audioScopeFramesGroup->addAction(fiveFrames);
audioScopeFramesGroup->addAction(twentyFrames);
audioScopeFramesGroup->addAction(fiftyFrames);
}
auto statsRenderer = DependencyManager::get<AudioIOStatsRenderer>();
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioStats,
Qt::CTRL | Qt::SHIFT | Qt::Key_A,
false,
statsRenderer.data(),
SLOT(toggle()));
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioStatsShowInjectedStreams,
0,
false,
statsRenderer.data(),
SLOT(toggleShowInjectedStreams()));
MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics");
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned);
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowHulls);
MenuWrapper* helpMenu = addMenu("Help");
addActionToQMenuAndActionHash(helpMenu, MenuOption::EditEntitiesHelp, 0, qApp, SLOT(showEditEntitiesHelp()));
#ifndef Q_OS_MAC
QAction* aboutAction = helpMenu->addAction(MenuOption::AboutApp);
connect(aboutAction, SIGNAL(triggered()), qApp, SLOT(aboutApp()));
#endif
}
static unsigned8
read_byte(device *me,
hw_eeprom_device *eeprom,
unsigned_word address)
{
/* may need multiple iterations of this */
while (1) {
switch (eeprom->state) {
case read_reset:
return eeprom->memory[address];
case autoselect:
if ((address & 0xff) == 0x00)
return eeprom->manufacture_code;
else if ((address & 0xff) == 0x01)
return eeprom->device_code;
else
return 0; /* not certain about this */
case byte_programming:
if (device_event_queue_time(me) > eeprom->program_finish_time) {
finish_programming_byte(me, eeprom);
eeprom->state = read_reset;
continue;
}
else if (address == eeprom->byte_program_address) {
return toggle(eeprom, eeprom->memory[address]);
}
else {
/* trash that memory location */
invalid_read(me, eeprom->state, address, "not byte program address");
eeprom->memory[address] = (eeprom->memory[address]
& eeprom->byte_program_byte);
return toggle(eeprom, eeprom->memory[eeprom->byte_program_address]);
}
case chip_erase:
if (device_event_queue_time(me) > eeprom->program_finish_time) {
finish_erasing_chip(me, eeprom);
eeprom->state = read_reset;
continue;
}
else {
return toggle(eeprom, eeprom->memory[address]);
}
case sector_erase:
if (device_event_queue_time(me) > eeprom->program_finish_time) {
finish_erasing_sector(me, eeprom);
eeprom->state = read_reset;
continue;
}
else if (!eeprom->sectors[address / eeprom->sizeof_sector]) {
/* read to wrong sector */
invalid_read(me, eeprom->state, address, "sector not being erased");
return toggle(eeprom, eeprom->memory[address]) & ~0x8;
}
else if (device_event_queue_time(me) > eeprom->sector_start_time) {
return toggle(eeprom, eeprom->memory[address]) | 0x8;
}
else {
return toggle(eeprom, eeprom->memory[address]) & ~0x8;
}
case sector_erase_suspend:
if (!eeprom->sectors[address / eeprom->sizeof_sector]) {
return eeprom->memory[address];
}
else {
invalid_read(me, eeprom->state, address, "sector being erased");
return eeprom->memory[address];
}
default:
invalid_read(me, eeprom->state, address, "invalid state");
return eeprom->memory[address];
}
}
return 0;
}
Menu::Menu() {
auto dialogsManager = DependencyManager::get<DialogsManager>();
AccountManager& accountManager = AccountManager::getInstance();
// File/Application menu ----------------------------------
MenuWrapper* fileMenu = addMenu("File");
// File > Login menu items
{
addActionToQMenuAndActionHash(fileMenu, MenuOption::Login);
// connect to the appropriate signal of the AccountManager so that we can change the Login/Logout menu item
connect(&accountManager, &AccountManager::profileChanged,
dialogsManager.data(), &DialogsManager::toggleLoginDialog);
connect(&accountManager, &AccountManager::logoutComplete,
dialogsManager.data(), &DialogsManager::toggleLoginDialog);
}
// File > Update -- FIXME: needs implementation
auto updateAction = addActionToQMenuAndActionHash(fileMenu, "Update");
updateAction->setDisabled(true);
// File > Help
addActionToQMenuAndActionHash(fileMenu, MenuOption::Help, 0, qApp, SLOT(showHelp()));
// File > Crash Reporter...-- FIXME: needs implementation
auto crashReporterAction = addActionToQMenuAndActionHash(fileMenu, "Crash Reporter...");
crashReporterAction->setDisabled(true);
// File > About
addActionToQMenuAndActionHash(fileMenu, MenuOption::AboutApp, 0, qApp, SLOT(aboutApp()), QAction::AboutRole);
// File > Quit
addActionToQMenuAndActionHash(fileMenu, MenuOption::Quit, Qt::CTRL | Qt::Key_Q, qApp, SLOT(quit()), QAction::QuitRole);
// Edit menu ----------------------------------
MenuWrapper* editMenu = addMenu("Edit");
// Edit > Undo
QUndoStack* undoStack = qApp->getUndoStack();
QAction* undoAction = undoStack->createUndoAction(editMenu);
undoAction->setShortcut(Qt::CTRL | Qt::Key_Z);
addActionToQMenuAndActionHash(editMenu, undoAction);
// Edit > Redo
QAction* redoAction = undoStack->createRedoAction(editMenu);
redoAction->setShortcut(Qt::CTRL | Qt::SHIFT | Qt::Key_Z);
addActionToQMenuAndActionHash(editMenu, redoAction);
// Edit > Running Sccripts
addActionToQMenuAndActionHash(editMenu, MenuOption::RunningScripts, Qt::CTRL | Qt::Key_J,
qApp, SLOT(toggleRunningScriptsWidget()));
// Edit > Open and Run Script from File... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::LoadScript, Qt::CTRL | Qt::Key_O,
qApp, SLOT(loadDialog()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Open and Run Script from Url... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::LoadScriptURL,
Qt::CTRL | Qt::SHIFT | Qt::Key_O, qApp, SLOT(loadScriptURLDialog()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
auto scriptEngines = DependencyManager::get<ScriptEngines>();
// Edit > Stop All Scripts... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::StopAllScripts, 0,
scriptEngines.data(), SLOT(stopAllScripts()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Reload All Scripts... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::ReloadAllScripts, Qt::CTRL | Qt::Key_R,
scriptEngines.data(), SLOT(reloadAllScripts()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Scripts Editor... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::ScriptEditor, Qt::ALT | Qt::Key_S,
dialogsManager.data(), SLOT(showScriptEditor()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Console... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::Console, Qt::CTRL | Qt::ALT | Qt::Key_J,
DependencyManager::get<StandAloneJSConsole>().data(),
SLOT(toggleConsole()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Reload All Content [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Edit > Package Model... [advanced]
addActionToQMenuAndActionHash(editMenu, MenuOption::PackageModel, 0,
qApp, SLOT(packageModel()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Audio menu ----------------------------------
MenuWrapper* audioMenu = addMenu("Audio");
auto audioIO = DependencyManager::get<AudioClient>();
// Audio > Mute
addCheckableActionToQMenuAndActionHash(audioMenu, MenuOption::MuteAudio, Qt::CTRL | Qt::Key_M, false,
audioIO.data(), SLOT(toggleMute()));
// Audio > Level Meter [advanced] -- FIXME: needs implementation
auto levelMeterAction = addCheckableActionToQMenuAndActionHash(audioMenu, "Level Meter", 0, false, NULL, NULL, UNSPECIFIED_POSITION, "Advanced");
levelMeterAction->setDisabled(true);
// Avatar menu ----------------------------------
MenuWrapper* avatarMenu = addMenu("Avatar");
auto avatarManager = DependencyManager::get<AvatarManager>();
QObject* avatar = avatarManager->getMyAvatar();
// Avatar > Attachments...
addActionToQMenuAndActionHash(avatarMenu, MenuOption::Attachments, 0,
dialogsManager.data(), SLOT(editAttachments()));
// Avatar > Size
MenuWrapper* avatarSizeMenu = avatarMenu->addMenu("Size");
// Avatar > Size > Increase
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::IncreaseAvatarSize,
0, // QML Qt::Key_Plus,
avatar, SLOT(increaseSize()));
// Avatar > Size > Decrease
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::DecreaseAvatarSize,
0, // QML Qt::Key_Minus,
avatar, SLOT(decreaseSize()));
// Avatar > Size > Reset
addActionToQMenuAndActionHash(avatarSizeMenu,
MenuOption::ResetAvatarSize,
0, // QML Qt::Key_Equal,
avatar, SLOT(resetSize()));
// Avatar > Reset Sensors
addActionToQMenuAndActionHash(avatarMenu,
MenuOption::ResetSensors,
0, // QML Qt::Key_Apostrophe,
qApp, SLOT(resetSensors()));
// Display menu ----------------------------------
// FIXME - this is not yet matching Alan's spec because it doesn't have
// menus for "2D"/"3D" - we need to add support for detecting the appropriate
// default 3D display mode
addMenu(DisplayPlugin::MENU_PATH());
MenuWrapper* displayModeMenu = addMenu(MenuOption::OutputMenu);
QActionGroup* displayModeGroup = new QActionGroup(displayModeMenu);
displayModeGroup->setExclusive(true);
// View menu ----------------------------------
MenuWrapper* viewMenu = addMenu("View");
QActionGroup* cameraModeGroup = new QActionGroup(viewMenu);
// View > [camera group]
cameraModeGroup->setExclusive(true);
// View > First Person
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::FirstPerson, 0, // QML Qt:: Key_P
false, qApp, SLOT(cameraMenuChanged())));
// View > Third Person
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::ThirdPerson, 0,
true, qApp, SLOT(cameraMenuChanged())));
// View > Mirror
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::FullscreenMirror, 0, // QML Qt::Key_H,
false, qApp, SLOT(cameraMenuChanged())));
// View > Independent [advanced]
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::IndependentMode, 0,
false, qApp, SLOT(cameraMenuChanged()),
UNSPECIFIED_POSITION, "Advanced"));
// View > Entity Camera [advanced]
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(viewMenu,
MenuOption::CameraEntityMode, 0,
false, qApp, SLOT(cameraMenuChanged()),
UNSPECIFIED_POSITION, "Advanced"));
viewMenu->addSeparator();
// View > Mini Mirror
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::MiniMirror, 0, false);
// Navigate menu ----------------------------------
MenuWrapper* navigateMenu = addMenu("Navigate");
// Navigate > Home -- FIXME: needs implementation
auto homeAction = addActionToQMenuAndActionHash(navigateMenu, "Home");
homeAction->setDisabled(true);
addActionToQMenuAndActionHash(navigateMenu, MenuOption::AddressBar, Qt::CTRL | Qt::Key_L,
dialogsManager.data(), SLOT(toggleAddressBar()));
// Navigate > Directory -- FIXME: needs implementation
addActionToQMenuAndActionHash(navigateMenu, "Directory");
// Navigate > Bookmark related menus -- Note: the Bookmark class adds its own submenus here.
qApp->getBookmarks()->setupMenus(this, navigateMenu);
// Navigate > Copy Address [advanced]
auto addressManager = DependencyManager::get<AddressManager>();
addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyAddress, 0,
addressManager.data(), SLOT(copyAddress()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Navigate > Copy Path [advanced]
addActionToQMenuAndActionHash(navigateMenu, MenuOption::CopyPath, 0,
addressManager.data(), SLOT(copyPath()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
// Settings menu ----------------------------------
MenuWrapper* settingsMenu = addMenu("Settings");
// Settings > Advance Menus
addCheckableActionToQMenuAndActionHash(settingsMenu, "Advanced Menus", 0, false, this, SLOT(toggleAdvancedMenus()));
// Settings > Developer Menus
addCheckableActionToQMenuAndActionHash(settingsMenu, "Developer Menus", 0, false, this, SLOT(toggleDeveloperMenus()));
// Settings > General...
addActionToQMenuAndActionHash(settingsMenu, MenuOption::Preferences, Qt::CTRL | Qt::Key_Comma,
dialogsManager.data(), SLOT(editPreferences()), QAction::PreferencesRole);
// Settings > Avatar...-- FIXME: needs implementation
auto avatarAction = addActionToQMenuAndActionHash(settingsMenu, "Avatar...");
avatarAction->setDisabled(true);
// Settings > Audio...-- FIXME: needs implementation
auto audioAction = addActionToQMenuAndActionHash(settingsMenu, "Audio...");
audioAction->setDisabled(true);
// Settings > LOD...-- FIXME: needs implementation
auto lodAction = addActionToQMenuAndActionHash(settingsMenu, "LOD...");
lodAction->setDisabled(true);
// Settings > Control with Speech [advanced]
#if defined(Q_OS_MAC) || defined(Q_OS_WIN)
auto speechRecognizer = DependencyManager::get<SpeechRecognizer>();
QAction* speechRecognizerAction = addCheckableActionToQMenuAndActionHash(settingsMenu, MenuOption::ControlWithSpeech,
Qt::CTRL | Qt::SHIFT | Qt::Key_C,
speechRecognizer->getEnabled(),
speechRecognizer.data(),
SLOT(setEnabled(bool)),
UNSPECIFIED_POSITION, "Advanced");
connect(speechRecognizer.data(), SIGNAL(enabledUpdated(bool)), speechRecognizerAction, SLOT(setChecked(bool)));
#endif
// Settings > Input Devices
MenuWrapper* inputModeMenu = addMenu(MenuOption::InputMenu, "Advanced");
QActionGroup* inputModeGroup = new QActionGroup(inputModeMenu);
inputModeGroup->setExclusive(false);
// Developer menu ----------------------------------
MenuWrapper* developerMenu = addMenu("Developer", "Developer");
// Developer > Render >>>
MenuWrapper* renderOptionsMenu = developerMenu->addMenu("Render");
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Atmosphere, 0, true);
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::DebugAmbientOcclusion);
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Antialiasing);
// Developer > Render > Ambient Light
MenuWrapper* ambientLightMenu = renderOptionsMenu->addMenu(MenuOption::RenderAmbientLight);
QActionGroup* ambientLightGroup = new QActionGroup(ambientLightMenu);
ambientLightGroup->setExclusive(true);
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLightGlobal, 0, true));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight0, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight1, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight2, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight3, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight4, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight5, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight6, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight7, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight8, 0, false));
ambientLightGroup->addAction(addCheckableActionToQMenuAndActionHash(ambientLightMenu, MenuOption::RenderAmbientLight9, 0, false));
// Developer > Render > Throttle FPS If Not Focus
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::ThrottleFPSIfNotFocus, 0, true);
// Developer > Render > Resolution
MenuWrapper* resolutionMenu = renderOptionsMenu->addMenu(MenuOption::RenderResolution);
QActionGroup* resolutionGroup = new QActionGroup(resolutionMenu);
resolutionGroup->setExclusive(true);
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionOne, 0, true));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionTwoThird, 0, false));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionHalf, 0, false));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionThird, 0, false));
resolutionGroup->addAction(addCheckableActionToQMenuAndActionHash(resolutionMenu, MenuOption::RenderResolutionQuarter, 0, false));
// Developer > Render > Stars
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Stars,
0, // QML Qt::Key_Asterisk,
true);
// Developer > Render > LOD Tools
addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::LodTools,
0, // QML Qt::SHIFT | Qt::Key_L,
dialogsManager.data(), SLOT(lodTools()));
// Developer > Assets >>>
MenuWrapper* assetDeveloperMenu = developerMenu->addMenu("Assets");
auto& assetDialogFactory = AssetUploadDialogFactory::getInstance();
assetDialogFactory.setDialogParent(this);
QAction* assetUpload = addActionToQMenuAndActionHash(assetDeveloperMenu,
MenuOption::UploadAsset,
0,
&assetDialogFactory,
SLOT(showDialog()));
// disable the asset upload action by default - it gets enabled only if asset server becomes present
assetUpload->setEnabled(false);
auto& atpMigrator = ATPAssetMigrator::getInstance();
atpMigrator.setDialogParent(this);
addActionToQMenuAndActionHash(assetDeveloperMenu, MenuOption::AssetMigration,
0, &atpMigrator,
SLOT(loadEntityServerFile()));
// Developer > Avatar >>>
MenuWrapper* avatarDebugMenu = developerMenu->addMenu("Avatar");
// Developer > Avatar > Face Tracking
MenuWrapper* faceTrackingMenu = avatarDebugMenu->addMenu("Face Tracking");
{
QActionGroup* faceTrackerGroup = new QActionGroup(avatarDebugMenu);
bool defaultNoFaceTracking = true;
#ifdef HAVE_DDE
defaultNoFaceTracking = false;
#endif
QAction* noFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::NoFaceTracking,
0, defaultNoFaceTracking,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(noFaceTracker);
#ifdef HAVE_FACESHIFT
QAction* faceshiftFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::Faceshift,
0, false,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(faceshiftFaceTracker);
#endif
#ifdef HAVE_DDE
QAction* ddeFaceTracker = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseCamera,
0, true,
qApp, SLOT(setActiveFaceTracker()));
faceTrackerGroup->addAction(ddeFaceTracker);
#endif
}
#ifdef HAVE_DDE
faceTrackingMenu->addSeparator();
QAction* binaryEyelidControl = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::BinaryEyelidControl, 0, true);
binaryEyelidControl->setVisible(true); // DDE face tracking is on by default
QAction* coupleEyelids = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CoupleEyelids, 0, true);
coupleEyelids->setVisible(true); // DDE face tracking is on by default
QAction* useAudioForMouth = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::UseAudioForMouth, 0, true);
useAudioForMouth->setVisible(true); // DDE face tracking is on by default
QAction* ddeFiltering = addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::VelocityFilter, 0, true);
ddeFiltering->setVisible(true); // DDE face tracking is on by default
QAction* ddeCalibrate = addActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::CalibrateCamera, 0,
DependencyManager::get<DdeFaceTracker>().data(), SLOT(calibrate()));
ddeCalibrate->setVisible(true); // DDE face tracking is on by default
#endif
#if defined(HAVE_FACESHIFT) || defined(HAVE_DDE)
faceTrackingMenu->addSeparator();
addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::MuteFaceTracking,
Qt::CTRL | Qt::SHIFT | Qt::Key_F, true); // DDE face tracking is on by default
addCheckableActionToQMenuAndActionHash(faceTrackingMenu, MenuOption::AutoMuteAudio, 0, false);
#endif
#ifdef HAVE_IVIEWHMD
// Developer > Avatar > Eye Tracking
MenuWrapper* eyeTrackingMenu = avatarDebugMenu->addMenu("Eye Tracking");
addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SMIEyeTracking, 0, false,
qApp, SLOT(setActiveEyeTracker()));
{
MenuWrapper* calibrateEyeTrackingMenu = eyeTrackingMenu->addMenu("Calibrate");
addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::OnePointCalibration, 0,
qApp, SLOT(calibrateEyeTracker1Point()));
addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::ThreePointCalibration, 0,
qApp, SLOT(calibrateEyeTracker3Points()));
addActionToQMenuAndActionHash(calibrateEyeTrackingMenu, MenuOption::FivePointCalibration, 0,
qApp, SLOT(calibrateEyeTracker5Points()));
}
addCheckableActionToQMenuAndActionHash(eyeTrackingMenu, MenuOption::SimulateEyeTracking, 0, false,
qApp, SLOT(setActiveEyeTracker()));
#endif
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AvatarReceiveStats, 0, false,
avatarManager.data(), SLOT(setShouldShowReceiveStats(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderBoundingCollisionShapes);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderLookAtVectors, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderLookAtTargets, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderFocusIndicator, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowWhosLookingAtMe, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::FixGaze, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawDefaultPose, 0, false,
avatar, SLOT(setEnableDebugDrawDefaultPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawAnimPose, 0, false,
avatar, SLOT(setEnableDebugDrawAnimPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawPosition, 0, false,
avatar, SLOT(setEnableDebugDrawPosition(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::MeshVisible, 0, true,
avatar, SLOT(setEnableMeshVisible(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::DisableEyelidAdjustment, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::TurnWithHead, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ComfortMode, 0, true);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::KeyboardMotorControl,
Qt::CTRL | Qt::SHIFT | Qt::Key_K, true, avatar, SLOT(updateMotionBehaviorFromMenu()),
UNSPECIFIED_POSITION, "Developer");
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ScriptedMotorControl, 0, true,
avatar, SLOT(updateMotionBehaviorFromMenu()),
UNSPECIFIED_POSITION, "Developer");
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableCharacterController, 0, true,
avatar, SLOT(updateMotionBehaviorFromMenu()),
UNSPECIFIED_POSITION, "Developer");
// Developer > Hands >>>
MenuWrapper* handOptionsMenu = developerMenu->addMenu("Hands");
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHandTargets, 0, false);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::LowVelocityFilter, 0, true,
qApp, SLOT(setLowVelocityFilter(bool)));
MenuWrapper* leapOptionsMenu = handOptionsMenu->addMenu("Leap Motion");
addCheckableActionToQMenuAndActionHash(leapOptionsMenu, MenuOption::LeapMotionOnHMD, 0, false);
// Developer > Network >>>
MenuWrapper* networkMenu = developerMenu->addMenu("Network");
addActionToQMenuAndActionHash(networkMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches()));
addCheckableActionToQMenuAndActionHash(networkMenu, MenuOption::DisableNackPackets, 0, false,
qApp->getEntityEditPacketSender(),
SLOT(toggleNackPackets()));
addCheckableActionToQMenuAndActionHash(networkMenu,
MenuOption::DisableActivityLogger,
0,
false,
&UserActivityLogger::getInstance(),
SLOT(disable(bool)));
addActionToQMenuAndActionHash(networkMenu, MenuOption::CachesSize, 0,
dialogsManager.data(), SLOT(cachesSizeDialog()));
addActionToQMenuAndActionHash(networkMenu, MenuOption::DiskCacheEditor, 0,
dialogsManager.data(), SLOT(toggleDiskCacheEditor()));
addActionToQMenuAndActionHash(networkMenu, MenuOption::ShowDSConnectTable, 0,
dialogsManager.data(), SLOT(showDomainConnectionDialog()));
// Developer > Timing and Stats >>>
MenuWrapper* timingMenu = developerMenu->addMenu("Timing and Stats");
MenuWrapper* perfTimerMenu = timingMenu->addMenu("Performance Timer");
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::DisplayDebugTimingDetails, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::OnlyDisplayTopTen, 0, true);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandUpdateTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandMyAvatarSimulateTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandOtherAvatarTiming, 0, false);
addCheckableActionToQMenuAndActionHash(perfTimerMenu, MenuOption::ExpandPaintGLTiming, 0, false);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::FrameTimer);
addActionToQMenuAndActionHash(timingMenu, MenuOption::RunTimingTests, 0, qApp, SLOT(runTests()));
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::PipelineWarnings);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::LogExtraTimings);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::ShowRealtimeEntityStats);
// Developer > Audio >>>
MenuWrapper* audioDebugMenu = developerMenu->addMenu("Audio");
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioNoiseReduction, 0, true,
audioIO.data(), SLOT(toggleAudioNoiseReduction()));
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoServerAudio, 0, false,
audioIO.data(), SLOT(toggleServerEcho()));
addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoLocalAudio, 0, false,
audioIO.data(), SLOT(toggleLocalEcho()));
addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::MuteEnvironment, 0,
audioIO.data(), SLOT(sendMuteEnvironmentPacket()));
auto scope = DependencyManager::get<AudioScope>();
MenuWrapper* audioScopeMenu = audioDebugMenu->addMenu("Audio Scope");
addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScope, Qt::CTRL | Qt::Key_P, false,
scope.data(), SLOT(toggle()));
addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopePause, Qt::CTRL | Qt::SHIFT | Qt::Key_P, false,
scope.data(), SLOT(togglePause()));
addDisabledActionAndSeparator(audioScopeMenu, "Display Frames");
{
QAction* fiveFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiveFrames,
0, true, scope.data(), SLOT(selectAudioScopeFiveFrames()));
QAction* twentyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeTwentyFrames,
0, false, scope.data(), SLOT(selectAudioScopeTwentyFrames()));
QAction* fiftyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiftyFrames,
0, false, scope.data(), SLOT(selectAudioScopeFiftyFrames()));
QActionGroup* audioScopeFramesGroup = new QActionGroup(audioScopeMenu);
audioScopeFramesGroup->addAction(fiveFrames);
audioScopeFramesGroup->addAction(twentyFrames);
audioScopeFramesGroup->addAction(fiftyFrames);
}
// Developer > Physics >>>
MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics");
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned);
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowHulls);
// Developer > Display Crash Options
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::DisplayCrashOptions, 0, true);
// Developer > Crash Application
addActionToQMenuAndActionHash(developerMenu, MenuOption::CrashInterface, 0, qApp, SLOT(crashApplication()));
// Developer > Log...
addActionToQMenuAndActionHash(developerMenu, MenuOption::Log, Qt::CTRL | Qt::SHIFT | Qt::Key_L,
qApp, SLOT(toggleLogDialog()));
// Developer > Stats
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::Stats);
// Developer > Audio Stats...
addActionToQMenuAndActionHash(developerMenu, MenuOption::AudioNetworkStats, 0,
dialogsManager.data(), SLOT(audioStatsDetails()));
// Developer > Bandwidth Stats...
addActionToQMenuAndActionHash(developerMenu, MenuOption::BandwidthDetails, 0,
dialogsManager.data(), SLOT(bandwidthDetails()));
// Developer > Entity Stats...
addActionToQMenuAndActionHash(developerMenu, MenuOption::OctreeStats, 0,
dialogsManager.data(), SLOT(octreeStatsDetails()));
// Developer > World Axes
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::WorldAxes);
#if 0 /// -------------- REMOVED FOR NOW --------------
addDisabledActionAndSeparator(navigateMenu, "History");
QAction* backAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Back, 0, addressManager.data(), SLOT(goBack()));
QAction* forwardAction = addActionToQMenuAndActionHash(navigateMenu, MenuOption::Forward, 0, addressManager.data(), SLOT(goForward()));
// connect to the AddressManager signal to enable and disable the back and forward menu items
connect(addressManager.data(), &AddressManager::goBackPossible, backAction, &QAction::setEnabled);
connect(addressManager.data(), &AddressManager::goForwardPossible, forwardAction, &QAction::setEnabled);
// set the two actions to start disabled since the stacks are clear on startup
backAction->setDisabled(true);
forwardAction->setDisabled(true);
MenuWrapper* toolsMenu = addMenu("Tools");
addActionToQMenuAndActionHash(toolsMenu,
MenuOption::ToolWindow,
Qt::CTRL | Qt::ALT | Qt::Key_T,
dialogsManager.data(),
SLOT(toggleToolWindow()),
QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::NamesAboveHeads, 0, true,
NULL, NULL, UNSPECIFIED_POSITION, "Advanced");
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::CenterPlayerInView,
0, false, qApp, SLOT(rotationModeChanged()),
UNSPECIFIED_POSITION, "Advanced");
#endif
}
void UDoor::open()
{
if (!is_open())
toggle();
}
void OptionsWindow::clicked( int mouseX, int mouseY, uint8_t mouseState )
{
// check for quit and the other options
if( !isMouseOnFrame( mouseX, mouseY ) )
{
return;
}
int selectedEntry = -1;
if ( mouseX < posX + 64 || mouseX > posX + frameWidth - 64 || posY + frameHeight - 64 < mouseY) {
selectedEntry = -1;
} else {
selectedEntry = (posY + frameHeight - 64 - mouseY) / static_cast<int>(font->getHeight()*1.5);
if ( (posY + frameHeight - 64 - mouseY) % static_cast<int>(font->getHeight()*1.5) > static_cast<int>(font->getHeight()) ) {
selectedEntry = -1;
}
}
if( selectedEntry == 0 )
{
setQuitGame();
}
else if( selectedEntry == 1 && utils::file_exists( "savegame.lua" ) == true )
{
// Load Game
// clear current game data
Globals::getCurrentZone()->purgeInteractionList();
Globals::getCurrentZone()->purgeInteractionRegionList();
questWindow->removeAllQuests();
for ( std::map< std::string, CZone* >::iterator it = Globals::allZones.begin(); it != Globals::allZones.end(); ++it ) {
delete it->second;
it->second = NULL;
}
Globals::allZones.clear();
Globals::getPlayer()->clearInventory();
// clear shop data
shopWindow = std::auto_ptr<Shop>( new Shop( Globals::getPlayer(), NULL ) );
// clear spellbook
spellbook->clear();
// clear action bar
actionBar->clear();
// clear cooldowns
Globals::getPlayer()->clearCooldownSpells();
// clear buffs
Globals::getPlayer()->clearActiveSpells();
// reenter map
// 1. Load all zones
// TODO: Load all zones
// 2. Restore lua variables
LuaFunctions::executeLuaScript( "loadGame( 'savegame' )" );
//CZone *newZone = Globals::allZones["data/zone1"];
//newZone->LoadZone("data/zone1");
LuaFunctions::executeLuaFile( "data/quests_wood.lua" );
DawnInterface::clearLogWindow();
}
else if( selectedEntry == 2 )
{
if( Globals::isSavingAllowed() )
{
// save Game
LuaFunctions::executeLuaScript( "saveGame( 'savegame' )" );
GLfloat yellow[] = { 1.0f, 1.0f, 0.0f };
DawnInterface::addTextToLogWindow( yellow, "Game saved.");
}
}
else if( selectedEntry == 3 )
{
toggle(); // close the window
}
else if( selectedEntry == 4 )
{
GLfloat yellow[] = { 1.0f, 1.0f, 0.0f };
if( Globals::isPaused() )
{
Globals::setPaused( false );
DawnInterface::addTextToLogWindow( yellow, "Game unpaused." );
}
else
{
Globals::setPaused( true );
DawnInterface::addTextToLogWindow( yellow, "Game paused." );
}
}
}
int main(int argc, char *argv[])
{
int mode = SDL_HWSURFACE | SDL_HWACCEL |
SDL_DOUBLEBUF | SDL_OPENGL;
if (argc >= 2 && (! strcmp(argv[1], "-h") ||
! strcmp(argv[1], "--help"))) {
printf("Uso: %s [-fs] resolucao-x resolucao-y\n\n"
"Exemplo: ./walker 1024 768\n\n"
"Para mais informacoes, leia o README.\n",
argv[0]);
exit(0);
}
int shift = 1;
if (argc >= 2 && ! strcmp(argv[1], "-fs")) {
mode |= SDL_FULLSCREEN;
res_x = 1360;
res_y = 768;
shift++;
}
if (argc >= 3) {
res_x = atoi(argv[shift]);
res_y = atoi(argv[shift+1]);
}
init_event_keys();
glutInit(&argc, argv);
initsdl(mode);
initgl();
carregar_texturas();
SDL_Event ev;
while (1)
if (! SDL_PollEvent(&ev)
|| ev.type == SDL_MOUSEMOTION)
break;
else
event_handler(ev);
uint64_t old_time, new_time;
uint64_t old_border, new_border;
old_time = time_get();
old_border = time_in_secs(old_time);
float dt = 0;
int count = 0;
while (1) {
while (SDL_PollEvent(&ev))
event_handler(ev);
new_time = time_get();
new_border = time_in_secs(new_time);
dt = time_diff(new_time, old_time);
if (new_border > old_border) {
update_fps_str(count);
old_border = new_border;
count = 0;
}
old_time = new_time;
count++;
update_status_str();
toggle();
model(dt);
physics(dt);
update_map_pos();
draw();
}
}
void ofxSimpleGuiButton::keyPressed( int key ) {
if(key==keyboardShortcut) toggle();
}
int main(void) {
//init USART serial connection
initUSART();
printString("USART Initialized!\r\n");
//blink LED
DDRB |= (1 << PB2);
toggle('B', 2);
_delay_ms(200);
toggle('B', 2);
_delay_ms(200);
toggle('B', 2);
_delay_ms(200);
toggle('B', 2);
_delay_ms(200);
uint8_t i;
uint32_t sum;
//init ADC
initADC();
uint16_t adcValue;
//moving average variables
uint8_t joystickValues = 10;
uint8_t slidepotValues = 20;
uint16_t verticalValue [joystickValues];
uint16_t horizontalValue [joystickValues];
uint16_t topSliderValue [slidepotValues];
uint16_t bottomSliderValue [slidepotValues];
uint16_t avgValue;
char valueString[15];
//init moving average values
for(i=0;i<joystickValues;i++){
verticalValue[i] = 511;
horizontalValue[i] = 511;
}
//init moving average values
for(i=0;i<slidepotValues;i++){
topSliderValue[i] = 0;
bottomSliderValue[i] = 0;
}
while(1) {
// ********** Read Vertical Joystick **********
adcValue = readADC(0);
// store new value, dump oldest
for(i=joystickValues-1;i>0;i--){
verticalValue[i] = verticalValue[i-1];
}
verticalValue[0] = adcValue;
//get average of all saved values
sum = 0;
for(i=0;i<joystickValues;i++){
sum = sum + verticalValue[i];
}
avgValue = sum/joystickValues;
//convert int to string
sprintf(valueString, "%d", avgValue);
//print value over USART
printString("V: ");
printString(valueString);
// ********** Read Horizontal Joystick **********
adcValue = readADC(1);
// store new value, dump oldest
for(i=joystickValues-1;i>0;i--){
horizontalValue[i] = horizontalValue[i-1];
}
horizontalValue[0] = adcValue;
//get average of all saved values
sum = 0;
for(i=0;i<joystickValues;i++){
sum = sum + horizontalValue[i];
}
avgValue = sum/joystickValues;
//convert int to string
sprintf(valueString, "%d", avgValue);
//print value over USART
printString(" H: ");
printString(valueString);
// ********** Read Top Slider **********
adcValue = readADC(2);
// store new value, dump oldest
for(i=slidepotValues-1;i>0;i--){
topSliderValue[i] = topSliderValue[i-1];
}
topSliderValue[0] = adcValue;
//get average of all saved values
sum = 0;
for(i=0;i<slidepotValues;i++){
sum = sum + topSliderValue[i];
}
avgValue = sum/slidepotValues;
//convert int to string
sprintf(valueString, "%d", avgValue);
//print value over USART
printString(" Top: ");
printString(valueString);
// ********** Read Bottom Slider **********
adcValue = readADC(3);
// store new value, dump oldest
for(i=slidepotValues-1;i>0;i--){
bottomSliderValue[i] = bottomSliderValue[i-1];
}
bottomSliderValue[0] = adcValue;
//get average of all saved values
sum = 0;
for(i=0;i<slidepotValues;i++){
sum = sum + bottomSliderValue[i];
}
avgValue = sum/slidepotValues;
//convert int to string
sprintf(valueString, "%d", avgValue);
//print value over USART
printString(" Bot: ");
printString(valueString);
//print return carriage
printString("\r\n");
}
return(0);
}
void NetworkAnalyzerPanel::closeEvent(QCloseEvent *event)
{
Q_UNUSED(event);
toggle(false);
}
bool dumb_output_handle_setting(const char *setting, bool show_cursor,
bool startup)
{
char *p;
int i;
if (!strncmp(setting, "pb", 2)) {
toggle(&show_pictures, setting[2]);
printf("Picture outlines display %s\n", show_pictures ? "ON" : "OFF");
if (startup)
return TRUE;
for (i = 0; i < screen_cells; i++)
screen_changes[i] = (cell_style(screen_data[i]) == PICTURE_STYLE);
dumb_show_screen(show_cursor);
} else if (!strncmp(setting, "vb", 2)) {
toggle(&visual_bell, setting[2]);
printf("Visual bell %s\n", visual_bell ? "ON" : "OFF");
os_beep(1); os_beep(2);
} else if (!strncmp(setting, "ln", 2)) {
toggle(&show_line_numbers, setting[2]);
printf("Line numbering %s\n", show_line_numbers ? "ON" : "OFF");
} else if (!strncmp(setting, "lt", 2)) {
toggle(&show_line_types, setting[2]);
printf("Line-type display %s\n", show_line_types ? "ON" : "OFF");
} else if (*setting == 'c') {
switch (setting[1]) {
case 'm': compression_mode = COMPRESSION_MAX; break;
case 's': compression_mode = COMPRESSION_SPANS; break;
case 'n': compression_mode = COMPRESSION_NONE; break;
case 'h': hide_lines = atoi(&setting[2]); break;
default: return FALSE;
}
printf("Compression mode %s, hiding top %d lines\n",
compression_names[compression_mode], hide_lines);
} else if (*setting == 'r') {
switch (setting[1]) {
case 'n': rv_mode = RV_NONE; break;
case 'o': rv_mode = RV_DOUBLESTRIKE; break;
case 'u': rv_mode = RV_UNDERLINE; break;
case 'c': rv_mode = RV_CAPS; break;
case 'b': rv_blank_char = setting[2] ? setting[2] : ' '; break;
default: return FALSE;
}
printf("Reverse-video mode %s, blanks reverse to '%c': ",
rv_names[rv_mode], rv_blank_char);
for (p = "sample reverse text"; *p; p++)
show_cell(make_cell(REVERSE_STYLE, *p));
putchar('\n');
for (i = 0; i < screen_cells; i++)
screen_changes[i] = (cell_style(screen_data[i]) == REVERSE_STYLE);
dumb_show_screen(show_cursor);
} else if (!strcmp(setting, "set")) {
printf("Compression Mode %s, hiding top %d lines\n",
compression_names[compression_mode], hide_lines);
printf("Picture Boxes display %s\n", show_pictures ? "ON" : "OFF");
printf("Visual Bell %s\n", visual_bell ? "ON" : "OFF");
os_beep(1); os_beep(2);
printf("Line Numbering %s\n", show_line_numbers ? "ON" : "OFF");
printf("Line-Type display %s\n", show_line_types ? "ON" : "OFF");
printf("Reverse-Video mode %s, Blanks reverse to '%c': ",
rv_names[rv_mode], rv_blank_char);
for (p = "sample reverse text"; *p; p++)
show_cell(make_cell(REVERSE_STYLE, *p));
putchar('\n');
} else
return FALSE;
return TRUE;
}
void TransferServerConnection::onReceive(const Archive::ByteStream & message)
{
Archive::ReadIterator ri = message.begin();
const GameNetworkMessage msg(ri);
ri = message.begin();
if(msg.isType("UploadCharacterMessage"))
{
const UploadCharacterMessage ucm(ri);
CentralServer::getInstance().sendToGameServer(ucm.getFromGameServerId(), ucm, true);
LOG("TransferServerConnection", ("Received character data for SUID %lu for character object %s on game server %d", ucm.getStationId(), ucm.getFromCharacterId().getValueString().c_str(), ucm.getFromGameServerId()));
}
else if(msg.isType("CharacterTransferStatusMessage"))
{
const CharacterTransferStatusMessage ctsm(ri);
CentralServer::getInstance().sendToGameServer(ctsm.getGameServerId(), ctsm, true);
}
else if(msg.isType("TransferRequestCharacterList"))
{
// simply forward the request to any available login server
const GenericValueTypeMessage<TransferCharacterData> request(ri);
IGNORE_RETURN(CentralServer::getInstance().sendToArbitraryLoginServer(request));
}
else if(msg.isType("TransferRequestMoveValidation"))
{
const TransferRequestMoveValidation request(ri);
IGNORE_RETURN(CentralServer::getInstance().sendToArbitraryLoginServer(request));
LOG("CustomerService", ("CharacterTransfer: Received TransferRequestMoveValidation : %s on %s to %s on %s. Forwarding request to LoginServer.", request.getSourceCharacter().c_str(), request.getSourceGalaxy().c_str(), request.getDestinationCharacter().c_str(), request.getDestinationGalaxy().c_str()));
}
else if(msg.isType("TransferRequestKickConnectedClients"))
{
GenericValueTypeMessage<std::pair<unsigned int, unsigned int> > const request(ri);
// disconnect any clients with a connection to SWG services
GenericValueTypeMessage<unsigned int> kickSource("TransferKickConnectedClients", request.getValue().first);
GenericValueTypeMessage<unsigned int> kickDestination("TransferKickConnectedClients", request.getValue().second);
CentralServer::getInstance().sendToAllLoginServers(kickSource);
CentralServer::getInstance().sendToAllLoginServers(kickDestination);
CentralServer::getInstance().sendToAllConnectionServers(kickSource, true);
CentralServer::getInstance().sendToAllConnectionServers(kickDestination, true);
}
else if(msg.isType("TransferGetCharacterDataFromLoginServer"))
{
const GenericValueTypeMessage<TransferCharacterData> getCharacterData(ri);
// The transfer server has received a move request. The request doesn't
// contain the source id of the character, character's container or scene
// information. The LoginServer can retrieve the character ID for the
// source station id + character name contained in character data.
// Forward the request to the login server. It will respond and the
// message can be routed back to the transfer server for further
// processing
IGNORE_RETURN(CentralServer::getInstance().sendToArbitraryLoginServer(getCharacterData));
LOG("CustomerService", ("CharacterTransfer: ***CentralServer: received TransferGetCharacterDataFromLoginServer : %s)", getCharacterData.getValue().toString().c_str()));
}
else if(msg.isType("TransferGetLoginLocationData"))
{
GenericValueTypeMessage<TransferCharacterData> getLoginData(ri);
CentralServer::getInstance().sendToDBProcess(getLoginData, true);
LOG("CustomerService", ("CharacterTransfer: ***CentralServer: Received TransferGetLoginLocationData for %s\n", getLoginData.getValue().getSourceCharacterName().c_str()));
}
else if(msg.isType("TransferLoginCharacterToSourceServer"))
{
const GenericValueTypeMessage<TransferCharacterData> loginCharacter(ri);
ConnectionServerConnection * connectionServer = CentralServer::getInstance().getAnyConnectionServer();
if(connectionServer)
{
connectionServer->send(loginCharacter, true);
LOG("CustomerService", ("CharacterTransfer: ***CentralServer: Received TransferLoginCharacterToSourceServer request from Transfer Server. Sendint request to ConnectionServer : %s\n", loginCharacter.getValue().toString().c_str()));
}
else
{
LOG("CustomerService", ("CharacterTransfer: ***CentralServer: Couldn't find a connection server to satisfy the transfer request for %s\n", loginCharacter.getValue().toString().c_str()));
}
}
else if(msg.isType("TransferLoginCharacterToDestinationServer"))
{
const GenericValueTypeMessage<TransferCharacterData> loginCharacter(ri);
LOG("CustomerService", ("CharacterTransfer: ***CentralServer: Received TransferLoginCharacterToDestinationServer request from Transfer Server for %s\n", loginCharacter.getValue().toString().c_str()));
ConnectionServerConnection * connectionServer = CentralServer::getInstance().getAnyConnectionServer();
if(connectionServer)
{
connectionServer->send(loginCharacter, true);
}
}
else if(msg.isType("ToggleAvatarLoginStatus"))
{
ToggleAvatarLoginStatus toggle(ri);
LOG("CustomerService", ("CharacterTransfer: Received ToggleAvatarLoginStatus for station ID %d, Character Object %s", toggle.getStationId(), toggle.getCharacterId().getValueString().c_str()));
IGNORE_RETURN(CentralServer::getInstance().sendToArbitraryLoginServer(toggle));
}
else if(msg.isType("TransferRequestNameValidation"))
{
GenericValueTypeMessage<TransferCharacterData> request(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferRequestNameValidation from TransferServer. Forwarding request to a random GameServer. %s", request.getValue().toString().c_str()));
IGNORE_RETURN(CentralServer::getInstance().sendToRandomGameServer(request));
}
else if(msg.isType("TransferRenameCharacter"))
{
GenericValueTypeMessage<TransferCharacterData> renameRequest(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferRenameCharacter. Sending rename request to game database. %s", renameRequest.getValue().toString().c_str()));
// send first portion of request to DBProcess , wait for response
CentralServer::getInstance().sendToDBProcess(renameRequest, true);
}
else if(msg.isType("TransferAccountRequestLoginServer"))
{
// got message to transfer a character from one account to another - have to update in loginServer
GenericValueTypeMessage<TransferAccountData> accountTransferRequest(ri);
LOG("CustomerService", ("CharacterTransfer: Received TransferAccountRequestLoginServer from station ID %d to station ID %d", accountTransferRequest.getValue().getSourceStationId(), accountTransferRequest.getValue().getDestinationStationId()));
IGNORE_RETURN(CentralServer::getInstance().sendToArbitraryLoginServer(accountTransferRequest));
}
else if(msg.isType("RequestChatTransferAvatar"))
{
GenericValueTypeMessage<TransferCharacterData> chatTransferAvatar(ri);
LOG("CustomerService", ("CharacterTransfer: Received RequestChatTransferAvatar from TransferServer. Forward request to ChatServer. %s", chatTransferAvatar.getValue().toString().c_str()));
CentralServer::getInstance().broadcastToChatServers(chatTransferAvatar);
}
else if(msg.isType("DeleteFailedTransfer"))
{
GenericValueTypeMessage<TransferCharacterData> deleteCharacter(ri);
LOG("CustomerService", ("CharacterTransfer: received request to delete a character for a failed transfer. %s", deleteCharacter.getValue().toString().c_str()));
IGNORE_RETURN(CentralServer::getInstance().sendToArbitraryLoginServer(deleteCharacter));
}
else if(msg.isType("TransferClosePseudoClientConnection"))
{
GenericValueTypeMessage<unsigned int> closeRequest(ri);
CentralServer::getInstance().sendToAllConnectionServers(closeRequest, true);
}
else if(msg.isType("ConGenericMessage"))
{
ConGenericMessage con(ri);
ConsoleConnection::onCommandComplete(con.getMsg(), static_cast<int>(con.getMsgId()));
}
}
void StellarisPortPin::pulse(unsigned long micros) {
toggle();
ROM_SysCtlDelay((40 * micros) / 3);
toggle();
}
main(int argc, char *argv[])
{
toplevel = XtAppInitialize(&app, "Paperplane", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
dpy = XtDisplay(toplevel);
/* find an OpenGL-capable RGB visual with depth buffer */
vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf);
if (vi == NULL) {
vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf);
if (vi == NULL)
XtAppError(app, "no RGB visual with depth buffer");
doubleBuffer = GL_FALSE;
}
/* create an OpenGL rendering context */
cx = glXCreateContext(dpy, vi, /* no display list sharing */ None,
/* favor direct */ GL_TRUE);
if (cx == NULL)
XtAppError(app, "could not create rendering context");
/* create an X colormap since probably not using default visual */
#ifdef noGLwidget
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
vi->visual, AllocNone);
/*
* Establish the visual, depth, and colormap of the toplevel
* widget _before_ the widget is realized.
*/
XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth,
XtNcolormap, cmap, NULL);
#endif
XtAddEventHandler(toplevel, StructureNotifyMask, False,
map_state_changed, NULL);
mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0);
XtManageChild(mainw);
/* create menu bar */
menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0);
XtManageChild(menubar);
#ifdef noGLwidget
/* Hack around Xt's unfortunate default visual inheritance. */
XtSetArg(menuPaneArgs[0], XmNvisual, vi->visual);
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
btn = XmCreatePushButton(menupane, "Quit", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, quit, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "File", args, 1);
XtManageChild(cascade);
#ifdef noGLwidget
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
btn = XmCreateToggleButton(menupane, "Motion", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc)toggle, NULL);
XtManageChild(btn);
btn = XmCreatePushButton(menupane, "Add plane", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)add_plane, NULL);
XtManageChild(btn);
btn = XmCreatePushButton(menupane, "Remove plane", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)remove_plane, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Planes", args, 1);
XtManageChild(cascade);
/* create framed drawing area for OpenGL rendering */
frame = XmCreateFrame(mainw, "frame", NULL, 0);
XtManageChild(frame);
#ifdef noGLwidget
glxarea = XtVaCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass,
frame, NULL);
#else
#ifdef noMotifGLwidget
/* notice glwDrawingAreaWidgetClass lacks an 'M' */
glxarea = XtVaCreateManagedWidget("glxarea", glwDrawingAreaWidgetClass,
#else
glxarea = XtVaCreateManagedWidget("glxarea", glwMDrawingAreaWidgetClass,
#endif
frame, GLwNvisualInfo, vi, NULL);
#endif
XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc)draw, NULL);
XtAddCallback(glxarea, XmNresizeCallback, resize, NULL);
XtAddCallback(glxarea, XmNinputCallback, input, NULL);
/* set up application's window layout */
XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame);
XtRealizeWidget(toplevel);
/*
* Once widget is realized (ie, associated with a created X window), we
* can bind the OpenGL rendering context to the window.
*/
glXMakeCurrent(dpy, XtWindow(glxarea), cx);
made_current = GL_TRUE;
/* setup OpenGL state */
glClearDepth(1.0);
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 20);
glMatrixMode(GL_MODELVIEW);
/* add three initial random planes */
srandom(getpid());
add_plane(); add_plane(); add_plane(); add_plane(); add_plane();
/* start event processing */
toggle();
XtAppMainLoop(app);
}
