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); }