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()));
auto addressManager = DependencyManager::get<AddressManager>();
addDisabledActionAndSeparator(fileMenu, "History");
QAction* backAction = addActionToQMenuAndActionHash(fileMenu,
MenuOption::Back,
0,
addressManager.data(),
SLOT(goBack()));
QAction* forwardAction = addActionToQMenuAndActionHash(fileMenu,
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);
addDisabledActionAndSeparator(fileMenu, "Location");
qApp->getBookmarks()->setupMenus(this, fileMenu);
addActionToQMenuAndActionHash(fileMenu,
MenuOption::AddressBar,
Qt::CTRL | Qt::Key_L,
dialogsManager.data(),
SLOT(toggleAddressBar()));
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()));
addMenu(DisplayPlugin::MENU_PATH());
{
MenuWrapper* displayModeMenu = addMenu(MenuOption::OutputMenu);
QActionGroup* displayModeGroup = new QActionGroup(displayModeMenu);
displayModeGroup->setExclusive(true);
}
MenuWrapper* avatarMenu = addMenu("Avatar");
QObject* avatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
MenuWrapper* inputModeMenu = addMenu(MenuOption::InputMenu);
QActionGroup* inputModeGroup = new QActionGroup(inputModeMenu);
inputModeGroup->setExclusive(false);
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(updateMotionBehaviorFromMenu()));
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::ScriptedMotorControl, 0, true,
avatar, SLOT(updateMotionBehaviorFromMenu()));
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::NamesAboveHeads, 0, true);
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::BlueSpeechSphere, 0, true);
addCheckableActionToQMenuAndActionHash(avatarMenu, MenuOption::EnableCharacterController, 0, true,
avatar, SLOT(updateMotionBehaviorFromMenu()));
MenuWrapper* viewMenu = addMenu("View");
addActionToQMenuAndActionHash(viewMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches()));
MenuWrapper* cameraModeMenu = viewMenu->addMenu("Camera Mode");
QActionGroup* cameraModeGroup = new QActionGroup(cameraModeMenu);
cameraModeGroup->setExclusive(true);
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(cameraModeMenu,
MenuOption::FirstPerson, 0, // QML Qt:: Key_P
false, qApp, SLOT(cameraMenuChanged())));
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(cameraModeMenu,
MenuOption::ThirdPerson, 0,
true, qApp, SLOT(cameraMenuChanged())));
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(cameraModeMenu,
MenuOption::IndependentMode, 0,
false, qApp, SLOT(cameraMenuChanged())));
cameraModeGroup->addAction(addCheckableActionToQMenuAndActionHash(cameraModeMenu,
MenuOption::FullscreenMirror, 0, // QML Qt::Key_H,
false, 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::CenterPlayerInView,
0, false, qApp, SLOT(rotationModeChanged()));
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::TurnWithHead, 0, false);
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::WorldAxes);
addCheckableActionToQMenuAndActionHash(viewMenu, MenuOption::Stats);
addActionToQMenuAndActionHash(viewMenu, MenuOption::Log,
Qt::CTRL | Qt::SHIFT | Qt::Key_L,
qApp, SLOT(toggleLogDialog()));
addActionToQMenuAndActionHash(viewMenu, MenuOption::AudioNetworkStats, 0,
dialogsManager.data(), SLOT(audioStatsDetails()));
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::DebugAmbientOcclusion);
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::Antialiasing);
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));
addCheckableActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::ThrottleFPSIfNotFocus, 0, true,
qApp, SLOT(setThrottleFPSEnabled()));
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);
addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::LodTools,
0, // QML Qt::SHIFT | Qt::Key_L,
dialogsManager.data(), SLOT(lodTools()));
MenuWrapper* assetDeveloperMenu = developerMenu->addMenu("Assets");
auto& assetDialogFactory = AssetUploadDialogFactory::getInstance();
assetDialogFactory.setParent(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);
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* 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
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
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::RenderLookAtTargets, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::RenderFocusIndicator, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::ShowWhosLookingAtMe, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::FixGaze, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableAvatarUpdateThreading, 0, false,
qApp, SLOT(setAvatarUpdateThreading(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableRigAnimations, 0, true,
avatar, SLOT(setEnableRigAnimations(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::EnableAnimGraph, 0, false,
avatar, SLOT(setEnableAnimGraph(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawBindPose, 0, false,
avatar, SLOT(setEnableDebugDrawBindPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::AnimDebugDrawAnimPose, 0, false,
avatar, SLOT(setEnableDebugDrawAnimPose(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::MeshVisible, 0, true,
avatar, SLOT(setEnableMeshVisible(bool)));
addCheckableActionToQMenuAndActionHash(avatarDebugMenu, MenuOption::DisableEyelidAdjustment, 0, false);
addCheckableActionToQMenuAndActionHash(avatarDebugMenu,
MenuOption::Connexion,
0, false,
&ConnexionClient::getInstance(),
SLOT(toggleConnexion(bool)));
MenuWrapper* handOptionsMenu = developerMenu->addMenu("Hands");
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::DisplayHandTargets, 0, false);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::HandMouseInput, 0, true);
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::LowVelocityFilter, 0, true,
qApp, SLOT(setLowVelocityFilter(bool)));
addCheckableActionToQMenuAndActionHash(handOptionsMenu, MenuOption::ShowIKConstraints, 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");
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()));
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::LogExtraTimings);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::SuppressShortTimings);
addCheckableActionToQMenuAndActionHash(timingMenu, MenuOption::ShowRealtimeEntityStats);
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);
}
MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics");
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned);
addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowHulls);
addCheckableActionToQMenuAndActionHash(developerMenu, MenuOption::DisplayCrashOptions, 0, true);
addActionToQMenuAndActionHash(developerMenu, MenuOption::CrashInterface, 0, qApp, SLOT(crashApplication()));
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
}
void URLNavigator::setURL(const KURL& url)
{
QString urlStr(url.prettyURL());
if (url.protocol() == "zip") {
bool stillInside = false;
if (KMimeType::findByPath(url.url(-1))
->is("application/x-zip")) {
stillInside = true;
}
else {
KURL url1 = url.upURL();
while (url1 != url1.upURL()) {
if (KMimeType::findByPath(url1.url(-1))
->is("application/x-zip")) {
stillInside = true;
break;
}
url1 = url1.upURL();
}
}
if (!stillInside)
{
// Drop the zip:/ protocol since we are not in the zip anymore
urlStr = url.path();
}
}
else if (url.protocol() == "tar")
{
bool stillInside = false;
KMimeType::Ptr kmp =
KMimeType::findByPath(url.url(-1));
if (kmp->is("application/x-tar") ||
kmp->is("application/x-tarz") ||
kmp->is("application/x-tbz") ||
kmp->is("application/x-tgz") ||
kmp->is("application/x-tzo")
) {
stillInside = true;
}
else {
KURL url1 = url.upURL();
while (url1 != url1.upURL()) {
KMimeType::Ptr kmp =
KMimeType::findByPath(url1.url(-1));
if (kmp->is("application/x-tar") ||
kmp->is("application/x-tarz") ||
kmp->is("application/x-tbz") ||
kmp->is("application/x-tgz") ||
kmp->is("application/x-tzo")
) {
stillInside = true;
break;
}
url1 = url1.upURL();
}
}
if (!stillInside)
{
// Drop the tar:/ protocol since we are not in the tar anymore
urlStr = url.path();
}
}
if (urlStr.at(0) == '~') {
// replace '~' by the home directory
urlStr.remove(0, 1);
urlStr.insert(0, QDir::home().path());
}
const KURL transformedURL(urlStr);
if (m_historyIndex > 0) {
// Check whether the previous element of the history has the same URL.
// If yes, just go forward instead of inserting a duplicate history
// element.
const KURL& nextURL = m_history[m_historyIndex - 1].url();
if (transformedURL == nextURL) {
goForward();
return;
}
}
const KURL& currURL = m_history[m_historyIndex].url();
if (currURL == transformedURL) {
// don't insert duplicate history elements
return;
}
updateHistoryElem();
const QValueListIterator<URLNavigator::HistoryElem> it = m_history.at(m_historyIndex);
m_history.insert(it, HistoryElem(transformedURL));
updateContent();
emit urlChanged(transformedURL);
emit historyChanged();
// Prevent an endless growing of the history: remembering
// the last 100 URLs should be enough...
if (m_historyIndex > 100) {
m_history.erase(m_history.begin());
--m_historyIndex;
}
}
/*******MOVEMENT**********/
void front()
{
goForward();
cost++;
//..printf("Front\n");
}
void NBFolderView::createAndSetupActions() {
connect( IconView, SIGNAL( peek( QModelIndex ) ), this, SLOT( doPeek( QModelIndex ) ) );
connect( IconView, SIGNAL( open( QModelIndex ) ), this, SLOT( doOpen( QModelIndex ) ) );
connect( IconView, SIGNAL( open( QString ) ), this, SLOT( doOpen( QString ) ) );
connect( IconView, SIGNAL( contextMenuRequested( QPoint ) ), this, SLOT( showContextMenu( QPoint ) ) );
connect( IconView, SIGNAL( actionsMenuRequested( QPoint ) ), this, SLOT( showActionsMenu( QPoint ) ) );
connect(
IconView->selectionModel(), SIGNAL( selectionChanged( const QItemSelection&, const QItemSelection& ) ),
this, SIGNAL( selectionChanged( const QItemSelection&, const QItemSelection& ) )
);
connect( IconView->selectionModel(), SIGNAL( selectionChanged( const QItemSelection&, const QItemSelection& ) ), this, SLOT( updateActions() ) );
connect( IconView, SIGNAL( link( QStringList, QString ) ), this, SLOT( link( QStringList, QString ) ) );
// DragDrop copy
connect( IconView, SIGNAL( copy( QStringList, QString ) ), this, SLOT( copy( QStringList, QString ) ) );
// DragDrop move
connect( IconView, SIGNAL( move( QStringList, QString ) ), this, SLOT( move( QStringList, QString ) ) );
// Update actions once the directory is loaded
connect( fsModel, SIGNAL( directoryLoaded( QString ) ), this, SLOT( updateActions() ) );
// Peek
peekAct = new QAction( QIcon( ":/icons/peek.png" ), "Pee&k", this );
peekAct->setShortcuts( Settings->shortcuts( "Peek" ) );
connect( peekAct, SIGNAL( triggered() ), this, SLOT( doPeek() ) );
addAction( peekAct );
// Home Dir
actHomeDir = new QAction( QIcon( ":/icons/home.png" ), "&Home", this );
actHomeDir->setShortcuts( Settings->shortcuts( "GoHome" ) );
connect( actHomeDir, SIGNAL( triggered() ), this, SLOT( loadHomeDir() ) );
addAction( actHomeDir );
// Home
actGoHome = new QAction( QIcon( ":/icons/home.png" ), "&Home", this );
actGoHome->setShortcut( tr( "Alt+Shift+Home" ) );
connect( actGoHome, SIGNAL( triggered() ), this, SLOT( doOpenHome() ) );
addAction( actGoHome );
// Up
actParDir = new QAction( QIcon( ":/icons/up.png" ), "&Up", this );
actParDir->setShortcuts( Settings->shortcuts( "GoUp" ) );
connect( actParDir, SIGNAL( triggered() ), fsModel, SLOT( goUp() ) );
addAction( actParDir );
// Back
actPrevDir = new QAction( QIcon( ":/icons/prev.png" ), "&Back", this );
actPrevDir->setShortcuts( Settings->shortcuts( "GoLeft" ) );
connect( actPrevDir, SIGNAL( triggered() ), fsModel, SLOT( goBack() ) );
addAction( actPrevDir );
// Forward
actNextDir = new QAction( QIcon( ":/icons/next.png" ), "&Forward", this );
actNextDir->setShortcuts( Settings->shortcuts( "GoRight" ) );
connect( actNextDir, SIGNAL( triggered() ), fsModel, SLOT( goForward() ) );
addAction( actNextDir );
// New Folder
actNewDir = new QAction( QIcon::fromTheme( "folder-new" ), "New folder", this );
actNewDir->setShortcuts( Settings->shortcuts( "NewFolder" ) );
connect( actNewDir, SIGNAL( triggered() ), this, SLOT( newFolder() ) );
addAction( actNewDir );
// New file
actNewFile = new QAction( QIcon::fromTheme( "document-new" ), "New File", this );
actNewFile->setShortcuts( Settings->shortcuts( "NewFile" ) );
connect( actNewFile, SIGNAL( triggered() ), this, SLOT( newFile() ) );
addAction( actNewFile );
// New file
actNewEncFS = new QAction( QIcon::fromTheme( "document-new" ), "New Encrypted Directory", this );
actNewEncFS->setShortcuts( Settings->shortcuts( "NewEncFS" ) );
connect( actNewEncFS, SIGNAL( triggered() ), this, SLOT( createEncFS() ) );
addAction( actNewEncFS );
// Copy
copyAct = new QAction( QIcon( ":/icons/copy.png" ), "&Copy", this );
copyAct->setShortcuts( Settings->shortcuts( "Copy" ) );
connect( copyAct, SIGNAL( triggered() ), this, SLOT( prepareCopy() ) );
addAction( copyAct );
// Move
moveAct = new QAction( QIcon( ":/icons/cut.png" ), "Cu&t", this );
moveAct->setShortcuts( Settings->shortcuts( "Cut" ) );
connect( moveAct, SIGNAL( triggered() ), this, SLOT( prepareMove() ) );
addAction( moveAct );
// Paste
pasteAct = new QAction( QIcon( ":/icons/paste.png" ), "&Paste", this );
pasteAct->setShortcuts( Settings->shortcuts( "Paste" ) );
connect( pasteAct, SIGNAL( triggered() ), this, SLOT( prepareIO() ) );
addAction( pasteAct );
// Rename
renameAct = new QAction( QIcon( ":/icons/rename.png" ), "&Rename", this );
renameAct->setShortcuts( Settings->shortcuts( "Rename" ) );
connect( renameAct, SIGNAL( triggered() ), this, SLOT( doRename() ) );
addAction( renameAct );
// Reload
reloadAct = new QAction( QIcon( ":/icons/reload.png" ), "Re&fresh", this );
reloadAct->setShortcuts( Settings->shortcuts( "Reload" ) );
connect( reloadAct, SIGNAL( triggered() ), this, SLOT( doReload() ) );
addAction( reloadAct );
// showDotFiles
showHideDotFiles = new QAction( QIcon( ":/icons/showDotFiles.png" ), "Show &Hidden", this );
showHideDotFiles->setShortcuts( Settings->shortcuts( "ToggleHidden" ) );
connect( showHideDotFiles, SIGNAL( triggered() ), this, SLOT( doToggleHidden() ) );
addAction( showHideDotFiles );
// Trash
trashAct = new QAction( QIcon( ":/icons/trash.png" ), "Move to trash", this );
trashAct->setShortcuts( Settings->shortcuts( "Trash" ) );
connect( trashAct, SIGNAL( triggered() ), this, SLOT( doSendToTrash() ) );
addAction( trashAct );
// Delete
delAct = new QAction( QIcon( ":/icons/delete.png" ), "Delete", this );
delAct->setShortcuts( Settings->shortcuts( "Delete" ) );
connect( delAct, SIGNAL( triggered() ), this, SLOT( doDelete() ) );
addAction( delAct );
// Properties
propertiesAct = new QAction( QIcon( ":/icons/props.png" ), "&Properties", this );
propertiesAct->setShortcuts( Settings->shortcuts( "Properties" ) );
connect( propertiesAct, SIGNAL( triggered() ), this, SIGNAL( showProperties() ) );
addAction( propertiesAct );
// Permissions
permissionsAct = new QAction( QIcon::fromTheme( "system-users" ), "P&ermissions", this );
permissionsAct->setShortcuts( Settings->shortcuts( "Permissions" ) );
connect( permissionsAct, SIGNAL( triggered() ), this, SIGNAL( showPermissions() ) );
addAction( permissionsAct );
// Open a virtual terminal emulator
openVTE = new QAction( QIcon::fromTheme( "utilities-terminal" ), "Open &VTE", this );
openVTE->setShortcuts( Settings->shortcuts( "Terminal" ) );
connect( openVTE, SIGNAL( triggered() ), this, SLOT( openTerminal() ) );
addAction( openVTE );
// Open a virtual terminal emulator
openVTEin = new QAction( QIcon::fromTheme( "utilities-terminal" ), "Open &VTE Here", this );
// openVTEin->setShortcuts( Settings->shortcuts( "Terminal" ) );
connect( openVTEin, SIGNAL( triggered() ), this, SLOT( openTerminalIn() ) );
// Select All
QAction *selectAllAct = new QAction( "&Select All", this );
selectAllAct->setShortcuts( Settings->shortcuts( "SelectAll" ) );
connect( selectAllAct, SIGNAL( triggered() ), this, SLOT( selectAll() ) );
addAction( selectAllAct );
// Sorting
sortByNameAct = new QAction( QIcon::fromTheme( "format-text-underline" ), "&Name", this );
sortByNameAct->setCheckable( true );
connect( sortByNameAct, SIGNAL( triggered() ), this, SLOT( sortByName() ) );
sortByTypeAct = new QAction( QIcon::fromTheme( "preferences-other" ), "&Type", this );
sortByTypeAct->setCheckable( true );
connect( sortByTypeAct, SIGNAL( triggered() ), this, SLOT( sortByType() ) );
sortBySizeAct = new QAction( QIcon( ":/icons/size.png" ), "&Size", this );
sortBySizeAct->setCheckable( true );
connect( sortBySizeAct, SIGNAL( triggered() ), this, SLOT( sortBySize() ) );
sortByDateAct = new QAction( QIcon::fromTheme( "office-calendar" ), "&Date", this );
sortByDateAct->setCheckable( true );
connect( sortByDateAct, SIGNAL( triggered() ), this, SLOT( sortByDate() ) );
QActionGroup *sortGroup = new QActionGroup( this );
sortGroup->addAction( sortByNameAct );
sortGroup->addAction( sortByTypeAct );
sortGroup->addAction( sortBySizeAct );
sortGroup->addAction( sortByDateAct );
switch( ( int )Settings->value( "SortColumn" ) ) {
case 0: {
sortByNameAct->setChecked( true );
break;
}
case 1: {
sortBySizeAct->setChecked( true );
break;
}
case 2: {
sortByTypeAct->setChecked( true );
break;
}
case 4: {
sortByDateAct->setChecked( true );
break;
}
}
groupsAct = new QAction( QIcon::fromTheme( "view-group", QIcon( ":/icons/groups.png" ) ), "Show in &Groups", this );
groupsAct->setCheckable( true );
groupsAct->setChecked( Settings->value( "Grouping" ) );
connect( groupsAct, SIGNAL( triggered() ), this, SIGNAL( toggleGroups() ) );
// Add bookmark
addBookMarkAct = new QAction( QIcon( ":/icons/bookmark.png" ), "Add &Bookmark", this );
addBookMarkAct->setShortcuts( Settings->shortcuts( "AddBookmark" ) );
connect( addBookMarkAct, SIGNAL( triggered() ), this, SLOT( addBookMark() ) );
addAction( addBookMarkAct );
/* Add to SuperStart */
addToSuperStartAct = new QAction( QIcon( ":/icons/superstart.png" ), "Add to S&uperStart", this );
addToSuperStartAct->setShortcut( tr( "Ctrl+U" ) );
connect( addToSuperStartAct, SIGNAL( triggered() ), this, SLOT( addToSuperStart() ) );
addAction( addToSuperStartAct );
updateActions();
};
int main(void) {
SYSTEMConfigPerformance(40000000); //System clock is 40MHz
//Because interrupts are good to have
enableInterrupts();
//Because ADC is good to have
initADC();
//Because a timer is good to have for PWM
initTimer2();
//Because PWM is good to have
initPWM();
// initMotorDirPins();
//Because the delayUs function is typically pretty good to have
initTimer4();
//Because UART is good to have for interfacing with our speech chip
initUART(40000000);
//Because a talking robot is the absolute best thing to have
//initSpeakJet();
initSevenSegment();
initSW();
int HelloBytes[] = {0, 0, 0, 0b01110110, 0b01111001, 0b00111000, 0b00111000, 0b00111111, 0, 0, 0};
int helloCounter = 2;
int myCounter = 0;
int timesInFwd = 0;
//sendSpeakjet(initByteArray);
while(1) {
if(millis >= 5000) //if it's been some seconds
{
millis = 0; //reset the timer
//tell speakjet to speak state here
sendSpeakjet(AllYour);
}
if(ScrollMillis >= 600)
{
ScrollMillis = 0;
helloCounter = ((helloCounter + 1) % 8);
sevenSeg_write(0, HelloBytes[WRAPPOS((helloCounter-3), 8)]);
sevenSeg_write(1, HelloBytes[WRAPPOS(helloCounter-2,8)]);
sevenSeg_write(2, HelloBytes[(helloCounter-1) % 8]);
sevenSeg_write(2, HelloBytes[WRAPPOS((helloCounter-1), 8)]);
sevenSeg_write(3, HelloBytes[(helloCounter)]);
}
switch(myState) {
case idle:
motorsOff();
break;
case init:
//Wait for a button press to start us up
motorsOff();
sendSpeakjet(BiteMy);
delayUs(3000000);
myState = backwards;
break;
case backwards:
timesInFwd = 0;
LeftMotor_Write(-800);
RightMotor_Write(-800);
if(leftPairReading < THRESHOLD && rightPairReading < THRESHOLD)
myState = pivot_right;
else if (rightPairReading < THRESHOLD)
myState = turnL_back;
else if (leftPairReading < THRESHOLD)
myState = turnR_back;
else
myState = backwards;
break;
case turnR_back:
turnRight_back(73); //makes the LEFT motor turn at near full power. Yes, it IS the left motor and not the right one.
turnLeft_back(300);
sampleIRPairs(&leftPairReading, &rightPairReading, 10);
// myState = (rightPairReading >= THRESHOLD) ? forward : turnR;
if (leftPairReading < THRESHOLD && rightPairReading < THRESHOLD) //both dark
myState = pivot_right;
else if (rightPairReading < THRESHOLD)
myState = turnR_back;
else if (leftPairReading < THRESHOLD)
myState = turnL_back;
else
myState = backwards;
break;
case turnL_back:
turnRight_back(300); //makes the LEFT motor turn at near full power. Yes, it IS the left motor and not the right one.
turnLeft_back(73);
sampleIRPairs(&leftPairReading, &rightPairReading, 10);
// myState = (rightPairReading >= THRESHOLD) ? forward : turnR;
if (leftPairReading < THRESHOLD && rightPairReading < THRESHOLD) //both dark
myState = pivot_right;
else if (rightPairReading < THRESHOLD)
myState = turnR_back;
else if (leftPairReading < THRESHOLD)
myState = turnL_back;
else
myState = backwards;
break;
case pivot_right:
// if(leftPairReading >= THRESHOLD) //left is light
// myState = forward;
// break;
RightMotor_Write(-650);
LeftMotor_Write(700);
if(rightPairReading > THRESHOLD)
myState = forward;
break;
case turnR:
// turnRight(512);
turnRight(73); //makes the LEFT motor turn at near full power. Yes, it IS the left motor and not the right one.
turnLeft(800);
sampleIRPairs(&leftPairReading, &rightPairReading, 10);
// myState = (rightPairReading >= THRESHOLD) ? forward : turnR;
if (leftPairReading < THRESHOLD && rightPairReading < THRESHOLD) //both dark
myState = turnR;
else if (rightPairReading < THRESHOLD)
myState = turnR;
else if (leftPairReading < THRESHOLD)
myState = turnL;
else
myState = forward;
break;
case turnL:
// turnLeft(512);
turnLeft(73); //makes RIGHT motor run at near full power. Yes, it IS the right motor, not the left one.
turnRight(800);
sampleIRPairs(&leftPairReading, &rightPairReading, 10);
// myState = (leftPairReading >= THRESHOLD) ? forward : turnL;
if (leftPairReading < THRESHOLD && rightPairReading < THRESHOLD)
myState = turnR;
else if (rightPairReading < THRESHOLD)
myState = turnR;
else if (leftPairReading < THRESHOLD)
myState = turnL;
else
myState = forward;
break;
case forward:
if(timesInFwd >= 25000)
{
sendSpeakjet(finishedPhrase);
myState = backwards;
// myState = idle;
break;
}
timesInFwd++;
goForward();
sampleIRPairs(&leftPairReading, &rightPairReading, 100);
if (rightPairReading < THRESHOLD) {
myState = turnR;
timesInFwd = 0;
}
else if (leftPairReading < THRESHOLD) {
myState = turnL;
timesInFwd = 0;
}
break;
}
}
return (EXIT_SUCCESS);
}
geometry_msgs::PoseStamped getNextWaypoint(const sensor_msgs::PointCloud& pointCloud){
geometry_msgs::PoseStamped lcl_position;//our next waypoint in navigating from our initial position to the global goal position.
bool left_occupied = false, right_occupied = false, front_occupied = false, self_occupied = false, left_front_occupied = false, right_front_occupied = false;//occupancy grid Booleans.
float currPoseX = current_position.pose.position.x;//absolute x-position of laser.
float currPoseY = current_position.pose.position.y;//aboslute y-position of laser.
float currPoseYaw = 2*asin(current_position.pose.orientation.z); //transform absolute laser yaw from quaternion to radians
float currPointXabs, currPointYabs;//absolute x and y position of current point in pointcloud.
timestamp = current_position.header.stamp.sec;
//(START A)------------------------------
// Determine whether adjacent block to left, right, right-front, left-front, and front of laser are occupied. Change occupancy grid size with "navigation_resolution_" global variable.
for(int i = 0; i<pointCloud.points.size(); i++){//iterate through all points in pointcloud.
const geometry_msgs::Point32& currPoint(pointCloud.points[i]);//get current point in pointcloud.
//calculate absolute position of current point by offsetting it relative to the absolute position of the laser.
currPointXabs = currPoint.x + currPoseX;
currPointYabs = currPoint.y + currPoseY;
int j = pointCloud.points.size();
const geometry_msgs::Point32& right(pointCloud.points[0]);
const geometry_msgs::Point32& front(pointCloud.points[j/2]);
const geometry_msgs::Point32& left(pointCloud.points[j-5]);
rcl = -right.y;
fcl = front.x;
lcl = left.y;
clearance.pose.position.x = rcl;
clearance.pose.position.y = fcl;
clearance.pose.position.z = lcl;
pub_clearance.publish(clearance);
//determine our occupancy grid relative to the laser based on Cartesian pointcloud data. The coefficient in front of "navigation_resolution_" sets the bounds of how much of the block to check in. E.g. "1.5*navigation_resolution_" is "one and a half occupancy grid blocks".
if(currPointYabs < (currPoseY + gcupper*navigation_resolution_y) && currPointYabs > (currPoseY + gclower*navigation_resolution_y) && currPointXabs > (currPoseX - gclower*navigation_resolution_x) && currPointXabs < (currPoseX + gclower*navigation_resolution_x)){
left_occupied = true;
}
if(currPointYabs < (currPoseY + gcupper*navigation_resolution_y) && currPointYabs > (currPoseY + gclower*navigation_resolution_y) && currPointXabs > (currPoseX + gclower*navigation_resolution_x) && currPointXabs < (currPoseX + gcupper*navigation_resolution_x)){
left_front_occupied = true;
}
if(currPointYabs < (currPoseY - gclower*navigation_resolution_y) && currPointYabs > (currPoseY - gcupper*navigation_resolution_y) && currPointXabs > (currPoseX - gclower*navigation_resolution_x) && currPointXabs < (currPoseX + gclower*navigation_resolution_x)){
right_occupied = true;
}
if(currPointYabs < (currPoseY - gclower*navigation_resolution_y) && currPointYabs > (currPoseY - gcupper*navigation_resolution_y) && currPointXabs > (currPoseX + gclower*navigation_resolution_x) && currPointXabs < (currPoseX + gcupper*navigation_resolution_x)){
right_front_occupied = true;
}
if(currPointYabs < (currPoseY + gclower*navigation_resolution_y) && currPointYabs > (currPoseY - gclower*navigation_resolution_y) && currPointXabs > (currPoseX + gclower*navigation_resolution_x) && currPointXabs < (currPoseX + gcupper*navigation_resolution_x)){
front_occupied = true;
}
if(currPointYabs < (currPoseY + gclower*navigation_resolution_y) && currPointYabs > (currPoseY - gclower*navigation_resolution_y) && currPointXabs > (currPoseX - gclower*navigation_resolution_x) && currPointXabs < (currPoseX + gclower*navigation_resolution_x)){
self_occupied = true;
}
}
//DEBUG. Use this block to check how previous for-loop is building the local occupancy grid.
std_msgs::String msg;
std::stringstream ss;
// ss << "left: " << left_occupied;
// ss << ", left-front: " << left_front_occupied;
// ss << ", right: " << right_occupied;
// ss << ", right-front: " << right_front_occupied;
// ss << ", front: " << front_occupied;
// ss << ", self: " << self_occupied;
// ss << ", CurrYaw: " << currPoseYaw*(180/3.14);
//\DEBUG
//(END A)------------------------------
//(START B)------------------------------
// Determine angular bearing from current position to global goal position.
double global_goal_bearing = getGlobalGoalBearing(currPoseX, currPoseY);
//(END B)--------------------------------
/*
//(Algorithm LHS)-------------------------------------------------------------------------------LEFT WALL FOLLOWING BEGINS---------------------------------------------------------------------------------------------
if (flagTR == 0)
{
if ((currPoseY < leftgo) && (flag1 == 0)){
//go left
ss << ", go left";
lcl_position = goLeft(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
//ss << ", YawDot: ";
//ss << yawdot*(180/3.14);
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if (currPoseY >= leftgo)
{
flag1 = 1;
}
if ((!front_occupied) && (flag1 == 1) && (flag2 == 0) && (flag3 == 0))
{
//go forward
ss << ", go forward";
lcl_position = goForward(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
//ss << ", YawDot: ";
//ss << yawdot*(180/3.14);
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if ((front_occupied) && (flag1 == 1))
{
flag2 = 1;
}
if ((flag1 == 1) && (flag2 == 1) && (currPoseY > 0.9)){
//go right
ss << ", go right";
lcl_position = goRight(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
//ss << ", YawDot: ";
//ss << yawdot*(180/3.14);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if ((!front_occupied) && (flag1 == 1) && (flag2 == 1))
{
flag3 = 1;
}
if ((flag1 == 1) && (flag2 == 1) && (flag3 == 1) && (currPoseY > -0.9) && (currPoseY < 0.9))
{
//go forward
ss << ", go forward";
lcl_position = goForward(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
//ss << ", YawDot: ";
//ss << yawdot*(180/3.14);
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if (currPoseX >= tr)
{//reached target room
flagTR = 1;
}
}
//(END Algorithm LHS)---------------------------------------------------------------------------------LEFT WALL FOLLOWING ENDS----------------------------------------------------------------------------------------------------
*/
//(Algorithm RHS)-------------------------------------------------------------------------------RIGHT WALL FOLLOWING BEGINS---------------------------------------------------------------------------------------------
if (flagTR == 0)
{
if ((rcl > 1.8) && (flag1 == 0)){
//go right
ss << ", go right";
lcl_position = goRight(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if (rcl <= 1.8)
{
flag1 = 1;
}
if ((!front_occupied) && (flag1 == 1) && (flag2 == 0) && (flag3 == 0))
{
//go forward
ss << ", go forward";
lcl_position = goForward(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if ((front_occupied) && (flag1 == 1))
{
flag2 = 1;
}
if ((flag1 == 1) && (flag2 == 1) && (currPoseY < openingYlow+0.3)){
//go left
ss << ", go left";
lcl_position = goLeft(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if ((!front_occupied) && (flag1 == 1) && (flag2 == 1) && (currPoseY >= openingYlow+0.3))
{
flag3 = 1;
}
if (((!front_occupied) && (flag1 == 1) && (flag2 == 1) && (flag3 == 1)) && (currPoseY < openingYhigh-0.3))
{
//go forward
ss << ", go forward";
lcl_position = goForward(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if (currPoseX >= tr)
{
//reached target room
flagTR = 1;
}
}
//(END Algorithm RHS)-------------------------------------------------------------------------------RIGHT WALL FOLLOWING ENDS-------------------------------------------------------------------------------------------
/*
//(Algorithm FRONT)-------------------------------------------------------------------------------STRAIGHT FORWARD BEGINS---------------------------------------------------------------------------------------------
if (flagTR == 0)
{
if ((!front_occupied) && (flag1 == 0) && (flag2 == 0) && (flag3 == 0))
{
//go forward
ss << ", go forward";
lcl_position = goForward(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if (front_occupied)
{
flag1 = 1;
}
if ((flag1 == 1) && (flag2 == 0) && (flag3 == 0) && (currPoseY > -(brc+1.5)))
{
//go right
ss << ", go right";
lcl_position = goRight(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if ((currPoseY <= -(brc+1.5)) && (!front_occupied) && (flag1 == 1))
{
flag2 = 1;
}
if ((currPoseY <= -(brc+1.5)) && (flag1 == 1) && (flag2 == 1) && (flag3 == 0))
{
//go forward
ss << ", go forward";
lcl_position = goForward(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if ((front_occupied) && (flag1 == 1) && (flag2 == 1))
{
flag3 = 1;
}
if ((flag1 == 1) && (flag2 == 1) && (flag3 == 1) && (currPoseY < -0.9)){
//go left
ss << ", go left";
lcl_position = goLeft(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if ((!front_occupied) && (flag1 == 1) && (flag2 == 1) && (flag3 == 1) && (currPoseY >= -0.9) && (currPoseY <= 0.9))
{
//go forward
ss << ", go forward";
lcl_position = goForward(currPoseX, currPoseY, currPoseYaw);
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
if (currPoseX >= tr)
{//reached target room
flagTR = 1;
}
}
//(END Algorithm FRONT)-------------------------------------------------------------------------------STRAIGHT FORWARD ENDS-------------------------------------------------------------------------------------------
*/
// (SWITCH TO TARGET ESTIMATION)
if (flagTR == 1)
{
lcl_position.pose.position.x = nxtX;
lcl_position.pose.position.y = nxtY;
lcl_position.pose.orientation.z = nxtYaw;
xdot = (currPoseX - x_prev)/dt;
ydot = (currPoseY - y_prev)/dt;
yawdot = (currPoseYaw - yaw_prev)/dt;
wp_x_dot = (lcl_position.pose.position.x - last_wp_x)/dt;
wp_y_dot = (lcl_position.pose.position.y - last_wp_y)/dt;
wp_yaw_dot = (lcl_position.pose.orientation.z - last_wp_yaw)/dt;
if (wp_x_dot > xddlim)
{
wp_x_dot = xddlim;
}
else if (wp_x_dot < -xddlim)
{
wp_x_dot = -xddlim;
}
if (wp_y_dot > yddlim)
{
wp_y_dot = yddlim;
}
else if (wp_y_dot < -yddlim)
{
wp_y_dot = -yddlim;
}
th_des = kp_theta*(lcl_position.pose.position.y - currPoseY) + kd_theta*(wp_y_dot - ydot); // roll
phi_des = kp_phi*(lcl_position.pose.position.x - currPoseX) + kd_phi*(wp_x_dot - xdot); // pitch
yaw_des = kp_psi*(lcl_position.pose.orientation.z - currPoseYaw) + kd_psi*(wp_yaw_dot - yawdot); // yaw
if (phi_des > 10)
{
phi_des = 10;
}
else if (phi_des < -10)
{
phi_des = -10;
}
if (th_des > 10)
{
th_des = 10;
}
else if (th_des < -10)
{
th_des = -10;
}
if (yaw_des > 15)
{
yaw_des = 15;
}
else if (yaw_des < -15)
{
yaw_des = -15;
}
del_phi = 62 - phi_des;
del_th = 70 - th_des;
del_yaw = 64 - yaw_des;
ss << " Roll: ";
ss << del_th;
ss << ", Pitch: ";
ss << del_phi;
ss << ", Yaw: ";
ss << del_yaw;
address_p = 0x84;
value_p = int (del_phi);
send_cmd(address_p,value_p);
address_r = 0x85;
value_r = int (del_th);
send_cmd(address_r,value_r);
address_y = 0x83;
value_y = int (del_yaw);
send_cmd(address_y,value_y);
}
//DEBUG
msg.data = ss.str();
ROS_INFO("%s", msg.data.c_str());
//\DEBUG
x_prev = currPoseX;
y_prev = currPoseY;
yaw_prev = currPoseYaw;
last_wp_x = lcl_position.pose.position.x;
last_wp_y = lcl_position.pose.position.y;
last_wp_yaw = lcl_position.pose.orientation.z;
return lcl_position;
}
void main(void)
{
init();
STOP();
lcd_set_cursor(0x00);
lcd_write_string("(-,-) - -- --- -"); //x/y of robot, explore/return, zone of victim/got victim, walls, way went
lcd_set_cursor(0x40);
lcd_write_string("- - - (3,1) GREG"); //orientation, cliff detected, v.wall detected, x/y of final destination
char victimIndicator = 0;
while(!home)
{
if(start.pressed && ready == FALSE)
{
findWalls();
if(leftWall && rightWall && frontWall) //if facing east
turnAround(); //turn to face west
else if (rightWall && frontWall) //if facing north
turnLeft90(); //turn to face west
else if(leftWall && frontWall) //if facing south
turnRight90(); //turn to face west
ready = TRUE; //commence exploring the map
lcd_set_cursor(0x06);
lcd_write_data('E'); //Explore mode
play_iCreate_song(1);
}
//EEPROM Serial Transfer
if(eepromSerial.pressed && ready == FALSE)
{
eepromSerial.pressed = FALSE;
lcd_set_cursor(0x00);
lcd_write_string("EEPROM Serial ");
lcd_set_cursor(0x40);
lcd_write_string("Please Wait... ");
writeEEPROMTestData();
EEPROMToSerial();
lcd_set_cursor(0x40);
lcd_write_string("Complete ");
}
if(start.pressed)
{
ready = TRUE;
checkForFinalDestination();
lookForVictim();
findWalls();
play_iCreate_song(5);
if(leftWall)
{
rotateIR(24,CCW);
leftAngleCorrect();
rotateIR(24,CW);
}
play_iCreate_song(5);
if(frontWall)
frontWallCorrect();
play_iCreate_song(5);
switch(node) // Gives the Create specific movement instructions for certain squares to go shortest path home and collecting the victim
{
case 0:
goToNextCell();
break;
case 1:
if (goingHome)
{
if (victimZone == 1)
goRight();
else if (getOrientation() == EAST)
goForward();
else if (getOrientation() == SOUTH)
goRight();
else
goToNextCell();
}
else
goToNextCell();
break;
case 2:
if (goingHome)
{
if (victimZone == 2)
goForward();
else if (getOrientation() == SOUTH)
goRight();
else if (getOrientation() == NORTH)
goLeft();
else
goToNextCell();
}
else
goToNextCell();
break;
case 3:
if (goingHome)
{
if (victimZone == 3)
goRight();
else if (getOrientation() == EAST)
goForward();
else if (getOrientation() == SOUTH)
goLeft();
else
goToNextCell();
}
else
goToNextCell();
break;
case 4:
if (getOrientation() == EAST)
goRight();
else
goToNextCell();
break;
case 5:
if (getOrientation() == NORTH)
goRight();
else
goToNextCell();
break;
case 6:
if (getOrientation() == WEST)
{
play_iCreate_song(6);
goForward();
}
else
goToNextCell();
break;
default:
break;
}
play_iCreate_song(5);
if(getSuccessfulDrive())
{
//Send EEPROM data for current cell
if(xVictim == xCoord && yVictim == yCoord)
{
victimIndicator = 1;
}
/*if(xVirtual == xCoord && yVirtual == yCoord)
{
switch(dVirtual)
{
case WEST:
{
updateMapData(1,0,0,0,victimIndicator,getOrientation());
break;
}
case SOUTH:
{
updateMapData(0,1,0,0,victimIndicator,getOrientation());
break;
}
case EAST:
{
updateMapData(0,0,1,0,victimIndicator,getOrientation());
break;
}
case NORTH:
{
updateMapData(0,0,0,1,victimIndicator,getOrientation());
break;
}
default:
updateMapData(0,0,0,0,victimIndicator,getOrientation());
}
}*/
updateMapData(0,0,0,0,victimIndicator,getOrientation());
victimIndicator = 0;
updateLocation();
updateNode();
if(goingHome)
checkIfHome();
}
}
}
}
void MediaBrowser::setupUI()
{
QVBoxLayout *vbox0 = new QVBoxLayout(this);
m_splitter = new QSplitter(this);
m_splitter->setOrientation(Qt::Vertical);
vbox0->addWidget(m_splitter);
QWidget *browser = new QWidget(m_splitter);
QVBoxLayout *vbox = new QVBoxLayout(browser);
SET_MARGIN(vbox,0);
// Setup filter box at the top of the widget
m_searchBase = new QWidget(browser);
QHBoxLayout *hbox = new QHBoxLayout(m_searchBase);
SET_MARGIN(hbox,0);
m_btnBack = new QPushButton(QIcon(":/data/stock-go-back.png"),"");
m_btnBack->setEnabled(false);
connect(m_btnBack, SIGNAL(clicked()), this, SLOT(goBack()));
m_btnForward = new QPushButton(QIcon(":/data/stock-go-forward.png"),"");
m_btnForward->setEnabled(false);
connect(m_btnForward, SIGNAL(clicked()), this, SLOT(goForward()));
m_btnUp = new QPushButton(QIcon(":/data/stock-go-up.png"),"");
m_btnUp->setEnabled(false);
connect(m_btnUp, SIGNAL(clicked()), this, SLOT(goUp()));
QLabel *label = new QLabel("Fil&ter:");
m_searchBox = new QLineEdit(m_searchBase);
label->setBuddy(m_searchBox);
m_clearSearchBtn = new QPushButton(QIcon(":/data/stock-clear.png"),"");
m_clearSearchBtn->setVisible(false);
hbox->addWidget(m_btnBack);
hbox->addWidget(m_btnForward);
hbox->addWidget(m_btnUp);
hbox->addWidget(label);
hbox->addWidget(m_searchBox);
hbox->addWidget(m_clearSearchBtn);
connect(m_searchBox, SIGNAL(textChanged(const QString &)), this, SLOT(filterChanged(const QString &)));
connect(m_searchBox, SIGNAL(returnPressed()), this, SLOT(filterReturnPressed()));
connect(m_clearSearchBtn, SIGNAL(clicked()), this, SLOT(clearFilter()));
// Now for the list itself
m_listView = new MediaBrowserQListView(browser);
m_listView->setAlternatingRowColors(true);
m_listView->setIconSize(m_iconSize);
//m_listView->setWrapping(true);
m_listView->setWordWrap(true);
//m_listView->setGridSize(MEDIABROWSER_LIST_ICON_SIZE);
m_listView->setLayoutMode(QListView::Batched);
//m_listView->setFlow(QListView::LeftToRight);
m_listView->setResizeMode(QListView::Adjust);
//m_listView->setSelectionMode(QAbstractItemView::SingleSelection);
// below doesnt seem to be enough
//m_listView->setEditTriggers(QAbstractItemView::SelectedClicked | QAbstractItemView::EditKeyPressed);
m_fsModel = new DirectoryListModel(browser); //QFileSystemModel(browser);
m_fsModel->setIconProvider(new MyQFileIconProvider());
//m_fsModel->setNameFilterDisables(false);
m_listView->setModel(m_fsModel);
connect(m_listView, SIGNAL(doubleClicked(const QModelIndex &)), this, SLOT(indexDoubleClicked(const QModelIndex &)));
connect(m_listView, SIGNAL(activated(const QModelIndex &)), this, SLOT(indexDoubleClicked(const QModelIndex &)));
connect(m_listView, SIGNAL(clicked(const QModelIndex &)), this, SLOT(indexSingleClicked(const QModelIndex &)));
////////////////////////
// Add action buttons
m_btnBase = new QWidget(browser);
QHBoxLayout *hbox3 = new QHBoxLayout(m_btnBase);
SET_MARGIN(hbox3,0);
m_btnSetAsBgLive = new QPushButton(QIcon(":/data/stock-apply-ffwd.png"),"");
m_btnSetAsBgLive->setToolTip("Set selected file as background for the current live slide");
hbox3->addWidget(m_btnSetAsBgLive);
m_btnAddToSchedue = new QPushButton(QIcon(":/data/stock-add.png"),"");
m_btnAddToSchedue->setToolTip("Add selected file to schedule");
hbox3->addWidget(m_btnAddToSchedue);
m_btnSetAsBgLater = new QPushButton(QIcon(":/data/stock-apply-next.png"),"");
m_btnSetAsBgLater->setToolTip("Set selected file as background for the NEXT slide to go live");
hbox3->addWidget(m_btnSetAsBgLater);
m_btnSetAsBgCurrent = new QPushButton(QIcon(":/data/stock-apply-pause.png"),"");
m_btnSetAsBgCurrent->setToolTip("Set selected file as background for the selected slide group");
hbox3->addWidget(m_btnSetAsBgCurrent);
connect(m_btnAddToSchedue, SIGNAL(clicked()), this, SLOT(slotAddToSchedule()));
connect(m_btnSetAsBgCurrent, SIGNAL(clicked()), this, SLOT(slotSetAsBgCurrent()));
connect(m_btnSetAsBgLater, SIGNAL(clicked()), this, SLOT(slotSetAsBgLater()));
connect(m_btnSetAsBgLive, SIGNAL(clicked()), this, SLOT(slotSetAsBgLive()));
// enabled by indexSingleClicked()
m_btnBase->setEnabled(false);
/////////////////
// Add the directory box and filter box at bottom
m_folderBoxBase = new QWidget(browser);
QHBoxLayout *hbox2 = new QHBoxLayout(m_folderBoxBase);
SET_MARGIN(hbox2,0);
hbox2->addWidget(new QLabel("Folder:"));
m_dirBox = new QLineEdit(m_folderBoxBase);
hbox2->addWidget(m_dirBox);
m_filterBox = new QComboBox(m_folderBoxBase);
hbox2->addWidget(m_filterBox);
connect(m_dirBox, SIGNAL(returnPressed()), this, SLOT(dirBoxReturnPressed()));
connect(m_filterBox, SIGNAL(currentIndexChanged(int)), this, SLOT(fileTypeChanged(int)));
//#######################################333
m_bookmarkBase = new QWidget(browser);
QHBoxLayout *hbox4 = new QHBoxLayout(m_bookmarkBase);
SET_MARGIN(hbox4,0);
hbox4->addWidget(new QLabel("Saved:"));
m_bookmarkBox = new QComboBox(m_bookmarkBase);
hbox4->addWidget(m_bookmarkBox,2);
m_btnBookmark = new QPushButton(QIcon(":/data/stock-new.png"),"");
m_btnBookmark->setToolTip("Bookmark current folder");
hbox4->addWidget(m_btnBookmark);
m_btnDelBookmark = new QPushButton(QIcon(":/data/stock-remove.png"),"");
m_btnDelBookmark->setToolTip("Delete current bookmark");
hbox4->addWidget(m_btnDelBookmark);
connect(m_bookmarkBox, SIGNAL(activated(int)), this, SLOT(loadBookmarkIndex(int)));
connect(m_btnBookmark, SIGNAL(clicked()), this, SLOT(slotBookmarkFolder()));
connect(m_btnDelBookmark, SIGNAL(clicked()), this, SLOT(slotDelBookmark()));
//#######################################333
QFrame * line = new QFrame();
line->setFrameShape(QFrame::HLine);
line->setFrameShadow(QFrame::Sunken);
vbox->addWidget(m_searchBase);
vbox->addWidget(m_folderBoxBase);
vbox->addWidget(line);
vbox->addWidget(m_bookmarkBase);
vbox->addWidget(m_listView);
vbox->addWidget(m_btnBase);
m_splitter->addWidget(browser);
m_viewerBase = new QWidget(m_splitter);
m_viewerLayout = new QVBoxLayout(m_viewerBase);
m_viewerLayout->setContentsMargins(0,0,0,0);
// Setup the slide group viewer
m_viewer = new SlideGroupViewer(m_viewerBase);
m_viewer->setCanZoom(true);
m_viewer->setSceneContextHint(MyGraphicsScene::Preview);
m_viewer->setBackground(Qt::black);
// Create the slide and slide group that we'll reuse to preview the
// selected media items
Slide * slide = new Slide();
AbstractVisualItem * bg = dynamic_cast<AbstractVisualItem*>(slide->background());
bg->setFillType(AbstractVisualItem::Solid);
bg->setFillBrush(Qt::black);
SlideGroup *group = new SlideGroup();
group->addSlide(slide);
//qDebug() << "MediaBrowser::setupUI(): Setting slidegroup "<<group<<" on viewer "<<m_viewer;
m_viewer->setSlideGroup(group, slide);
m_viewerLayout->addWidget(m_viewer);
m_splitter->addWidget(m_viewerBase);
loadBookmarks();
}
/*MAIN*/
int main()
{
//Declarations
int i, j;
int targets;
int center, error, most_blob;
int num_balls = 5;
int dist, prev;
int n = 0;
//Set up GPIO
gpio_export(POWER_LED_PIN);
gpio_set_dir(POWER_LED_PIN, OUTPUT_PIN);
gpio_export(CAMERA_LED_PIN);
gpio_set_dir(CAMERA_LED_PIN, OUTPUT_PIN);
gpio_export(BUTTON_PIN);
gpio_set_dir(BUTTON_PIN, INPUT_PIN);
gpio_export(RELOAD_LED_PIN);
gpio_set_dir(RELOAD_LED_PIN, OUTPUT_PIN);
gpio_export(ARDUINO_PIN);
gpio_set_dir(ARDUINO_PIN, OUTPUT_PIN);
gpio_set_value(ARDUINO_PIN, LOW);
//Set up PWM
initPWM();
usleep(microsecondsToMilliseconds(500));
//Dropper
setPeriod(DROPPER_MOTOR_INDEX, PWM_PERIOD);
setDuty(DROPPER_MOTOR_INDEX, percentageToDuty(DROPPER_DOWN_POSITION));
setRun(DROPPER_MOTOR_INDEX, 1);
//Grabber
setPeriod(GRABBER_MOTOR_INDEX, PWM_PERIOD);
setDuty(GRABBER_MOTOR_INDEX, GRABBER_UP_POSITION);
setRun(GRABBER_MOTOR_INDEX, 1);
//Right wheel
setPeriod(RIGHT_WHEEL_INDEX, PWM_PERIOD);
setDuty(RIGHT_WHEEL_INDEX, NEUTRAL_DUTY);
setRun(RIGHT_WHEEL_INDEX, 0);
//Left wheel
setPeriod(LEFT_WHEEL_INDEX, PWM_PERIOD);
setDuty(LEFT_WHEEL_INDEX, NEUTRAL_DUTY);
setRun(LEFT_WHEEL_INDEX, 0);
//Roller
setRun(ROLLER_MOTOR_INDEX, 0);
setPeriod(ROLLER_MOTOR_INDEX, PWM_PERIOD);
setDuty(ROLLER_MOTOR_INDEX, PWM_PERIOD*ROLLER_SPEED);
//Set up serial
serial* arduinoSerial;
if (serial_open(&arduinoSerial, ARDUINO_SERIAL_PORT, ARDUINO_BAUD_RATE) == 0){
printf("Opened Ardunio serial port sucessfully\n");
}
else{
printf("Failed to open Arduino serial port\n");
}
/*for(i = 0; i < 50; i++)
{
dist = getDistance(arduinoSerial);
printf("Instensity: %d\n", dist);
usleep(microsecondsToMilliseconds(100));
}
usleep(microsecondsToMilliseconds(5000));*/
//Turn on power LED
gpio_set_value(POWER_LED_PIN, HIGH);
printf("Systems are GO for launch!\n");
waitForButtonPress();
getDistance(arduinoSerial);
//Move to center of the board
goForward();
usleep(microsecondsToMilliseconds(1800));
stopWheels();
//Aim at right target
rotate(180);
if(aimAtSideMostTarget(1))
{
for (; num_balls > 3; num_balls--)
{
fireGolfBall();
}
}
//Move toward left target
rotate(-550);
goForward();
usleep(microsecondsToMilliseconds(2200));
stopWheels();
//Aim at left target
rotate(300);
if(aimAtSideMostTarget(0))
{
for (; num_balls > 1; num_balls--)
{
fireGolfBall();
}
}
//Aim at middle target
rotate(260);
aimAtBiggestTarget();
for(; num_balls > 0; num_balls--)
{
fireGolfBall();
}
//Move to sideline for reload
rotate(-600);
goForward();
buffer_clear(arduinoSerial);
do
{
prev = dist;
dist = getDistance(arduinoSerial);
//printf("%d, ", dist);
usleep(microsecondsToMilliseconds(9));
}
while (dist < DISTANCE_TO_WALL || dist == 0 || prev - dist > 5);
stopWheels();
rotate(1100);
//Turn on reload LED
gpio_set_value(RELOAD_LED_PIN, HIGH);
usleep(microsecondsToMilliseconds(3000));
gpio_set_value(RELOAD_LED_PIN, LOW);
while (n < 3) //big while loop thing!
{
//start from left
num_balls = 5;
goForward();
usleep(microsecondsToMilliseconds(1200));
stopWheels();
rotate(-420);
goForward();
usleep(microsecondsToMilliseconds(590));
stopWheels();
//Aim at left target
if(aimAtSideMostTarget(0))
{
for(; num_balls > 3; num_balls--)
{
fireGolfBall();
}
}
//Aim at middle target
rotate(420);
goForward();
usleep(microsecondsToMilliseconds(600));
stopWheels();
rotate(-150);
aimAtBiggestTarget();
for(; num_balls > 2; num_balls--)
{
fireGolfBall();
}
//Aim at right target
rotate(400);
goForward();
usleep(microsecondsToMilliseconds(2700));
stopWheels();
rotate(-370);
if(aimAtSideMostTarget(1))
{
for(; num_balls > 0; num_balls--)
{
fireGolfBall();
}
}
//Move to sideline for reload
rotate(320);
//usleep(microsecondsToMilliseconds(50));
goForward();
buffer_clear(arduinoSerial);
dist = 0;
do
{
prev = dist;
dist = getDistance(arduinoSerial);
//printf("And another thing....\n");
//printf("%d!!! \n", dist);
usleep(microsecondsToMilliseconds(10));
}while (dist < DISTANCE_TO_WALL || dist == 0 || prev - dist > 5);
stopWheels();
rotate(-900);
gpio_set_value(RELOAD_LED_PIN, HIGH);
usleep(microsecondsToMilliseconds(3000));
gpio_set_value(RELOAD_LED_PIN, LOW);
//start from right
num_balls = 5;
goForward();
usleep(microsecondsToMilliseconds(1350));
stopWheels();
rotate(570);
//Aim at right target
if(aimAtSideMostTarget(1))
{
for(; num_balls > 3; num_balls--)
{
fireGolfBall();
}
}
//Aim at middle target
rotate(-500);
goForward();
usleep(microsecondsToMilliseconds(4500));
stopWheels();
rotate(650);
aimAtBiggestTarget();
for(; num_balls > 2; num_balls--)
{
fireGolfBall();
}
//Aim at left target
rotate(-200);
if(aimAtSideMostTarget(0))
{
for(; num_balls > 0; num_balls--)
{
fireGolfBall();
}
}
//Move to sideline for reload
rotate(-400);
goForward();
buffer_clear(arduinoSerial);
do
{
prev = dist;
dist = getDistance(arduinoSerial);
usleep(microsecondsToMilliseconds(9));
}
while(dist < DISTANCE_TO_WALL || dist == 0 || prev - dist > 5);
stopWheels();
rotate(1000);
gpio_set_value(RELOAD_LED_PIN, HIGH);
usleep(microsecondsToMilliseconds(3000));
gpio_set_value(RELOAD_LED_PIN, LOW);
} //end of while loop
//Turn off gpio power
gpio_set_value(POWER_LED_PIN, LOW);
gpio_set_value(RELOAD_LED_PIN, LOW);
gpio_set_value(ARDUINO_PIN, LOW);
//Turn off motors
setRun(GRABBER_MOTOR_INDEX, 0);
setRun(DROPPER_MOTOR_INDEX, 0);
setRun(ROLLER_MOTOR_INDEX, 0);
setRun(RIGHT_WHEEL_INDEX, 0);
setRun(LEFT_WHEEL_INDEX, 0);
//Remove GPIO files
//gpio_unexport(PING_PIN);
return 0;
}
task main() {
initializeRobot();
bDisplayDiagnostics = false; //disable diagnostics display
eraseDisplay();
nxtDisplayCenteredBigTextLine(6, "L R");
getButton();
switch (button) {
case kRightButton:
scan_direction = -1;
break;
case kLeftButton:
scan_direction = 1;
break;
default:
StopAllTasks();
}
eraseDisplay();
nxtDisplayCenteredTextLine(4, "Both");
nxtDisplayCenteredTextLine(6, "Block|Ramp");
getButton();
switch (button) {
case kRightButton:
ramp = true;
block = false;
break;
case kLeftButton:
ramp = false;
block = true;
break;
case kEnterButton:
ramp = true;
block = true;
break;
default:
StopAllTasks();
}
if (block && ramp) {
eraseDisplay();
nxtDisplayCenteredTextLine(4, "Ramp Side?");
nxtDisplayCenteredTextLine(6, "Far|Closest|Near");
getButton();
switch (button) {
case kRightButton: //near side
ramp_direction = -scan_direction;
break;
case kLeftButton: //far side
ramp_direction = scan_direction;
break;
case kEnterButton: //closest side based on encoders
ramp_direction = 0;
break;
default:
StopAllTasks();
}
}
eraseDisplay();
nxtDisplayCenteredTextLine(1, "Wait for Start?");
nxtDisplayCenteredTextLine(6, "Yes No");
getButton();
switch (button) {
case kRightButton:
wait = false;
break;
case kLeftButton:
wait = true;
break;
default:
StopAllTasks();
}
eraseDisplay();
nxtDisplayCenteredBigTextLine(1, "Debug?");
nxtDisplayCenteredBigTextLine(6, "Yes No");
getButton();
switch (button) {
case kRightButton:
debug = false;
break;
case kLeftButton:
debug = true;
break;
default:
StopAllTasks();
}
//optional delay before starting autonomous
eraseDisplay();
nxtDisplayCenteredBigTextLine(1, "Delay?");
nxtDisplayCenteredBigTextLine(6,"0");
int delay = 0; //number of seconds to delay
bool done = false;
while(!done) {
nxtDisplayCenteredBigTextLine(6," %d ",delay);
getButton();
switch (button) {
case kRightButton:
delay++;
break;
case kLeftButton:
if (delay > 0)
delay--;
break;
case kEnterButton:
done = true;
break;
default:
StopAllTasks();
}
}
eraseDisplay();
nxtDisplayCenteredBigTextLine(0, "Ready?");
nxtDisplayCenteredBigTextLine(6, "Go!");
getButton();
switch (button) {
case kEnterButton:
break;
default:
StopAllTasks();
}
////////////////////////////////////////////////////
//code that actually runs during match starts here//
////////////////////////////////////////////////////
eraseDisplay();
bDisplayDiagnostics = true; //reenable diagnostics display
if (wait)
waitForStart();
wait1Msec(delay*1000);
//just get on ramp via dead reckoning
if (ramp && !block) {
goForward(100);
wait1Msec(900);
driveFast(scan_direction*100,0);
wait1Msec(2100);
driveStop();
}
//score block in IR goal
else {
pwr_x = scan_direction*PWR_SCAN;
driveTilted(pwr_x, pwr_y);
while (abs(nMotorEncoder[M_DRIVE_FL]) < 6500) {
//wait for it to reach the wall
}
//we are now at the near edge of the wall//
nMotorEncoder[M_DRIVE_FL] = 0;
while (SensorValue[SONAR] < 200) {
//TODO: Check this value, or maybe make it use sonar
// to detect end of wall instead.
nxtDisplayString(3, "%8d ", nMotorEncoder[M_DRIVE_FL]);
//nxtDisplayBigStringAt(0,50, "IR:%d ", SensorValue[IR]);
if (SensorValue[IR] == 5 || abs(nMotorEncoder[M_DRIVE_FL]) > 6500) {
//TODO: use sonar instead of encoder we see the IR beacon
scored = true;
//wait1Msec(80);
driveStop();
int near_edge = abs(nMotorEncoder[M_DRIVE_FL]);
while (SensorValue[IR] == 5){
trackWall(35, 100);
driveTilted(pwr_x, pwr_y);
}
driveStop();
int far_edge = abs(nMotorEncoder[M_DRIVE_FL]);
while (abs(nMotorEncoder[M_DRIVE_FL]) > (near_edge + far_edge)/2) {
trackWall(35, 100);
driveTilted(-pwr_x, pwr_y);
}
driveStop();
nxtDisplayString(3, "%8d ", nMotorEncoder[M_DRIVE_FL]);
if (ramp_direction == 0) { //if we have not already chosen a direction for the ramp
if (abs(nMotorEncoder[M_DRIVE_FL]) > 2000) //TODO: calibrate this value, should be halfway
ramp_direction = scan_direction;
else
ramp_direction = -scan_direction;
}
pwr_x = 0;
pwr_y = 75;
while(true) {
int ir = SensorValue[IR];
if (ir < 5){
pwr_x = -30;
pwr_y = 0;
}
if (ir > 5) {
pwr_x = 30;
pwr_y = 0;
}
else {
pwr_x = 0;
pwr_y = 50;
}
if (SensorValue[SONAR] < 30)
break;
//trackWall(30,50);
driveTilted(pwr_x,pwr_y);
}
driveStop();
if (debug)
wait1Msec(1000);
wait1Msec(300);
servo[SV_AUTO] = 130; //score the autonomous block
wait1Msec(400);
servo[SV_AUTO] = 24;
wait1Msec(100);
if (debug)
wait1Msec(1000);
break;
}
trackWall(35, 50);
driveTilted(pwr_x, pwr_y);
}
driveStop();
if (ramp) {
//go remaining distance
pwr_x = ramp_direction*1.5*PWR_SCAN;
pwr_y = -10; //get a bit away from baskets
driveTilted(pwr_x, pwr_y);
while(SensorValue[SONAR] < 200) {
trackWall(45,50);
driveTilted(pwr_x, pwr_y);
}
servo[SV_AUTO] = 0;
driveStop();
if (debug)
wait1Msec(1000);
//get away from baskets
if (ramp_direction == 1)
goForward(100);
else
goLeft(100);
wait1Msec(1000);
driveStop();
if (debug)
wait1Msec(1000);
//get in front of ramp
goForwardLeft(100);
wait1Msec(1000);
driveStop();
if (debug)
wait1Msec(1000);
//rotate to face ramp
rotate(-100);
wait1Msec(350);
driveStop();
if (debug)
wait1Msec(1000);
//get on ramp
if (ramp_direction == 1)
goLeft(100);
else
goRight(100);
wait1Msec(2000);
driveStop();
}
}
}
const DirSet::Iter& DirSet::Iter::operator++ () {
ind = Dir(int(ind) + 1);
goForward();
return *this;
}
DirSet::Iter::Iter(const DirSet& s, Dir num) : set(s), ind(num) {
goForward();
}
void stepForward(){
goForward();
__delay_cycles(2000000);
stop();
}
void
SimilarArtistsApplet::init()
{
DEBUG_BLOCK
// Call the base implementation.
Context::Applet::init();
enableHeader( true );
setHeaderText( i18n( "Similar Artists" ) );
QAction* backwardAction = new QAction( this );
backwardAction->setIcon( KIcon( "go-previous" ) );
backwardAction->setEnabled( false );
backwardAction->setText( i18n( "Back" ) );
m_backwardIcon = addLeftHeaderAction( backwardAction );
connect( m_backwardIcon, SIGNAL(clicked()), this, SLOT(goBackward()) );
QAction* forwardAction = new QAction( this );
forwardAction->setIcon( KIcon( "go-next" ) );
forwardAction->setEnabled( false );
forwardAction->setText( i18n( "Forward" ) );
m_forwardIcon = addLeftHeaderAction( forwardAction );
connect( m_forwardIcon, SIGNAL(clicked()), this, SLOT(goForward()) );
QAction *currentAction = new QAction( this );
currentAction->setIcon( KIcon( "filename-artist-amarok" ) );
currentAction->setEnabled( true );
currentAction->setText( i18n( "Show Similar Artists for Currently Playing Track" ) );
m_currentArtistIcon = addRightHeaderAction( currentAction );
connect( m_currentArtistIcon, SIGNAL(clicked()), this, SLOT(queryForCurrentTrack()) );
QAction* settingsAction = new QAction( this );
settingsAction->setIcon( KIcon( "preferences-system" ) );
settingsAction->setEnabled( true );
settingsAction->setText( i18n( "Settings" ) );
m_settingsIcon = addRightHeaderAction( settingsAction );
connect( m_settingsIcon, SIGNAL(clicked()), this, SLOT(configure()) );
setCollapseOffHeight( -1 );
setCollapseHeight( m_header->height() );
setMinimumHeight( collapseHeight() );
setPreferredHeight( collapseHeight() );
// create a scrollarea
m_scroll = new ArtistsListWidget( this );
m_scroll->hide();
connect( m_scroll, SIGNAL(showSimilarArtists(QString)), SLOT(showSimilarArtists(QString)) );
connect( m_scroll, SIGNAL(showBio(QString)), SLOT(showArtistBio(QString)) );
m_layout = new QGraphicsLinearLayout( Qt::Vertical, this );
m_layout->addItem( m_header );
m_layout->addItem( m_scroll );
setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
// Read config and inform the engine.
KConfigGroup config = Amarok::config( "SimilarArtists Applet" );
m_maxArtists = config.readEntry( "maxArtists", "5" ).toInt();
Plasma::DataEngine *engine = dataEngine( "amarok-similarArtists" );
connect( engine, SIGNAL(sourceAdded(QString)), SLOT(connectSource(QString)) );
engine->setProperty( "maximumArtists", m_maxArtists );
engine->query( "similarArtists" );
}
void MotorCar::joggling() {
goForward(MAX_SPEED, 50);
goBack(MAX_SPEED, 50);
}
void MultiPageLayout::addPageAfterSecond()
{
// in this case the page after the second page is new, so move forward to view that page
if( book->addPage(nFirstPage+1) )
goForward();
}
void loop() {
if ((unsigned long) (millis() - previousEth) >= interval_ethernet) { //entra a cada 50ms
previousEth = millis();
if(count_eth == 0) { //espera completar um ciclo de todas as funções chamadas
int packetSize = Udp.parsePacket();
count_eth = 2;
Serial.println("entrou eth");
received = 0;
if (packetSize) {
set_debug(PC3);
#ifdef debug
Serial.println("entrou eth RX ");
Serial.print("Received packet of size ");
Serial.println(packetSize);
Serial.print("From ");
IPAddress remote = Udp.remoteIP();
for (int i =0; i < 4; i++)
{
Serial.print(remote[i], DEC);
if (i < 3)
{
Serial.print(".");
}
}
Serial.print(", port ");
Serial.println(Udp.remotePort());
Serial.println("Contents:");
Serial.println(packetBuffer);
#endif
received = Udp.read();
charBuffer.put(received);
#ifdef debug
Serial.println("\rchar recebido:");
Serial.write(received);
#endif
/////////////////////////////
clear_debug(PC3);
}
} else {
count_eth--;
Serial.println("entrou eth NADA");
if (charBuffer.getSize() > 5) charBuffer.clear();
if( charBuffer.getSize() > 0 )
received = charBuffer.get();
Serial.println("received:");
Serial.println(received);
}
}
#ifdef debug
Serial.println("client disconnected");
#endif
/****************FIM ROTINA ETHERNET ***************************************************/
if ((unsigned long) (millis() - previousADC) >= interval_adc) { //entra a cada 60ms
previousADC = millis();
set_debug(PC4);
if (count_adc == 0) {
count_adc = 1;
/*testa obstaculo IR*/
Serial.println("entrou adc OBSTACULO ");
IR_obstaculo = 0;
IR_obstaculo = verificaObstaculoIR();
#ifdef debug
Serial.println("distancia_ir");
Serial.println(IR_obstaculo);
Serial.println("\r");
#endif
if (IR_obstaculo > IR_OBSTACLE_THRESHOLD)
obstacle_flag = 0;
else if (IR_obstaculo > IR_OBSTACLE_THRESHOLD
&& IR_obstaculo < IR_OBSTACLE_UPPER_THRESHOLD)
obstacle_flag = 1;
else if (IR_obstaculo <= IR_OBSTACLE_THRESHOLD)
obstacle_flag = 2;
clear_debug(PC4);
} else {
count_adc=0;
Serial.println("entrou adc NADA ");
}
}
/***************** FIM ROTINA ADC********************************/
if ((unsigned long) (millis() - previousMotores) >= interval_motores) { //entra a cada 100ms
previousMotores = millis();
if (ciclosClock_motor == 2) { //duas bordas de subida depois de acionar o motor (200ms depois de acionar o motor)
Serial.println("motor stop ");
stopMove();
ciclosClock_motor = 0;
}
if (count_motor == 0) {
Serial.println("motor ANDA ");
if (obstacle_flag == 0 || obstacle_flag == 1) {
count_motor = 1;
/*move motores*/
switch (received) {
case 'u':
goForward(obstacle_flag);
break;
case 'd':
goBack(obstacle_flag);
break;
case 'l':
goLeft(obstacle_flag);
break;
case 'r':
goRight(obstacle_flag);
break;
default:
received = 0;
stopMove();
break;
}
} else {
if (received == 'd') {
goBack(WITH_CARE);
} else {
stopMove();
}
}
} else {
ciclosClock_motor++;
count_motor = 0;
Serial.println("ciclosClock_motor++ ");
}
}
// _delay_ms(500);
}
NavigationBar::NavigationBar(QupZilla* mainClass)
: QWidget(mainClass)
, p_QupZilla(mainClass)
{
setObjectName("navigationbar");
m_layout = new QHBoxLayout(this);
m_layout->setMargin(3);
m_layout->setSpacing(3);
setLayout(m_layout);
m_buttonBack = new ToolButton(this);
m_buttonBack->setObjectName("navigation-button-back");
m_buttonBack->setToolTip(tr("Back"));
m_buttonBack->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_buttonBack->setAutoRaise(true);
m_buttonBack->setEnabled(false);
m_buttonBack->setFocusPolicy(Qt::NoFocus);
m_buttonNext = new ToolButton(this);
m_buttonNext->setObjectName("navigation-button-next");
m_buttonNext->setToolTip(tr("Forward"));
m_buttonNext->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_buttonNext->setAutoRaise(true);
m_buttonNext->setEnabled(false);
m_buttonNext->setFocusPolicy(Qt::NoFocus);
QHBoxLayout* backNextLayout = new QHBoxLayout();
backNextLayout->setContentsMargins(0, 0, 0, 0);
backNextLayout->setSpacing(0);
backNextLayout->addWidget(m_buttonBack);
backNextLayout->addWidget(m_buttonNext);
m_reloadStop = new ReloadStopButton(this);
m_buttonHome = new ToolButton(this);
m_buttonHome->setObjectName("navigation-button-home");
m_buttonHome->setToolTip(tr("Home"));
m_buttonHome->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_buttonHome->setAutoRaise(true);
m_buttonHome->setFocusPolicy(Qt::NoFocus);
m_buttonAddTab = new ToolButton(this);
m_buttonAddTab->setObjectName("navigation-button-addtab");
m_buttonAddTab->setToolTip(tr("New Tab"));
m_buttonAddTab->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_buttonAddTab->setAutoRaise(true);
m_buttonAddTab->setFocusPolicy(Qt::NoFocus);
m_menuBack = new Menu(this);
m_buttonBack->setMenu(m_menuBack);
m_menuForward = new Menu(this);
m_buttonNext->setMenu(m_menuForward);
#ifndef Q_OS_MAC
m_supMenu = new ToolButton(this);
m_supMenu->setObjectName("navigation-button-supermenu");
m_supMenu->setPopupMode(QToolButton::InstantPopup);
m_supMenu->setToolTip(tr("Main Menu"));
m_supMenu->setAutoRaise(true);
m_supMenu->setFocusPolicy(Qt::NoFocus);
m_supMenu->setMenu(p_QupZilla->superMenu());
m_supMenu->setShowMenuInside(true);
#endif
m_searchLine = new WebSearchBar(p_QupZilla);
m_navigationSplitter = new QSplitter(this);
m_navigationSplitter->addWidget(p_QupZilla->tabWidget()->locationBars());
m_navigationSplitter->addWidget(m_searchLine);
m_navigationSplitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
m_navigationSplitter->setCollapsible(0, false);
m_exitFullscreen = new ToolButton();
m_exitFullscreen->setText(tr("Exit Fullscreen"));
m_exitFullscreen->setToolTip(tr("Exit Fullscreen"));
m_exitFullscreen->setAutoRaise(true);
m_exitFullscreen->setVisible(false);
m_layout->addLayout(backNextLayout);
m_layout->addWidget(m_reloadStop);
m_layout->addWidget(m_buttonHome);
m_layout->addWidget(m_buttonAddTab);
m_layout->addWidget(m_navigationSplitter);
#ifndef Q_OS_MAC
m_layout->addWidget(m_supMenu);
#endif
m_layout->addWidget(m_exitFullscreen);
setContextMenuPolicy(Qt::CustomContextMenu);
connect(this, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(contextMenuRequested(QPoint)));
connect(m_menuBack, SIGNAL(aboutToShow()), this, SLOT(aboutToShowHistoryBackMenu()));
connect(m_menuForward, SIGNAL(aboutToShow()), this, SLOT(aboutToShowHistoryNextMenu()));
connect(m_buttonBack, SIGNAL(clicked()), this, SLOT(goBack()));
connect(m_buttonBack, SIGNAL(middleMouseClicked()), this, SLOT(goBackInNewTab()));
connect(m_buttonBack, SIGNAL(controlClicked()), this, SLOT(goBackInNewTab()));
connect(m_buttonNext, SIGNAL(clicked()), this, SLOT(goForward()));
connect(m_buttonNext, SIGNAL(middleMouseClicked()), this, SLOT(goForwardInNewTab()));
connect(m_buttonNext, SIGNAL(controlClicked()), this, SLOT(goForwardInNewTab()));
connect(m_reloadStop->buttonStop(), SIGNAL(clicked()), p_QupZilla, SLOT(stop()));
connect(m_reloadStop->buttonReload(), SIGNAL(clicked()), p_QupZilla, SLOT(reload()));
connect(m_buttonHome, SIGNAL(clicked()), p_QupZilla, SLOT(goHome()));
connect(m_buttonHome, SIGNAL(middleMouseClicked()), p_QupZilla, SLOT(goHomeInNewTab()));
connect(m_buttonHome, SIGNAL(controlClicked()), p_QupZilla, SLOT(goHomeInNewTab()));
connect(m_buttonAddTab, SIGNAL(clicked()), p_QupZilla, SLOT(addTab()));
connect(m_exitFullscreen, SIGNAL(clicked(bool)), p_QupZilla, SLOT(toggleFullScreen(bool)));
}
DSPDFViewer::DSPDFViewer(const RuntimeConfiguration& r):
runtimeConfiguration(r),
pdfDocument(Poppler::Document::load(r.filePathQString()))
,
renderFactory(r.filePathQString()),
m_pagenumber(0),
audienceWindow(0, r.useFullPage()? PagePart::FullPage : PagePart::LeftHalf , false, r),
secondaryWindow(1, r.useFullPage()? PagePart::FullPage : PagePart::RightHalf, true, r, r.useSecondScreen() )
{
qDebug() << "Starting constructor" ;
if ( ! r.useSecondScreen() ) {
secondaryWindow.hide();
}
audienceWindow.showLoadingScreen(0);
secondaryWindow.showLoadingScreen(0);
if ( ! pdfDocument || pdfDocument->isLocked() )
{
/// FIXME: Error message
throw std::runtime_error("I was not able to open the PDF document. Sorry.");
}
setHighQuality(true);
qDebug() << "Connecting audience window";
audienceWindow.setPageNumberLimits(0, numberOfPages()-1);
connect( &renderFactory, SIGNAL(pageRendered(QSharedPointer<RenderedPage>)), &audienceWindow, SLOT(renderedPageIncoming(QSharedPointer<RenderedPage>)));
connect( &renderFactory, SIGNAL(thumbnailRendered(QSharedPointer<RenderedPage>)), &audienceWindow, SLOT(renderedThumbnailIncoming(QSharedPointer<RenderedPage>)));
connect( &audienceWindow, SIGNAL(nextPageRequested()), this, SLOT(goForward()));
connect( &audienceWindow, SIGNAL(previousPageRequested()), this, SLOT(goBackward()));
connect( &audienceWindow, SIGNAL(pageRequested(uint)), this, SLOT(gotoPage(uint)));
connect( &audienceWindow, SIGNAL(quitRequested()), this, SLOT(exit()));
connect( &audienceWindow, SIGNAL(rerenderRequested()), this, SLOT(renderPage()));
connect( &audienceWindow, SIGNAL(restartRequested()), this, SLOT(goToStartAndResetClocks()));
connect( &audienceWindow, SIGNAL(screenSwapRequested()), this, SLOT(swapScreens()) );
if ( r.useSecondScreen() )
{
qDebug() << "Connecting secondary window";
secondaryWindow.setPageNumberLimits(0, numberOfPages()-1);
connect( &renderFactory, SIGNAL(pageRendered(QSharedPointer<RenderedPage>)), &secondaryWindow, SLOT(renderedPageIncoming(QSharedPointer<RenderedPage>)));
connect( &renderFactory, SIGNAL(thumbnailRendered(QSharedPointer<RenderedPage>)), &secondaryWindow, SLOT(renderedThumbnailIncoming(QSharedPointer<RenderedPage>)));
connect( &secondaryWindow, SIGNAL(nextPageRequested()), this, SLOT(goForward()));
connect( &secondaryWindow, SIGNAL(previousPageRequested()), this, SLOT(goBackward()));
connect( &secondaryWindow, SIGNAL(pageRequested(uint)), this, SLOT(gotoPage(uint)));
connect( &secondaryWindow, SIGNAL(quitRequested()), this, SLOT(exit()));
connect( &secondaryWindow, SIGNAL(rerenderRequested()), this, SLOT(renderPage()));
connect( &secondaryWindow, SIGNAL(restartRequested()), this, SLOT(goToStartAndResetClocks()));
connect( &secondaryWindow, SIGNAL(screenSwapRequested()), this, SLOT(swapScreens()) );
connect( this, SIGNAL(presentationClockUpdate(QTime)), &secondaryWindow, SLOT(updatePresentationClock(QTime)));
connect( this, SIGNAL(slideClockUpdate(QTime)), &secondaryWindow, SLOT(updateSlideClock(QTime)));
connect( this, SIGNAL(wallClockUpdate(QTime)), &secondaryWindow, SLOT(updateWallClock(QTime)));
}
renderPage();
clockDisplayTimer.setInterval(TIMER_UPDATE_INTERVAL);
clockDisplayTimer.start();
connect( &clockDisplayTimer, SIGNAL(timeout()), this, SLOT(sendAllClockSignals()));
sendAllClockSignals();
}
