//Calculates the new position of the planet, based on the hoursPassed (and the initOrbitDegree)
void Planet :: move()
{
//Get theta
double theta = (((hoursPassed / 24) / daysToOrbit)+initOrbitDegree);
//Make sure theta is in the range 0 - 360
if (theta > 360.0)
{
theta -= 360.0;
}
//Change to negative to get orbits to go counterclockwise, and switch to radians
theta = -theta*DEG2RAD;
setCurrentPosition(getOrbitX(theta),getOrbitY(),getOrbitZ(theta));
}
void
AudioOutput::onVlcEvent( const libvlc_event_t* event )
{
switch ( event->type )
{
case libvlc_MediaPlayerTimeChanged:
setCurrentTime( event->u.media_player_time_changed.new_time );
break;
case libvlc_MediaPlayerPositionChanged:
setCurrentPosition( event->u.media_player_position_changed.new_position );
break;
case libvlc_MediaPlayerSeekableChanged:
// tDebug() << Q_FUNC_INFO << " : seekable changed : " << event->u.media_player_seekable_changed.new_seekable;
break;
case libvlc_MediaDurationChanged:
setTotalTime( event->u.media_duration_changed.new_duration );
break;
case libvlc_MediaPlayerLengthChanged:
// tDebug() << Q_FUNC_INFO << " : length changed : " << event->u.media_player_length_changed.new_length;
break;
case libvlc_MediaPlayerPlaying:
setState( Playing );
break;
case libvlc_MediaPlayerPaused:
setState( Paused );
break;
case libvlc_MediaPlayerEndReached:
setState( Stopped );
break;
case libvlc_MediaPlayerEncounteredError:
tDebug() << Q_FUNC_INFO << "LibVLC error: MediaPlayerEncounteredError. Stopping";
// Don't call stop() here - it will deadlock libvlc
setState( Error );
break;
case libvlc_MediaPlayerNothingSpecial:
case libvlc_MediaPlayerOpening:
case libvlc_MediaPlayerBuffering:
case libvlc_MediaPlayerStopped:
case libvlc_MediaPlayerVout:
case libvlc_MediaPlayerMediaChanged:
case libvlc_MediaPlayerForward:
case libvlc_MediaPlayerBackward:
case libvlc_MediaPlayerPausableChanged:
case libvlc_MediaPlayerTitleChanged:
case libvlc_MediaPlayerSnapshotTaken:
default:
break;
}
}
HouseChoiceMenu::HouseChoiceMenu() : MenuBase()
{
currentHouseChoiceScrollPos = 0;
// set up window
int xpos = std::max(0,(screen->w - 640)/2);
int ypos = std::max(0,(screen->h - 400)/2);
setCurrentPosition(xpos,ypos,640,400);
setTransparentBackground(true);
setWindowWidget(&windowWidget);
selectYourHouseLabel.setSurface(pGFXManager->getUIGraphic(UI_SelectYourHouseLarge), false);
windowWidget.addWidget(&selectYourHouseLabel, Point(0,0), Point(100, 640));
// set up buttons
house1Button.setOnClick(std::bind(&HouseChoiceMenu::onHouseButton, this, 0));
windowWidget.addWidget(&house1Button, Point(40,108), Point(168,182));
house2Button.setOnClick(std::bind(&HouseChoiceMenu::onHouseButton, this, 1));
windowWidget.addWidget(&house2Button, Point(235,108), Point(168,182));
house3Button.setOnClick(std::bind(&HouseChoiceMenu::onHouseButton, this, 2));
windowWidget.addWidget(&house3Button, Point(430,108), Point(168,182));
SDL_Surface* surf;
SDL_Surface* surfPressed;
surf = pGFXManager->getUIGraphic(UI_Herald_ArrowLeftLarge);
surfPressed = pGFXManager->getUIGraphic(UI_Herald_ArrowLeftHighlightLarge);
houseLeftButton.setSurfaces(surf, false, surf, false, surfPressed, false);
houseLeftButton.setOnClick(std::bind(&HouseChoiceMenu::onHouseLeft, this));
houseLeftButton.setVisible(false);
windowWidget.addWidget( &houseLeftButton, Point(320 - surf->w - 85, 360), Point(surf->w,surf->h));
surf = pGFXManager->getUIGraphic(UI_Herald_ArrowRightLarge);
surfPressed = pGFXManager->getUIGraphic(UI_Herald_ArrowRightHighlightLarge);
houseRightButton.setSurfaces(surf, false, surf, false, surfPressed, false);
houseRightButton.setOnClick(std::bind(&HouseChoiceMenu::onHouseRight, this));
windowWidget.addWidget( &houseRightButton, Point(320 + 85, 360), Point(surf->w,surf->h));
updateHouseChoice();
}
bool CpuProfileInputStream::resetStream()
{
bool ret = false;
if (m_fileStream.isOpened())
{
#if AMDT_BUILD_TARGET == AMDT_LINUX_OS
// NOTE:This is a hack for GCC-4.1.1
// to force resetting the stream location
long off;
m_fileStream.currentPosition(off);
#endif
ret = setCurrentPosition(&m_bof);
}
return ret;
}
GlobalReference& GlobalReference::setCurrentHeading(const State& state, double new_heading) {
// get current yaw angle
double current_yaw = state.getYaw();
State::ConstPositionType position = state.getPosition();
// get current position in WGS84
double current_latitude, current_longitude;
if (hasPosition()) {
toWGS84(position.x(), position.y(), current_latitude, current_longitude);
}
// set the new reference heading
setHeading(new_heading - (-current_yaw));
// set the new reference position so that current position in WGS84 coordinates remains the same as before
if (hasPosition()) {
setCurrentPosition(state, current_latitude, current_longitude);
}
return *this;
}
void NewPosition(int pos)
{
char buf[256];
#ifdef REVERSED_CABLEA
int diff = pos - electrodeDepth;
#else
int diff = electrodeDepth - pos;
#endif
int old = electrodeDepth;
int portstate;
if(motorinvert){
while((electrodeDepthOffset-pos) <= 0){
electrodeDepthOffset += 10000;
}
}
else{
while((electrodeDepthOffset+pos) <= 0){
electrodeDepthOffset += 10000;
}
}
#ifdef OLDCODE
while((pos - electrodeDepthOffset) >= 0){
electrodeDepthOffset -= 10000;
}
#endif
if(fabs(diff) > 9999){
sprintf(buf,"Thats a big step (%d) Proceed?",diff);
acknowledge(buf,"/bgc/bgc/c/binoc/help/bigstep.err");
}
if(fabs(diff) > 200){
sprintf(buf,"Thats a big step (%d) Proceed?",diff);
if(!confirm_yes(buf,NULL))
return;
}
#ifdef DEBUG
printf("Setting new Postion to %d (%d) %d\n",pos,diff,electrodeDepthOffset);
#endif
#if !defined(WIN32)
ioctl(motorPort,TIOCMGET,&portstate);
if(!(portstate & TIOCM_CTS)){
fprintf(stderr,"Stepper Not Ready\n");
acknowledge("Stepper Not Ready!");
if(optionflags[STEP_CLEAR_SPIKES]){
memcpy(&cleartime,&now,sizeof(struct timeval));
/* empirical approximation for the duration of the movement artifact */
cleardelay = 0.2;
}
return;
}
#endif
sprintf(buf,"%d",pos);
electrodeDepth = pos;
selectMotor(motorids[motorid]);
setCurrentPosition(old);
setNewPosition(electrodeDepth,diff);
gettimeofday(&now,NULL);
times[totalsteps] = timediff(&now,&progstarttime) + timeoffset;
depths[totalsteps] = electrodeDepth;
if(penlog){
fprintf(penlog,"ed %d at %.1f\n",electrodeDepth,times[totalsteps]);
if(diff < -200){
fprintf(penlog,"Step Back at %s\n",binocTimeString());
}
}
times[totalsteps+1] = 0;
if(totalsteps < MAXDEPTHS-1)
totalsteps++;
if(optionflags[STEP_CLEAR_SPIKES]){
memcpy(&cleartime,&now,sizeof(struct timeval));
/* empirical approximation for the duration of the movement artifact */
cleardelay = 0.11 + fabs(diff) * 0.027 - pow(fabs(diff),1.13) * 0.0113;
}
notifyPositionChange(electrodeDepth);
}
LoadMapWindow::LoadMapWindow(int color) : Window(0,0,0,0), color(color) {
// set up window
SDL_Surface *surf;
surf = pGFXManager->getUIGraphic(UI_NewMapWindow);
setBackground(surf,false);
int xpos = std::max(0,(screen->w - surf->w)/2);
int ypos = std::max(0,(screen->h - surf->h)/2);
setCurrentPosition(xpos,ypos,surf->w,surf->h);
setWindowWidget(&mainHBox);
mainHBox.addWidget(HSpacer::create(16));
mainHBox.addWidget(&mainVBox);
mainHBox.addWidget(HSpacer::create(16));
titleLabel.setTextColor(110, COLOR_TRANSPARENT);
titleLabel.setAlignment((Alignment_Enum) (Alignment_HCenter | Alignment_VCenter));
titleLabel.setText(_("Load Map"));
mainVBox.addWidget(&titleLabel);
mainVBox.addWidget(VSpacer::create(22));
mainVBox.addWidget(¢ralHBox, 346);
centralHBox.addWidget(&leftVBox, 0.8);
leftVBox.addWidget(&mapTypeButtonsHBox, 24);
singleplayerUserMapsButton.setText(_("SP User Maps"));
singleplayerUserMapsButton.setTextColor(color);
singleplayerUserMapsButton.setToggleButton(true);
singleplayerUserMapsButton.setOnClick(std::bind(&LoadMapWindow::onMapTypeChange, this, 0));
mapTypeButtonsHBox.addWidget(&singleplayerUserMapsButton);
multiplayerUserMapsButton.setText(_("MP User Maps"));
multiplayerUserMapsButton.setTextColor(color);
multiplayerUserMapsButton.setToggleButton(true);
multiplayerUserMapsButton.setOnClick(std::bind(&LoadMapWindow::onMapTypeChange, this, 1));
mapTypeButtonsHBox.addWidget(&multiplayerUserMapsButton);
mapTypeButtonsHBox.addWidget(Spacer::create(), 5.0);
mapList.setColor(color);
mapList.setAutohideScrollbar(false);
mapList.setOnSelectionChange(std::bind(&LoadMapWindow::onMapListSelectionChange, this, std::placeholders::_1));
mapList.setOnDoubleClick(std::bind(&LoadMapWindow::onLoad, this));
leftVBox.addWidget(&mapList, 0.95);
leftVBox.addWidget(VSpacer::create(10));
centralHBox.addWidget(HSpacer::create(8));
centralHBox.addWidget(Spacer::create(), 0.05);
centralHBox.addWidget(&rightVBox, 180);
minimap.setSurface( GUIStyle::getInstance().createButtonSurface(130,130,_("Choose map"), true, false), true);
rightVBox.addWidget(&minimap);
rightVBox.addWidget(VSpacer::create(10));
rightVBox.addWidget(&mapPropertiesHBox, 0.01);
mapPropertiesHBox.addWidget(&mapPropertyNamesVBox, 75);
mapPropertiesHBox.addWidget(&mapPropertyValuesVBox, 105);
mapPropertyNamesVBox.addWidget(Label::create(_("Size") + ":", color));
mapPropertySize.setTextColor(color);
mapPropertyValuesVBox.addWidget(&mapPropertySize);
mapPropertyNamesVBox.addWidget(Label::create(_("Players") + ":", color));
mapPropertyPlayers.setTextColor(color);
mapPropertyValuesVBox.addWidget(&mapPropertyPlayers);
mapPropertyNamesVBox.addWidget(Label::create(_("Author") + ":", color));
mapPropertyAuthors.setTextColor(color);
mapPropertyValuesVBox.addWidget(&mapPropertyAuthors);
mapPropertyNamesVBox.addWidget(Label::create(_("License") + ":", color));
mapPropertyLicense.setTextColor(color);
mapPropertyValuesVBox.addWidget(&mapPropertyLicense);
rightVBox.addWidget(Spacer::create());
mainVBox.addWidget(VSpacer::create(5));
mainVBox.addWidget(&buttonHBox);
cancelButton.setText(_("Cancel"));
cancelButton.setTextColor(color);
cancelButton.setOnClick(std::bind(&LoadMapWindow::onCancel, this));
buttonHBox.addWidget(&cancelButton);
buttonHBox.addWidget(HSpacer::create(8));
buttonHBox.addWidget(Spacer::create());
buttonHBox.addWidget(HSpacer::create(8));
loadButton.setText(_("Load"));
loadButton.setTextColor(color);
loadButton.setOnClick(std::bind(&LoadMapWindow::onLoad, this));
buttonHBox.addWidget(&loadButton);
mainVBox.addWidget(VSpacer::create(10));
onMapTypeChange(0);
}
LoadSaveWindow::LoadSaveWindow(bool bSave, std::string caption, std::vector<std::string> directories, std::vector<std::string> directoryTitles, std::string extension, int preselectedDirectoryIndex, std::string preselectedFile, int color)
: Window(0,0,0,0), bSaveWindow(bSave), directories(directories), directoryTitles(directoryTitles), extension(extension), currentDirectoryIndex(preselectedDirectoryIndex), preselectedFile(preselectedFile), color(color) {
// set up window
SDL_Surface *surf;
surf = pGFXManager->getUIGraphic(UI_LoadSaveWindow);
setBackground(surf,false);
int xpos = std::max(0,(screen->w - surf->w)/2);
int ypos = std::max(0,(screen->h - surf->h)/2);
setCurrentPosition(xpos,ypos,surf->w,surf->h);
setWindowWidget(&mainHBox);
mainHBox.addWidget(HSpacer::create(16));
mainHBox.addWidget(&mainVBox);
mainHBox.addWidget(HSpacer::create(16));
titleLabel.setTextColor(110, COLOR_TRANSPARENT);
titleLabel.setAlignment((Alignment_Enum) (Alignment_HCenter | Alignment_VCenter));
titleLabel.setText(caption);
mainVBox.addWidget(&titleLabel);
mainVBox.addWidget(VSpacer::create(8));
if(directories.size() > 1) {
directoryButtons.resize(directories.size());
for(size_t i=0;i<directories.size(); i++) {
directoryButtons[i].setText(directoryTitles[i]);
directoryButtons[i].setTextColor(color);
directoryButtons[i].setToggleButton(true);
directoryButtons[i].setOnClick(std::bind(&LoadSaveWindow::onDirectoryChange, this, i));
directoryHBox.addWidget(&directoryButtons[i]);
}
mainVBox.addWidget(&directoryHBox, 20);
}
mainVBox.addWidget(&fileListHBox, (bSave ? 120 : 150) - (directories.size() > 1 ? 20 : 0));
fileList.setColor(color);
fileList.setOnSelectionChange(std::bind(&LoadSaveWindow::onSelectionChange, this, std::placeholders::_1));
fileList.setOnDoubleClick(std::bind(&LoadSaveWindow::onOK, this));
fileListHBox.addWidget(&fileList);
mainVBox.addWidget(VSpacer::create(5));
if(bSave == true) {
saveName.setTextColor(color);
mainVBox.addWidget(&saveName);
saveName.setMaximumTextLength(64);
mainVBox.addWidget(VSpacer::create(5));
}
mainVBox.addWidget(&buttonHBox);
okButton.setText(_(bSave ? "Save" : "Load"));
okButton.setTextColor(color);
okButton.setOnClick(std::bind(&LoadSaveWindow::onOK, this));
buttonHBox.addWidget(&okButton);
buttonHBox.addWidget(HSpacer::create(8));
cancelButton.setText(_("Cancel"));
cancelButton.setTextColor(color);
cancelButton.setOnClick(std::bind(&LoadSaveWindow::onCancel, this));
buttonHBox.addWidget(&cancelButton);
mainVBox.addWidget(VSpacer::create(10));
if(directories.size() > 1) {
onDirectoryChange(currentDirectoryIndex);
} else {
updateEntries();
}
if(bSaveWindow && (fileList.getSelectedIndex() < 0)) {
saveName.setText(preselectedFile);
saveName.setActive();
}
this->preselectedFile = "";
}
void Application::init_connections(){
CONNECT (player, pause(), listen, pause());
CONNECT (player, search(int), listen, jump(int));
CONNECT (player, sig_volume_changed(int), listen, setVolume(int));
CONNECT (player, sig_rec_button_toggled(bool), listen, record_button_toggled(bool));
CONNECT (player, setupLastFM(), ui_lastfm, show_win()); // IND
CONNECT (player, baseDirSelected(const QString &), library, baseDirSelected(const QString & ));
CONNECT (player, reloadLibrary(), library, reloadLibrary());
CONNECT (player, importDirectory(QString), library, importDirectory(QString));
CONNECT (player, libpath_changed(QString), library, setLibraryPath(QString));
CONNECT (player, fileSelected(QStringList &), playlist, psl_createPlaylist(QStringList&));
CONNECT (player, play(), playlist, psl_play());
CONNECT (player, stop(), playlist, psl_stop());
CONNECT (player, forward(), playlist, psl_forward());
CONNECT (player, backward(), playlist, psl_backward());
CONNECT (player, sig_stream_selected(const QString&, const QString&), playlist, psl_play_stream(const QString&, const QString&));
CONNECT (player, show_playlists(), ui_playlist_chooser, show()); // IND
CONNECT (player, skinChanged(bool), ui_playlist, change_skin(bool));
CONNECT (player, show_small_playlist_items(bool), ui_playlist, psl_show_small_playlist_items(bool));
CONNECT (player, sig_sound_engine_changed(QString&), plugin_loader, psl_switch_engine(QString&));
CONNECT (player, sig_show_stream_rec(bool), ui_stream_rec, psl_show(bool)); // IND
CONNECT (player, sig_show_socket(), ui_socket_setup, show()); // IND
CONNECT (player, sig_correct_id3(const MetaData&), ui_id3_editor, change_meta_data(const MetaData&)); // IND
CONNECT (playlist, sig_selected_file_changed_md(const MetaData&), player, update_track(const MetaData&));
CONNECT (playlist, sig_selected_file_changed_md(const MetaData&), listen, changeTrack(const MetaData & ));
CONNECT (playlist, sig_selected_file_changed_md(const MetaData&), lastfm, psl_track_changed(const MetaData&));
CONNECT (playlist, sig_no_track_to_play(), listen, stop());
CONNECT (playlist, sig_goon_playing(), listen, play());
CONNECT (playlist, sig_selected_file_changed(int), ui_playlist, track_changed(int));
CONNECT (playlist, sig_playlist_created(vector<MetaData>&, int), ui_playlist, fillPlaylist(vector<MetaData>&, int));
//CONNECT (&playlist, sig_cur_played_info_changed(const MetaData&), &player, update_info(const MetaData&));
CONNECT (playlist, sig_playlist_prepared(int, vector<MetaData>&), playlists, save_playlist_as_custom(int, vector<MetaData>&));
CONNECT (playlist, sig_playlist_prepared(QString, vector<MetaData>&), playlists, save_playlist_as_custom(QString, vector<MetaData>&));
CONNECT (playlist, sig_library_changed(), ui_library, library_changed());
CONNECT (playlist, sig_import_files(const vector<MetaData>&), library, importFiles(const vector<MetaData>&));
CONNECT (playlist, sig_need_more_radio(), lastfm, psl_radio_playlist_request());
CONNECT (playlist, sig_radio_active(int), player, set_radio_active(int));
CONNECT (playlist, sig_radio_active(int), ui_playlist, set_radio_active(int));
// Can be done inside player
CONNECT (playlist, sig_radio_active(int), ui_playlist_chooser, set_radio_active(int));
CONNECT (playlist, sig_data_for_id3_change(const vector<MetaData>&), ui_id3_editor, change_meta_data(const vector<MetaData>&)); // IND
CONNECT (ui_playlist, selected_row_changed(int), playlist, psl_change_track(int));
CONNECT (ui_playlist, clear_playlist(), playlist, psl_clear_playlist());
CONNECT (ui_playlist, playlist_mode_changed(const Playlist_Mode&), playlist, psl_playlist_mode_changed(const Playlist_Mode&));
CONNECT (ui_playlist, dropped_tracks(const vector<MetaData>&, int), playlist, psl_insert_tracks(const vector<MetaData>&, int));
CONNECT (ui_playlist, sound_files_dropped(QStringList&), playlist, psl_createPlaylist(QStringList&));
CONNECT (ui_playlist, directory_dropped(const QString&, int), playlist, psl_directoryDropped(const QString &, int ));
CONNECT (ui_playlist, rows_removed(const QList<int>&), playlist, psl_remove_rows(const QList<int>&));
CONNECT (ui_playlist, sig_import_to_library(bool), playlist, psl_import_new_tracks_to_library(bool));
CONNECT (listen, track_finished(), playlist, psl_next_track() );
CONNECT (listen, sig_valid_strrec_track(const MetaData&), playlist, psl_valid_strrec_track(const MetaData&));
CONNECT (listen, scrobble_track(const MetaData&), lastfm, psl_scrobble(const MetaData&));
// should be sent to player
CONNECT (listen, eq_presets_loaded(const vector<EQ_Setting>&), ui_eq, fill_eq_presets(const vector<EQ_Setting>&));
CONNECT (listen, eq_found(const QStringList&), ui_eq, fill_available_equalizers(const QStringList&));
CONNECT (listen, total_time_changed_signal(qint64), player, total_time_changed(qint64));
CONNECT (listen, timeChangedSignal(quint32), player, setCurrentPosition(quint32) );
CONNECT(library, sig_playlist_created(QStringList&), playlist, psl_createPlaylist(QStringList&));
CONNECT(library, sig_import_result(bool), playlist, psl_import_result(bool));
CONNECT(library, sig_import_result(bool), ui_playlist, import_result(bool));
CONNECT(library, sig_reload_library_finished(), ui_library, reloading_library_finished());
CONNECT(library, sig_reloading_library(QString&), ui_library, reloading_library(QString&));
CONNECT(library, sig_import_result(bool), ui_library, import_result(bool));
CONNECT(library, sig_metadata_loaded(vector<MetaData>&), ui_library, fill_library_tracks(vector<MetaData>&));
CONNECT(library, sig_all_albums_loaded(vector<Album>&), ui_library, fill_library_albums(vector<Album>&));
CONNECT(library, sig_all_artists_loaded(vector<Artist>&), ui_library, fill_library_artists(vector<Artist>&));
CONNECT(library, sig_track_mime_data_available(const vector<MetaData>&), ui_library, track_info_available(const vector<MetaData>&));
CONNECT(library, sig_tracks_for_playlist_available(vector<MetaData>&), playlist, psl_createPlaylist(vector<MetaData>&));
CONNECT(library, sig_import_result(bool), playlists, import_result(bool));
CONNECT(library, sig_delete_answer(QString), ui_library, psl_delete_answer(QString));
CONNECT(library, sig_play_next_tracks(const vector<MetaData>&), playlist, psl_play_next_tracks(const vector<MetaData>&));
if(ui_id3_editor)
CONNECT(library, sig_change_id3_tags(const vector<MetaData>&), ui_id3_editor, change_meta_data(const vector<MetaData>&)); // IND
CONNECT(ui_library, sig_album_dbl_clicked(), library, psl_prepare_album_for_playlist());
CONNECT(ui_library, sig_artist_dbl_clicked(), library, psl_prepare_artist_for_playlist());
CONNECT(ui_library, sig_track_dbl_clicked(int), library, psl_prepare_track_for_playlist(int));
CONNECT(ui_library, sig_artist_pressed(const QList<int>&), library, psl_selected_artists_changed(const QList<int>&));
CONNECT(ui_library, sig_album_pressed(const QList<int>&), library, psl_selected_albums_changed(const QList<int>&));
CONNECT(ui_library, sig_track_pressed(const QList<int>&), library, psl_selected_tracks_changed(const QList<int>&));
CONNECT(ui_library, sig_filter_changed(const Filter&), library, psl_filter_changed(const Filter&));
CONNECT(ui_library, sig_sortorder_changed(Sort::ArtistSort, Sort::AlbumSort, Sort::TrackSort),
library, psl_sortorder_changed(Sort::ArtistSort, Sort::AlbumSort, Sort::TrackSort));
CONNECT(ui_library, sig_show_id3_editor(const QList<int>&), library, psl_change_id3_tags(const QList<int>&));
CONNECT(ui_library, sig_delete_tracks(int), library, psl_delete_tracks(int));
CONNECT(ui_library, sig_delete_certain_tracks(const QList<int>&, int), library, psl_delete_certain_tracks(const QList<int>&, int));
CONNECT(ui_library, sig_play_next_tracks(const QList<int>&), library, psl_play_next_tracks(const QList<int>&));
CONNECT(ui_library, sig_play_next_all_tracks(), library, psl_play_next_all_tracks());
CONNECT(ui_lastfm, sig_activated(bool), player, psl_lfm_activated(bool));
CONNECT(ui_lastfm, sig_activated(bool), ui_playlist, psl_lfm_activated(bool));
CONNECT(ui_lastfm, new_lfm_credentials(QString, QString), lastfm, psl_login(QString, QString));
CONNECT(ui_eq, eq_changed_signal(int, int), listen, eq_changed(int, int));
CONNECT(ui_eq, eq_enabled_signal(bool), listen, eq_enable(bool));
CONNECT(ui_eq, close_event(), player, close_eq());
CONNECT(ui_playlist, edit_id3_signal(), playlist, psl_edit_id3_request());
CONNECT(ui_id3_editor, id3_tags_changed(), ui_library, id3_tags_changed());
CONNECT(ui_id3_editor, id3_tags_changed(vector<MetaData>&), playlist, psl_id3_tags_changed(vector<MetaData>&));
CONNECT(ui_id3_editor, id3_tags_changed(vector<MetaData>&), player, psl_id3_tags_changed(vector<MetaData>&));
CONNECT(lastfm, sig_similar_artists_available(const QList<int>&), playlist, psl_similar_artists_available(const QList<int>&));
CONNECT(lastfm, sig_last_fm_logged_in(bool), ui_playlist, last_fm_logged_in(bool));
CONNECT(lastfm, sig_last_fm_logged_in(bool), player, last_fm_logged_in(bool));
CONNECT(lastfm, sig_new_radio_playlist(const vector<MetaData>&), playlist, psl_new_radio_playlist_available(const vector<MetaData>&));
CONNECT(lastfm, sig_track_info_fetched(const MetaData&, bool, bool), player, lfm_info_fetched(const MetaData&, bool, bool));
CONNECT(ui_playlist_chooser, sig_playlist_chosen(int), playlists, load_single_playlist(int));
CONNECT(ui_playlist_chooser, sig_delete_playlist(int), playlists, delete_playlist(int));
CONNECT(ui_playlist_chooser, sig_save_playlist(int), playlist, psl_prepare_playlist_for_save(int));
CONNECT(ui_playlist_chooser, sig_save_playlist(QString), playlist, psl_prepare_playlist_for_save(QString));
CONNECT(ui_playlist_chooser, sig_clear_playlist(), playlist, psl_clear_playlist());
CONNECT(ui_playlist_chooser, sig_closed(), player, close_playlist_chooser());
CONNECT(playlists, sig_single_playlist_loaded(CustomPlaylist&), playlist, psl_createPlaylist(CustomPlaylist&));
CONNECT(playlists, sig_all_playlists_loaded(QMap<int, QString>&), ui_playlist_chooser, all_playlists_fetched(QMap<int, QString>&));
CONNECT(playlists, sig_import_tracks(const vector<MetaData>&), library, importFiles(const vector<MetaData>&));
CONNECT(ui_lfm_radio, listen_clicked(const QString&, int), lastfm, psl_radio_init(const QString&, int));
CONNECT(ui_lfm_radio, close_event(), player, close_lfm_radio());
CONNECT(ui_stream, sig_play_stream(const QString&, const QString&), playlist, psl_play_stream(const QString&, const QString&));
CONNECT(ui_stream, sig_close_event(), player, close_stream());
CONNECT (ui_stream_rec, sig_stream_recorder_active(bool), listen, psl_strrip_set_active(bool));
CONNECT (ui_stream_rec, sig_stream_recorder_active(bool), player, psl_strrip_set_active(bool));
CONNECT (ui_stream_rec, sig_path_changed(const QString&), listen, psl_strrip_set_path(const QString& ));
CONNECT (ui_stream_rec, sig_complete_tracks(bool), listen, psl_strrip_complete_tracks(bool));
CONNECT (ui_stream_rec, sig_create_playlist(bool), listen, psl_strrip_set_create_playlist(bool ));
bool is_socket_active = set->getSocketActivated();
if(is_socket_active){
CONNECT (remote_socket, sig_play(), playlist, psl_play());
CONNECT (remote_socket, sig_next(), playlist, psl_forward());
CONNECT (remote_socket, sig_prev(), playlist, psl_backward());
CONNECT (remote_socket, sig_stop(), playlist, psl_stop());
CONNECT (remote_socket, sig_pause(), listen, pause());
CONNECT (remote_socket, sig_setVolume(int),player, setVolume(int));
remote_socket->start();
}
}
bool parseForNextToken()
{
size_t pos = getCurrentPosition();
assert( pos < codestr.size() );
//
// Consume whitespace
//
for ( ;
pos < codestr.size() && isWhitespace(codestr[pos]);
++pos )
{
// do nothing, just consume space.
}
//
// End of the line?
//
if ( pos == codestr.size() )
{
setLastToken( "", TOK_EOF );
return false;
}
size_t startPos = pos;
//
// Search for the next token
//
TokenType type = TOK_UNKNOWN;
bool done = false;
bool error = false;
for ( ;
(!done) && pos < codestr.size() && (!isWhitespace(codestr[pos]))
&& ((pos == startPos) || !isEndOfToken(codestr[pos]) );
++pos )
{
char c = codestr[pos];
switch ( type )
{
case TOK_UNKNOWN:
if ( c == '(' )
{
type = TOK_OPEN;
done = true;
}
else if ( c == ')' )
{
type = TOK_CLOSE;
done = true;
}
else if ( c == ',' )
{
type = TOK_SEP;
done = true;
}
else if ( isNumeric( c ) )
{
type = TOK_NUMERIC;
}
else if ( isIdent( c ) )
{
type = TOK_IDENT;
}
else
{
error = true;
}
break;
case TOK_NUMERIC:
if ( isNumeric( c ) == false )
{
error = true;
}
break;
case TOK_IDENT:
if ( isIdent( c ) == false )
{
error = true;
}
break;
default:
error = true;
}
//
// Was there an error while parsing the token?
//
if ( error )
{
std::cerr << "Error while parsing token. "
<< "start=" << startPos << ", "
<< "pos=" << pos << ", "
<< "type=" << toString(type) << ", "
<< "value: "
<< codestr.substr( startPos, pos - startPos+1 )
<< std::endl;
return false;
}
}
setLastToken( codestr.substr(startPos, pos - startPos), type );
setCurrentPosition( pos );
return !isEOF();
}
void MusicConnectionPool::poolConnect(const QString &from, const QString &to)
{
QObject *first = m_para.value(from);
QObject *second = m_para.value(to);
if(first == nullptr || second == nullptr)
{
return;
}
if(from == "MusicPlayer" && to == "MusicLrcMakerWidget" )
{
QObject::connect(first, SIGNAL(positionChanged(qint64)), second,
SLOT(setCurrentPosition(qint64)));
}
if( (from == "MusicLocalSongsManagerWidget" && to == "MusicApplication") ||
(from == "MusicMyDownloadRecordWidget" && to == "MusicApplication") )
{
QObject::connect(first, SIGNAL(addSongToPlay(QStringList)), second,
SLOT(addSongToPlayList(QStringList)));
}
if(from == "MusicTimerWidget" && to == "MusicApplicationObject" )
{
QObject::connect(first, SIGNAL(timerParameterChanged()), second,
SLOT(musicToolSetsParameter()));
}
if( (from == "MusicToolSetsWidget" && to == "MusicApplication") ||
(from == "MusicApplicationObject" && to == "MusicApplication") )
{
QObject::connect(first, SIGNAL(getCurrentPlayList(QStringList&)), second,
SLOT(getCurrentPlayList(QStringList&)));
}
if(from == "MusicEqualizerDialog" && to == "MusicPlayer" )
{
QObject::connect(first, SIGNAL(setEqEffect(MIntList)), second,
SLOT(setEqEffect(MIntList)));
QObject::connect(first, SIGNAL(setEnaleEffect(bool)), second,
SLOT(setEnaleEffect(bool)));
}
if(from == "MusicSongSearchOnlineTableWidget" && to == "MusicDownloadStatusLabel" )
{
QObject::connect(first, SIGNAL(showDownLoadInfoFor(MusicObject::DownLoadType)), second,
SLOT(showDownLoadInfoFor(MusicObject::DownLoadType)));
}
if(from == "MusicBgThemeDownload" && to == "MusicTopAreaWidget" )
{
QObject::connect(first, SIGNAL(musicBgDownloadFinished()), second,
SLOT(musicBgThemeDownloadFinished()));
}
if(from == "MusicSongSearchOnlineTableWidget" && to == "MusicSongsSummarizied" )
{
QObject::connect(first, SIGNAL(muiscSongToPlayListChanged(QString,QString,QString)), second,
SLOT(addNetMusicSongToList(QString,QString,QString)));
}
if(from == "MusicSongSearchOnlineTableWidget" && to == "MusicRightAreaWidget" )
{
QObject::connect(first, SIGNAL(restartSearchQuery(QString)), second,
SLOT(musicResearchButtonSearched(QString)));
}
if(from == "MusicNetworkThread" && to == "MusicDownloadStatusLabel" )
{
QObject::connect(first, SIGNAL(networkConnectionStateChanged(bool)), second,
SLOT(networkConnectionStateChanged(bool)));
}
if(from == "MusicSongSearchOnlineTableWidget" && to == "MusicQualityChoiceTableWidget" )
{
QObject::connect(first, SIGNAL(getQualityString(QString&)), second,
SLOT(getQualityString(QString&)));
QObject::connect(second, SIGNAL(researchQueryByQuality()), first,
SLOT(researchQueryByQuality()));
}
if(from == "MusicSongsListPlayWidget" && to == "MusicRightAreaWidget" )
{
QObject::connect(first, SIGNAL(videoButtonClicked(QString)), second,
SLOT(musicVideoButtonSearched(QString)));
}
if(from == "MusicVideoControl" && to == "MusicRightAreaWidget" )
{
QObject::connect(first, SIGNAL(musicVideoSetPopup(bool)), second,
SLOT(musicVideoSetPopup(bool)));
QObject::connect(first, SIGNAL(musicVideoFullscreen(bool)), second,
SLOT(musicVideoFullscreen(bool)));
}
if(from == "MusicApplicationObject" && to == "MusicEnhancedWidget" )
{
QObject::connect(first, SIGNAL(enhancedMusicChanged(int)), second,
SLOT(setEnhancedMusicConfig(int)));
}
if(from == "MusicVideoControl" && to == "MusicVideoTableWidget" )
{
QObject::connect(first, SIGNAL(getMusicMvInfo(MusicSongAttributes&)), second,
SLOT(getMusicMvInfo(MusicSongAttributes&)));
QObject::connect(first, SIGNAL(downloadLocalByControl()), second,
SLOT(downloadLocalFromControl()));
}
}
//
// e x t r a c t S t r i n g
//
bool LineBuffer::extractString(
const LineBufferPosition &startPosition,
const LineBufferPosition &endPosition,
char *targetString)
{
// StartPosition invalid, probably because the line of the startPosition
// has already been overwritten, i.e. the string is too long
if (!isValidPosition(startPosition))
{
strcpy(targetString, "String too long!");
return false;
}
// EndPosition must be valid
OGDF_ASSERT(isValidPosition(endPosition))
// Remember original currentPosition
LineBufferPosition originalCurrentPosition = getCurrentPosition();
// Begin at startPosition
setCurrentPosition(startPosition);
// Copy characters to tempString
int targetStringIndex = 0;
while (getCurrentPosition() != endPosition)
{
// Check if eof
OGDF_ASSERT(getCurrentCharacter() != EOF)
// Put character into targetString
targetString[targetStringIndex] = getCurrentCharacter();
++targetStringIndex;
// String too long
if (targetStringIndex >= LineBuffer::c_maxStringLength - 1){
strcpy(targetString, "String too long!");
// Set back the original current position
setCurrentPosition(originalCurrentPosition);
return false;
}
// Move to next character
moveToNextCharacter();
} // Copy characters to tempString
// Set back the original current position
setCurrentPosition(originalCurrentPosition);
// Terminate string
targetString[targetStringIndex] = '\0';
return true;
} // extractString
void DebugSession::currentPositionChanged(const KUrl& url, int line)
{
setCurrentPosition(url, line, QString());
}
