lx/watrbx-game-engine
1
0
Fork 0
mirror of https://github.com/copyrighttxt/watrbx-game-engine.git synced 2026-09-04 20:57:49 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
watrbx-game-engine/RobloxStudio/RobloxIDEDoc.cpp
T
watrabi 977f1ff4b8 GEEKING
2025-09-18 17:55:52 -04:00

4619 lines
154 KiB
C++
Raw Permalink Blame History

/**
* RobloxIDEDoc.cpp
* Copyright (c) 2013 ROBLOX Corp. All Rights Reserved.
*/
#include "stdafx.h"
#include "RobloxIDEDoc.h"
// Qt Headers
#include <QFileInfo>
#include <QDir>
#include <QDateTime>
#include <QMessageBox>
#include <QDesktopServices>
#include <QDialogButtonBox>
#include <QPushButton>
#include <QFileDialog>
#include <QDomDocument>
#include <QDomElement>
// 3rd Party Headers
#include "boost/iostreams/copy.hpp"
// Roblox Headers
#include "v8world/World.h"
#include "v8datamodel/PartOperation.h"
#include "v8datamodel/Game.h"
#include "v8datamodel/DataModel.h"
#include "v8datamodel/Workspace.h"
#include "v8datamodel/CommonVerbs.h"
#include "v8datamodel/ContentProvider.h"
#include "v8datamodel/PluginManager.h"
#include "v8datamodel/GuiService.h"
#include "v8datamodel/UserInputService.h"
#include "v8datamodel/GameBasicSettings.h"
#include "v8datamodel/Lighting.h"
#include "v8datamodel/Light.h"
#include "V8DataModel/NonReplicatedCSGDictionaryService.h"
#include "v8datamodel/ServerScriptService.h"
#include "v8datamodel/StarterPlayerService.h"
#include "v8datamodel/ServerStorage.h"
#include "v8datamodel/ReplicatedStorage.h"
#include "v8datamodel/Visit.h"
#include "v8xml/Serializer.h"
#include "v8xml/SerializerBinary.h"
#include "rbx/BaldPtr.h"
#include "AppDraw/Draw.h"
#include "script/ScriptContext.h"
#include "script/LuaMemory.h"
#include "script/DebuggerManager.h"
#include "script/ModuleScript.h"
#include "script/Script.h"
#include "network/Players.h"
#include "util/ProtectedString.h"
#include "util/Statistics.h"
#include "util/Profiling.h"
#include "util/MD5Hasher.h"
#include "Util/RobloxGoogleAnalytics.h"
#include "util/ScopedAssign.h"
#include "Util/LuaWebService.h"
#include "Util/Hash.h"
#include "GfxBase/FrameRateManager.h"
#include "GfxBase/ViewBase.h"
#include "GfxBase/IAdornableCollector.h"
#include "RenderSettingsItem.h"
#include "Tool/ToolsArrow.h"
#include "V8Xml/WebParser.h"
#include "v8datamodel/BasicPartInstance.h"
#include "v8datamodel/HttpRbxApiService.h"
#include "v8datamodel/MegaCluster.h"
#include "StringConv.h"
#include "script/ScriptAnalyzer.h"
// Roblox Studio Headers
#include "RobloxView.h"
#include "RobloxTreeWidget.h"
#include "ogrewidget.h"
#include "RobloxMainWindow.h"
#include "RobloxStudioVerbs.h"
#include "RobloxPropertyWidget.h"
#include "RobloxSettings.h"
#include "StudioUtilities.h"
#include "RobloxDiagnosticsView.h"
#include "RobloxGameExplorer.h"
#include "RobloxScriptReview.h"
#include "CommonInsertWidget.h"
#include "RobloxToolBox.h"
#include "RobloxTutorials.h"
#include "RobloxDocManager.h"
#include "WebDialog.h"
#include "IExternalHandler.h"
#include "RobloxCustomWidgets.h"
#include "QtUtilities.h"
#include "RobloxScriptDoc.h"
#include "UpdateUIManager.h"
#include "AuthoringSettings.h"
#include "StudioSerializerHelper.h"
#include "InsertServiceDialog.h"
#include "DebuggerClient.h"
#include "RobloxPluginHost.h"
#include "PluginAction.h"
#include "RobloxUser.h"
#include "DebuggerWidgets.h"
#include "RobloxApplicationManager.h"
#include "ScriptAnalysisWidget.h"
#include "StudioDeviceEmulator.h"
#include "KeepSavedChangesDialog.h"
#include "AuthenticationHelper.h"
#include "RobloxTextOutputWidget.h"
#include "RobloxChatWidget.h"
#include "PlayersDataManager.h"
#include "RobloxTeamCreateWidget.h"
#include "RobloxServicesTools.h"
using namespace RBX;
using namespace boost;
LOGGROUP(AutoSave)
FASTFLAG(LuaDebugger)
FASTFLAG(StudioSeparateActionByActivationMethod)
FASTFLAG(StudioShowTutorialsByDefault)
FASTFLAG(StudioEmbeddedFindDialogEnabled)
FASTFLAG(StudioCustomStatsEnabled)
FASTFLAG(UserBetterInertialScrolling)
FASTFLAG(StudioEnableGameAnimationsTab)
DYNAMIC_FASTFLAG(ScriptExecutionContextApi)
FASTFLAG(MaterialPropertiesEnabled)
FASTFLAGVARIABLE(AnalyzerGroupUIEnabled, false)
FASTFLAGVARIABLE(PrefetchResourcesEnabled, false)
FASTFLAGVARIABLE(SearchToolboxByDataModelSearchString, false)
FASTFLAGVARIABLE(EnablePhysicalPropertiesByDefault, false)
FASTFLAGVARIABLE(PGSSolverDefaultOnNewPlaces, false)
FASTFLAGVARIABLE(NoPromptOnAlreadySavedPlace, true)
FASTFLAG(UseBuildGenericGameUrl)
FASTFLAG(CSGPhysicsLevelOfDetailEnabled)
DYNAMIC_FASTSTRINGVARIABLE(WorkspaceMessageText, std::string("Test Me - Please Remove"))
DYNAMIC_FASTSTRINGVARIABLE(WorkspaceMessageLink, std::string("http://www.roblox.com"))
DYNAMIC_FASTFLAGVARIABLE(WorkspaceNotificationMasterEnable, false)
// Level 1 = Show it to people with DEFAULT Physical Properties settings
// Level 2 = Show it to people with LEGACY and DEFAULT Physical properties settings
DYNAMIC_FASTINTVARIABLE(StudioWorkspaceNotificationLevel, 0)
FASTFLAGVARIABLE(CLI10590_FixConversionDialog, true)
FASTFLAGVARIABLE(RetryWhenCloudEditEnabledEndpointFails, false)
DYNAMIC_FASTFLAG(UseR15Character)
Q_DECLARE_METATYPE(boost::function<void(int)>);
Q_DECLARE_METATYPE(boost::function<void(std::string)>);
static const char* DraggerGridModeSetting = "DraggerGridMode";
static const char* GridSizeSetting = "GridSize";
static const char* StatsVerb = "Stats";
static const char* RenderStatsVerb = "RenderStats";
static const char* PhysicsStatsVerb = "PhysicsStats";
static const char* NetworkStatsVerb = "NetworkStats";
static const char* SummaryStatsVerb = "SummaryStats";
static const char* CustomStatsVerb = "CustomStats";
static const char* kMaterialPropertiesConvertDialogDisabled = "MaterialPropertiesConvertDialogDisabled";
static const char* kMaterialPropertiesConvertByDefault = "MaterialPropertiesConvertByDefault";
static const char* PlaySoloDebugFileExt = "_NPS"; // extension to be added to rdbg file for New Play Solo mode
static const char* kPublishedPlacePrefix = "Published as ";
static const char* kCloudEditPlacePrefix = "Team Create: ";
static const char* kNewPlaceWindowTitle = "Untitled";
#define RBX_MANUAL_JOINT_CREATION_KEY "RbxManualJointCreationMode"
int RobloxIDEDoc::sIDEDocCount = 1;
RobloxIDEDoc::RobloxIDEDoc(RobloxMainWindow* pMainWindow)
: m_WrapperWidget(NULL)
, m_pQOgreWidget(NULL)
, m_pDiagViewWidget(NULL)
, m_pMainWindow(pMainWindow)
, m_pFileWatcher(NULL)
, m_fileName("")
, m_displayName(QString("Place%1").arg(sIDEDocCount))
, m_bIsLocalDocument(true)
, m_initializationScript("")
, m_IsAutoSaveLoad(false)
, m_TestModeEnabled(true)
, m_ReopenLastSavedPlace(true)
, m_IOMutex(QMutex::NonRecursive)
, m_RequiresSave(false)
, m_CurrentGame(&m_EditGame)
, m_initialDataModelHash("")
, m_AnnouncementWidget(NULL)
{
#ifdef _WIN32
m_pRecordToggle = NULL;
#endif
InitializeDefaultsFromSettings();
}
RobloxIDEDoc::~RobloxIDEDoc()
{
clearPlayModifiedScriptList();
}
void RobloxIDEDoc::applyScriptChanges()
{
// Get all scripts and apply changes
const tScriptDocs& openScriptDocs = RobloxDocManager::Instance().getOpenScriptDocs();
tScriptDocs::const_iterator iter = openScriptDocs.begin();
for (; iter != openScriptDocs.end() ; ++iter)
(*iter)->applyEditChanges();
}
void RobloxIDEDoc::InitializeDefaultsFromSettings()
{
RobloxSettings settings;
// Set our default camera speeds
RBX::Camera::CameraKeyMoveFactor = AuthoringSettings::singleton().getCameraKeyMoveSpeed();
RBX::Camera::CameraShiftKeyMoveFactor = AuthoringSettings::singleton().getCameraShiftMoveSpeed();
RBX::Camera::CameraMouseWheelMoveFactor = AuthoringSettings::singleton().getCameraMouseWheelMoveSpeed();
// Turn on or off the dragger grid
RBX::ArrowToolBase::showDraggerGrid = AuthoringSettings::singleton().getShowDraggerGrid();
RBX::Draw::showHoverOver(AuthoringSettings::singleton().getShowHoverOver());
}
// services that don't necessarily exist in a game, but a user may want to put into their game, so we show them in studio
void RobloxIDEDoc::createOptionalDMServices()
{
boost::shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
dataModel->create<RBX::ContentProvider>()->setAssetFetchMediator(
&UpdateUIManager::Instance().getViewWidget<RobloxGameExplorer>(eDW_GAME_EXPLORER));
RBX::ServiceProvider::create<RBX::ServerScriptService>(dataModel.get());
RBX::ServiceProvider::create<RBX::ServerStorage>(dataModel.get());
RBX::ServiceProvider::create<RBX::ReplicatedStorage>(dataModel.get());
if (m_CurrentGame->m_Game != m_PlayGame.m_Game &&
!StudioUtilities::isAvatarMode() &&
!StudioUtilities::isTestMode())
dataModel->setIsStudio(true);
dataModel->create<RBX::LuaWebService>()->setCheckApiAccessBecauseInStudio();
dataModel->create<RBX::Network::Players>()->setNonSuperSafeChatForAllPlayersEnabled(true);
if (AuthoringSettings::singleton().onlyPlayFocusWindowAudio)
{
setMuteAllSounds(!QApplication::activeWindow());
if (m_pMainWindow)
{
if (QAction* audioToggleWidget = m_pMainWindow->findChild<QAction*>("audioToggleAction"))
{
audioToggleWidget->setChecked(!QApplication::activeWindow());
}
}
}
dataModel->getWorkspace()->getAdornableCollector()->onRenderableDescendantAdded(
&m_CurrentGame->m_SelectionHighlightAdornable);
}
void RobloxIDEDoc::displayWorkspaceMessage()
{
// Physical Properties Specific display of dialog.
if (DFInt::StudioWorkspaceNotificationLevel && DFFlag::MaterialPropertiesEnabled )
{
bool messageEnabled = false;
RBX::PhysicalPropertiesMode currentMode = this->getDataModel()->getWorkspace()->getPhysicalPropertiesMode();
switch (DFInt::StudioWorkspaceNotificationLevel)
{
case 1:
messageEnabled = currentMode == RBX::PhysicalPropertiesMode_Default;
break;
case 2:
messageEnabled = currentMode <= RBX::PhysicalPropertiesMode_Default;
break;
default:
break;
}
if ( messageEnabled)
{
// Should only display if Roblox user hasn't set his play to Legacy Mode
// or hasn't upgraded to new mode.
m_AnnouncementWidget->showText();
}
else
{
m_AnnouncementWidget->hideText();
}
}
if (DFFlag::WorkspaceNotificationMasterEnable)
{
m_AnnouncementWidget->showText();
}
}
void RobloxIDEDoc::initializeNewPlace()
{
// disable studio mode. studio mode wants to do some fancy camera focus stuff
// that causes a crash because we haven't initialized the network client yet
bool oldStudioMode = RBX::GameBasicSettings::singleton().inStudioMode();
RBX::GameBasicSettings::singleton().setStudioMode(false);
// create instance for base plate
boost::shared_ptr<RBX::Instance> instance = RBX::Creatable<RBX::Instance>::create<RBX::BasicPartInstance>();
RBXASSERT(instance);
// set up part instance
RBX::BaldPtr<RBX::PartInstance> partInstance = static_cast<RBX::PartInstance*>(instance.get());
partInstance->setName("BasePlate");
if (shared_ptr<RBX::BasicPartInstance> basicPartInstance = RBX::Instance::fastSharedDynamicCast<RBX::BasicPartInstance>(instance))
basicPartInstance->setFormFactorXml(RBX::PartInstance::SYMETRIC);
partInstance->setPartSizeUi(RBX::Vector3(512, 20, 512));
partInstance->setTranslationUi(RBX::Vector3(0,-10,0));
partInstance->setAnchored(true);
partInstance->setPartLocked(true);
partInstance->setColor(RBX::BrickColor::brickDarkGray());
shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
RBX::DataModel::LegacyLock lock(dataModel, RBX::DataModelJob::Write);
if (DFFlag::MaterialPropertiesEnabled && FFlag::EnablePhysicalPropertiesByDefault)
{
// All new places will have Physical Material Properties enabled
dataModel->getWorkspace()->setPhysicalPropertiesMode(PhysicalPropertiesMode_NewPartProperties);
}
if (DFFlag::MaterialPropertiesEnabled)
{
RBXASSERT(!m_workspacePropertyChangedConnection.connected());
m_workspacePropertyChangedConnection = getEditDataModel()->getWorkspace()->propertyChangedSignal.connect(boost::bind(&RobloxIDEDoc::onWorkspacePropertyChanged, this, _1));
}
RBX::Instances instances;
instances.push_back(instance);
dataModel->getWorkspace()->insertInstances(
instances,
NULL,
RBX::INSERT_TO_TREE,
RBX::SUPPRESS_PROMPTS);
RBX::GameBasicSettings::singleton().setStudioMode(oldStudioMode);
// zoom to a good spot
RBX::Vector3 boxSize(15,15,15);
RBX::Extents extents(-boxSize,boxSize);
RBX::Camera* camera = dataModel->getWorkspace()->getCamera();
camera->zoomExtents(extents,RBX::Camera::ZOOM_IN_OR_OUT);
if(!FFlag::UserBetterInertialScrolling)
{
// adjust focus - zoom extents sets us in orbit cam
RBX::CoordinateFrame frame = camera->getCameraCoordinateFrame();
RBX::Vector3 look = frame.lookVector();
camera->setCameraFocus(frame.translation + look * 2.0f);
}
// merge baseplate with change history baseline so we don't get an undo
RBX::ChangeHistoryService* chs = dataModel->create<RBX::ChangeHistoryService>();
chs->resetBaseWaypoint();
// In addition to setting the replicated flag "expSolverEnabled_Replicate",
// this also sets "experimentalSolverEnabled" (serialized flag) to true
if (FFlag::PGSSolverDefaultOnNewPlaces)
dataModel->getWorkspace()->setExpSolverEnabled_Replicate(true);
if (FFlag::CSGPhysicsLevelOfDetailEnabled)
{
RBXASSERT(!m_dataModelItemChangedConnection.connected());
m_dataModelItemChangedConnection = getEditDataModel()->itemChangedSignal.connect(boost::bind(&RobloxIDEDoc::onDMItemChanged, this, _1, _2));
}
}
void RobloxIDEDoc::initializeDataModeHash()
{
if (m_initialDataModelHash.isEmpty() && getDataModel())
{
RBX::DataModel::LegacyLock lock(getDataModel(), RBX::DataModelJob::Read);
m_initialDataModelHash = StudioSerializerHelper::getDataModelHash(getDataModel());
}
}
void RobloxIDEDoc::initializeRobloxView()
{
try
{
RBX::DataModel::LegacyLock lock(m_CurrentGame->m_Game->getDataModel(), RBX::DataModelJob::Write);
m_GameView = RobloxView::createGameView(m_pQOgreWidget);
m_CurrentGame->m_View = new RobloxView(m_pQOgreWidget,m_CurrentGame->m_Game, m_GameView);
m_CurrentGame->m_View->buildGui(StudioUtilities::isAvatarMode() || isCloudEditSession());
// view has been created, initialize video recording
initializeVideoRecording(*m_CurrentGame);
UpdateUIManager::Instance().updateAction(*m_pMainWindow->toggleVideoRecordAction);
}
catch(CreatePopupException &e)
{
RBX::Log::current()->writeEntry(RBX::Log::Information,RBX::format("\tPopup Exception : %s",qPrintable(e.m_message)).c_str());
QtUtilities::RBXMessageBox msgBox;
msgBox.setIcon(QMessageBox::Warning);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setText(e.m_message);
msgBox.exec();
}
catch (std::exception& e)
{
RBX::Log::current()->writeEntry(RBX::Log::Information,RBX::format("\tException : %s",e.what()).c_str());
RBX::StandardOut::singleton()->print(RBX::MESSAGE_ERROR, e.what());
}
m_pMainWindow->onIDEDocViewInitialized();
}
bool RobloxIDEDoc::open(RobloxMainWindow *pMainWindow, const QString &fileName)
{
m_pMainWindow = pMainWindow;
return openFile(fileName, false);
}
bool RobloxIDEDoc::openFile(const QString& fileName, bool asNew)
{
if (!fileName.isEmpty())
{
QByteArray ba = fileName.toUtf8();
std::string fileNameUtf8(ba.constData(), ba.size());
std::ifstream stream(RBX::utf8_decode(fileNameUtf8).c_str(), std::ios_base::in | std::ios_base::binary);
if (!stream.is_open())
return false;
return openStream(fileName, &stream, asNew);
}
return openStream(fileName, NULL, asNew);
}
static void doCloudEditFetch(const QString& scriptArg, int placeId, shared_ptr<EntityProperties> config,
bool* abort, QDialog* dialog)
{
StudioUtilities::reportCloudEditJoinEvent("Hitting PlaceLauncher");
std::string url;
if (FFlag::UseBuildGenericGameUrl)
{
url = BuildGenericGameUrl(RobloxSettings::getBaseURL().replace("http","https").toStdString(), QString("game/PlaceLauncher.ashx?request=CloudEdit&placeId=%1").arg(placeId).toStdString());
}
else
{
url = (RobloxSettings::getBaseURL()
.replace("http", "https")
+ QString("/game/PlaceLauncher.ashx?request=CloudEdit&placeId=%1").arg(placeId)).toStdString();
}
RBX::StandardOut::singleton()->printf(RBX::MESSAGE_INFO, "Connecting to server...");
while (!*abort)
{
EntityProperties p;
p.setFromJsonFuture(RBX::HttpAsync::get(url));
if (boost::optional<int> status = p.get<int>("status"))
{
// PlaceLauncher status code 2 == server is ready
if (status.get() == 2 && !*abort)
{
config->setFromValueTable(p.get<shared_ptr<const RBX::Reflection::ValueTable> >("settings").get());
QMetaObject::invokeMethod(dialog, "done", Qt::QueuedConnection, Q_ARG(int, QDialog::Accepted));
break;
}
}
boost::this_thread::sleep(boost::posix_time::milliseconds(500));
}
}
static boost::optional<int> parseUrlParameter(QString parameterName, QString url)
{
QRegExp matcher(QString("%1=(\\d+)").arg(parameterName));
matcher.setCaseSensitivity(Qt::CaseInsensitive);
if (matcher.indexIn(url) != -1)
{
return matcher.cap(1).toInt();
}
return boost::optional<int>();
}
shared_ptr<EntityProperties> RobloxIDEDoc::cloudEditDetectionAndPlaceLaunch()
{
boost::optional<int> placeId;
if ((RobloxUser::singleton().getUserId() > 0) && StudioUtilities::containsEditScript(m_initializationScript))
{
placeId = parseUrlParameter("placeid", m_initializationScript);
RBXASSERT(placeId);
boost::optional<int> universeId = parseUrlParameter("universeid", m_initializationScript);
if (placeId && !universeId)
{
EntityProperties p;
std::string url = ReplaceTopSubdomain(RobloxSettings::getBaseURL().toStdString(), "api") +
format("/universes/get-universe-containing-place?placeId=%d", placeId.get());
p.setFromJsonFuture(RBX::HttpAsync::get(url));
if (boost::optional<int> placeUniverseId = p.get<int>("UniverseId"))
{
universeId = placeUniverseId.get();
}
}
RBXASSERT(universeId);
if (placeId && universeId)
{
std::string url = ReplaceTopSubdomain(RobloxSettings::getBaseURL().toStdString(), "api") +
format("/universes/%d/cloudeditenabled", universeId.get());
EntityProperties p;
bool done = false;
while (!done)
{
p.setFromJsonFuture(RBX::HttpAsync::get(url));
if (boost::optional<bool> enabled = p.get<bool>("enabled"))
{
done = true;
m_IsCloudEditSession = enabled.get();
}
else
{
if (FFlag::RetryWhenCloudEditEnabledEndpointFails)
{
StudioUtilities::reportCloudEditJoinEvent("Failed universes/cloudeditenabled");
QtUtilities::RBXMessageBox warning;
warning.setText("Failed to look up place's edit mode");
warning.addButton("Check Again", QMessageBox::ResetRole);
warning.addButton("Edit Alone", QMessageBox::AcceptRole);
warning.exec();
QMessageBox::ButtonRole role = warning.buttonRole(warning.clickedButton());
if (role == QMessageBox::AcceptRole)
{
done = true;
m_IsCloudEditSession = false;
}
}
else
{
done = true;
m_IsCloudEditSession = false;
}
}
}
}
else
{
StudioUtilities::reportCloudEditJoinEvent("Unable to read universeid/placeid from edit script");
StandardOut::singleton()->print(MESSAGE_ERROR, "Unable to determine place/universe, proceeding with Edit alone");
placeId = 0;
universeId = 0;
m_IsCloudEditSession = false;
}
}
else
{
// if it isn't an edit script it can't be a cloud edit session
m_IsCloudEditSession = false;
}
RBXASSERT(m_IsCloudEditSession.is_initialized());
shared_ptr<EntityProperties> cloudEditJoinConfig(new EntityProperties);
if (isCloudEditSession())
{
QtUtilities::RBXMessageBox connectingDialog;
connectingDialog.setText("Requesting access...");
connectingDialog.setStandardButtons(QMessageBox::Cancel);
bool abort = false;
boost::thread httpThread(boost::bind(&doCloudEditFetch,
boost::ref(m_initializationScript), placeId.get(), cloudEditJoinConfig, &abort, &connectingDialog));
int status = connectingDialog.exec();
if (status != QDialog::Accepted)
{
m_initializationScript = "";
abort = true;
StudioUtilities::reportCloudEditJoinEvent("User Aborted PlaceLauncher");
httpThread.join();
}
}
return cloudEditJoinConfig;
}
bool RobloxIDEDoc::openStream(const QString& fileName, std::istream* stream, bool asNew)
{
RobloxMainWindow *pMainWindow = m_pMainWindow;
clearOutputWidget();
shared_ptr<EntityProperties> cloudEditJoinConfig = cloudEditDetectionAndPlaceLaunch();
// Initialize our plugin host
pMainWindow->getPluginHost()->init();
QMutexLocker locker(&m_IOMutex);
RBX::Log::current()->writeEntry(RBX::Log::Information,"RobloxIDEDoc::open - start");
bool success = true;
UpdateUIManager::Instance().setBusy(true);
const static int ProgressStages = 7;
RBX::BaldPtr<QProgressBar> progressBar = UpdateUIManager::Instance().showProgress("Opening Place",0,ProgressStages);
bool isRemoteEditSession = false;
try
{
// Stage 0 - initialize
m_pMainWindow = pMainWindow;
QString baseUrl = RobloxSettings::getBaseURL();
if (!baseUrl.endsWith("/"))
{
baseUrl = baseUrl + "/";
}
#ifdef STUDIO_ADMIN_BUILD
if (fileName.indexOf("Join.ashx") != -1)
{
m_EditGame.m_Game.reset(new RBX::SecurePlayerGame(NULL, baseUrl.toStdString().c_str(), false));
}
else
{
m_EditGame.m_Game.reset(new RBX::UnsecuredStudioGame(NULL, baseUrl.toStdString().c_str(), StudioUtilities::isAvatarMode()));
}
#else
m_EditGame.m_Game.reset(new RBX::UnsecuredStudioGame(NULL,baseUrl.toStdString().c_str(), true));
#endif
RBX::Log::current()->writeEntry(RBX::Log::Information,"\tLocking DataModel");
RBX::DataModel::LegacyLock lock(m_EditGame.m_Game->getDataModel(), RBX::DataModelJob::Write);
createOptionalDMServices();
// Stage 1 - initialize widgets/graphics/view
UpdateUIManager::Instance().updateProgress(progressBar,1);
// TODO - when opening up a place from the website, get the real place name for
// the display name
m_EditGame.m_Game->getDataModel()->setName(displayName().toStdString());
m_WrapperWidget = new QWidget; //hack to display Ogre window in a tab
QWidget *pDocWidgetToAdd = NULL;
RBX::CRenderSettings::GraphicsMode graphicsMode = CRenderSettingsItem::singleton().getLatchedGraphicsMode();
if (graphicsMode != RBX::CRenderSettings::NoGraphics)
{
RBX::Log::current()->writeEntry(RBX::Log::Information,"\tInitializing Ogre");
m_pQOgreWidget = new QOgreWidget("QOgreWidget", m_WrapperWidget);
if (m_pMainWindow->getBuildMode() == BM_BASIC)
m_WrapperWidget->setMinimumSize(QSize(800, 600));
else
m_WrapperWidget->setMinimumSize(m_pQOgreWidget->minimumSize());
#ifdef _WIN32
//if the application is minimized then make sure m_WrapperWidget is shown (fix for DE5666)
if (m_pMainWindow->windowState() & Qt::WindowMinimized)
{
m_WrapperWidget->move(m_pMainWindow->width(), m_pMainWindow->height());
m_WrapperWidget->setVisible(true);
}
#endif
RBX::Log::current()->writeEntry(RBX::Log::Information,"\tInitializing View");
pDocWidgetToAdd = m_pQOgreWidget;
}
else
{
m_pDiagViewWidget = new RobloxDiagnosticsView(true);
RBX::Profiling::setEnabled(true);
pDocWidgetToAdd = m_pDiagViewWidget;
}
// Stage 2 - initialize controls, layout
if (DFInt::StudioWorkspaceNotificationLevel || DFFlag::WorkspaceNotificationMasterEnable)
{
UpdateUIManager::Instance().updateProgress(progressBar,2);
m_AnnouncementWidget = new WorkspaceAnnouncementTooltip(m_WrapperWidget);
QVBoxLayout *renderWindowLayout = new QVBoxLayout(m_WrapperWidget);
renderWindowLayout->setSpacing(0);
renderWindowLayout->setContentsMargins(0,0,0,0);
renderWindowLayout->addSpacerItem(new QSpacerItem(0,0,QSizePolicy::Maximum,QSizePolicy::Maximum));
renderWindowLayout->addWidget(m_AnnouncementWidget);
renderWindowLayout->addSpacerItem(new QSpacerItem(0,0,QSizePolicy::Maximum,QSizePolicy::Maximum));
renderWindowLayout->addWidget(pDocWidgetToAdd);
m_WrapperWidget->setLayout(renderWindowLayout);
}
else
{
UpdateUIManager::Instance().updateProgress(progressBar,2);
QHBoxLayout *renderWindowLayout = new QHBoxLayout(m_WrapperWidget);
renderWindowLayout->setSpacing(0);
renderWindowLayout->setContentsMargins(0,0,0,0);
renderWindowLayout->addSpacerItem(new QSpacerItem(0,0,QSizePolicy::Maximum,QSizePolicy::Maximum));
renderWindowLayout->addWidget(pDocWidgetToAdd);
renderWindowLayout->addSpacerItem(new QSpacerItem(0,0,QSizePolicy::Maximum,QSizePolicy::Maximum));
m_WrapperWidget->setLayout(renderWindowLayout);
}
if (StudioUtilities::isAvatarMode())
StudioDeviceEmulator::Instance().activateCurrentDevice();
createActionIDVerbMap(m_EditGame);
RBX::Log::current()->writeEntry(RBX::Log::Information,"\tInitializing Explorer");
m_EditGame.m_TreeWidget = new RobloxTreeWidget(m_EditGame.m_Game->getDataModel());
UpdateUIManager::Instance().getViewWidget<RobloxExplorerWidget>(eDW_OBJECT_EXPLORER).setCurrentWidget(m_EditGame.m_TreeWidget);
// Stage 3 - load file
UpdateUIManager::Instance().updateProgress(progressBar,3);
m_RequiresSave = false;
RBX::Log::current()->writeEntry(RBX::Log::Information,RBX::format("\tLoading File : %s",qPrintable(fileName)).c_str());
if (m_initializationScript.isEmpty())
{
QMetaObject::invokeMethod(&UpdateUIManager::Instance().getViewWidget<RobloxGameExplorer>(eDW_GAME_EXPLORER),
"nonGameLoaded", Qt::QueuedConnection);
}
if (fileName.isEmpty() && m_initializationScript.isEmpty())
{
//init debugger data
initializeDebuggerData(fileName, m_EditGame.m_Game->getDataModel());
sIDEDocCount++;
}
else
{
if (!asNew)
m_fileName = fileName;
loadFromStream(stream);
if (!m_initializationScript.isEmpty())
{
sIDEDocCount++;
m_bIsLocalDocument = false;
if (m_initializationScript.contains("testmode=false"))
m_TestModeEnabled = false;
// make sure we are authenticated before loading initialization scripts
AuthenticationHelper::Instance().waitForHttpAuthentication();
if (isCloudEditSession())
{
// Reset synchronized flags, they should be set by the server
FLog::ResetSynchronizedVariablesState();
boost::thread(boost::bind(&StudioUtilities::joinCloudEditSession,
m_EditGame.m_Game,
cloudEditJoinConfig));
initCloudEditObjects();
}
else if (RBX::ContentProvider::isUrl(m_initializationScript.toStdString()))
{
if (StudioUtilities::containsEditScript(m_initializationScript))
{
// if in EDIT mode, connect with workspaceLoadedSignal, so we can initialize debugger data
m_contentDataLoadedConnection = m_EditGame.m_Game->getDataModel()->workspaceLoadedSignal.connect(boost::bind(
&RobloxIDEDoc::onContentDataLoaded,
this));
isRemoteEditSession = true;
}
if (StudioUtilities::containsJoinScript(m_initializationScript))
{
// enable FRM in play mode
CRenderSettingsItem::singleton().setEnableFRM(true);
// Reset synchronized flags, they should be set by the server
FLog::ResetSynchronizedVariablesState();
if (StudioUtilities::isTestMode())
{
if (RBX::Network::Players* players = RBX::ServiceProvider::create<RBX::Network::Players>(getDataModel()))
{
m_localPlayerConnection = players->onDemandWrite()->childAddedSignal.connect(
boost::bind(&RobloxIDEDoc::onLocalPlayerAdded, this, _1) );
}
}
boost::thread(boost::bind(
&StudioUtilities::executeURLJoinScript,
m_EditGame.m_Game,
m_initializationScript.toStdString()));
}
else
{
boost::thread(boost::bind(
&StudioUtilities::executeURLScript,
m_EditGame.m_Game->getDataModel(),
m_initializationScript.toStdString()));
}
}
else
{
handleScriptCommand(m_initializationScript);
}
}
}
CSGDictionaryService* dictionaryService = ServiceProvider::create<CSGDictionaryService>(getDataModel());
NonReplicatedCSGDictionaryService* nrDictionaryService = ServiceProvider::create<NonReplicatedCSGDictionaryService>(getDataModel());
dictionaryService->refreshRefCount();
nrDictionaryService->refreshRefCount();
// Stage 4 - initialize terrain/undo
UpdateUIManager::Instance().updateProgress(progressBar,4);
// enable dock views (must be done before enabling undo/redo)
setDockViewsEnabled();
setTeamCreateWidgetEnabled(true);
if (m_bIsLocalDocument)
{
RBX::Log::current()->writeEntry(RBX::Log::Information,"\tInitializing Terrain");
m_EditGame.m_Game->getDataModel()->getWorkspace()->createTerrain();
// initialize PlayerScripts
StarterPlayerService* starterPlayerService = ServiceProvider::find<StarterPlayerService>(m_EditGame.m_Game->getDataModel()->getWorkspace());
if (starterPlayerService)
starterPlayerService->setupPlayerScripts();
RBX::Log::current()->writeEntry(RBX::Log::Information,"\tInitializing Undo");
enableUndo(m_pMainWindow->getBuildMode() == BM_ADVANCED);
// enable dynamic lighting for new places
if (fileName.isEmpty())
{
if (RBX::Lighting* lighting = RBX::ServiceProvider::create<RBX::Lighting>(m_EditGame.m_Game->getDataModel().get()))
{
lighting->setGlobalShadows(true);
lighting->setGlobalAmbient(G3D::Color3(0,0,0));
}
}
// enable smooth terrain for new places
if (fileName.isEmpty())
{
RBX::MegaClusterInstance* terrain = boost::polymorphic_downcast<RBX::MegaClusterInstance*>(m_EditGame.m_Game->getDataModel()->getWorkspace()->getTerrain());
terrain->convertToSmooth();
}
}
// Stage 5 - load plugins
UpdateUIManager::Instance().updateProgress(progressBar,5);
// finally load in plugins (we want these in local and online docs)
RBX::Log::current()->writeEntry(RBX::Log::Information,"\tLoading Plugins");
RobloxPluginHost::loadPlugins(m_EditGame.m_Game->getDataModel().get());
// Stage 6 - finish initialization
UpdateUIManager::Instance().updateProgress(progressBar,6);
m_EditGame.m_Game->getDataModel()->setDirty(false);
m_RequiresSave = false;
m_pRSFHandler.reset(new RecentlySavedFilesHandler());
// restore in-game stats display
RobloxSettings settings;
setStatsEnabled(StatsVerb,settings.value(StatsVerb,false).toBool(), m_pMainWindow->testStatsAction);
setStatsEnabled(RenderStatsVerb,settings.value(RenderStatsVerb,false).toBool(), m_pMainWindow->testRenderStatsAction);
setStatsEnabled(PhysicsStatsVerb,settings.value(PhysicsStatsVerb,false).toBool(), m_pMainWindow->testPhysicsStatsAction);
setStatsEnabled(NetworkStatsVerb,settings.value(NetworkStatsVerb,false).toBool(), m_pMainWindow->testNetworkStatsAction);
setStatsEnabled(SummaryStatsVerb,settings.value(SummaryStatsVerb,false).toBool(), m_pMainWindow->testSummaryStatsAction);
if (FFlag::StudioCustomStatsEnabled)
{
setStatsEnabled(CustomStatsVerb,settings.value(CustomStatsVerb,false).toBool(), m_pMainWindow->testCustomStatsAction);
}
// for now assume qt docs always have access to keyboard/mouse (we should handle this somewhere else in the future)
RBX::UserInputService* userInputService = m_EditGame.m_Game->getDataModel()->find<RBX::UserInputService>();
if (userInputService != NULL)
{
userInputService->setMouseEnabled(true);
userInputService->setKeyboardEnabled(true);
}
enableDownloadPlaceCopy(isCloudEditSession());
QDateTime lastDateTimeOpen = settings.value("LastIDEDocOpen").toDateTime();
if (lastDateTimeOpen.isNull())
{
UpdateUIManager::Instance().setDockVisibility(eDW_TOOLBOX, true);
UpdateUIManager::Instance().setDockVisibility(eDW_TUTORIALS, FFlag::StudioShowTutorialsByDefault);
}
settings.setValue("LastIDEDocOpen", QDateTime::currentDateTime());
// Fire off pre-fetching
if (FFlag::PrefetchResourcesEnabled)
{
RBX::Log::current()->writeEntry(RBX::Log::Information,"\tPrefetch Resources");
preFetchResources();
}
RBXASSERT(!m_bIsLocalDocument || !isRemoteEditSession);
if (m_bIsLocalDocument || isRemoteEditSession)
{
RobloxGoogleAnalytics::trackEvent(GA_CATEGORY_STUDIO, "BeginEdit",
m_bIsLocalDocument ? "LocalDocument" : "RemoteBackedDocument");
}
if (m_AnnouncementWidget)
{
displayWorkspaceMessage();
}
// Stage 7 - Done!
UpdateUIManager::Instance().updateProgress(progressBar,7);
RBX::Log::current()->writeEntry(RBX::Log::Information,"\tOpen Success");
}
catch(CreatePopupException &e)
{
RBX::Log::current()->writeEntry(RBX::Log::Information,RBX::format("\tPopup Exception : %s",qPrintable(e.m_message)).c_str());
QtUtilities::RBXMessageBox msgBox;
msgBox.setIcon(QMessageBox::Warning);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setText(e.m_message);
msgBox.exec();
success = false;
}
catch (std::exception& e)
{
RBX::Log::current()->writeEntry(RBX::Log::Information,RBX::format("\tException : %s",e.what()).c_str());
RBX::StandardOut::singleton()->print(RBX::MESSAGE_ERROR, e.what());
success = false;
}
UpdateUIManager::Instance().hideProgress(progressBar);
UpdateUIManager::Instance().setBusy(false);
// Be sure not to do this while studio is busy, or the enabled state will get lost
if (m_initializationScript.isEmpty())
{
UpdateUIManager::Instance().getViewWidget<RobloxGameExplorer>(eDW_GAME_EXPLORER).nonGameLoaded();
}
// make sure that we're not dirty, especially if we get any sort of error
// if it's dirty, the user will be prompted to save
m_RequiresSave = false;
if (m_EditGame.m_Game && m_EditGame.m_Game->getDataModel())
m_EditGame.m_Game->getDataModel()->setDirty(false);
if (!m_pFileWatcher && CRenderSettingsItem::singleton().getDebugReloadAssets())
{
m_pFileWatcher = new FW::FileWatcher();
// assets
m_pFileWatcher->addWatch(ContentProvider::assetFolder(), this, true);
// platform dependent assets
m_pFileWatcher->addWatch(ContentProvider::platformAssetFolder(), this, true);
// and shaders, Oh yeah!
std::string shaderFolder = QDir::cleanPath(QString((ContentProvider::assetFolder() + "/../shaders/source").c_str())).toStdString();
m_pFileWatcher->addWatch(shaderFolder, this, false);
}
RBX::Log::current()->writeEntry(RBX::Log::Information,"RobloxIDEDoc::open - end");
return success;
}
void RobloxIDEDoc::handleFileAction(FW::WatchID watchid, const FW::String& dir, const FW::String& filename, FW::Action action)
{
// we dont care about deleted file, we'll keep current data in that case
if (action == FW::Actions::Delete)
return;
std::string simpleFilename = QDir::fromNativeSeparators(QString(filename.c_str())).toStdString();
std::string absoluteDir = QDir::fromNativeSeparators(QString(dir.c_str())).toStdString();
std::string contentFolder = QDir::fromNativeSeparators(QString(ContentProvider::assetFolder().c_str())).toStdString();
std::string platformContentFolder = QDir::fromNativeSeparators(QString(ContentProvider::platformAssetFolder().c_str())).toStdString();
std::string pathStr;
if (absoluteDir.find(contentFolder) == 0 || absoluteDir.find(platformContentFolder) == 0)
pathStr = "rbxasset://" + simpleFilename;
else
pathStr = simpleFilename;
RBX::ViewBase* pView = (&m_CurrentGame->m_View->getViewBase());
pView->queueAssetReload(pathStr);
}
void RobloxIDEDoc::exportSelection(std::string filePath, ExporterSaveType exportType)
{
RBX::ViewBase* pView = (&m_CurrentGame->m_View->getViewBase());
QString fileName = filePath.c_str();
if (fileName.isEmpty())
fileName = QFileDialog::getSaveFileName(&UpdateUIManager::Instance().getMainWindow(), tr("Export Place"), "", "Object Model (*.obj)");
if (!fileName.isEmpty())
{
QFileInfo fileInfo(fileName);
if (fileInfo.suffix() == "obj")
{
QString exportAction = "Exporting Place";
if (exportType == ExporterSaveType_Selection)
exportAction = "Exporting Selection";
UpdateUIManager::Instance().setBusy(true);
RBX::BaldPtr<QProgressBar> progressBar = UpdateUIManager::Instance().showProgress(exportAction);
UpdateUIManager::Instance().updateProgress(progressBar);
pView->exportScene(fileInfo.absolutePath().toStdString() + "/" + fileInfo.baseName().toStdString(), exportType, ExporterFormat_Obj);
UpdateUIManager::Instance().hideProgress(progressBar);
UpdateUIManager::Instance().setBusy(false);
}
else
{
QMessageBox::critical(
m_pMainWindow,
"Export Failure",
QString("Obj filetype expected. '%1' received.").arg(fileInfo.suffix()));
}
}
}
void RobloxIDEDoc::onDMItemChanged(shared_ptr<RBX::Instance> item, const RBX::Reflection::PropertyDescriptor* descriptor)
{
if (descriptor == &RBX::PartOperation::prop_CollisionFidelity)
{
if (PartOperation* partOp = item->fastDynamicCast<PartOperation>())
{
if (CSGDictionaryService* dictionaryService = ServiceProvider::create<CSGDictionaryService>(RBX::DataModel::get(partOp)))
{
if (!RBX::DataModel::get(partOp)->isRunMode())
{
partOp->createPhysicsData(partOp->getMesh().get());
}
}
}
}
}
void RobloxIDEDoc::enableUndo(bool enable)
{
//undo redo manager.
RBX::ChangeHistoryService* chs = m_CurrentGame->m_Game->getDataModel()->create<RBX::ChangeHistoryService>();
chs->setEnabled(true);
if (enable)
m_CurrentGame->m_ChangeHistoryConnection = chs->waypointChangedSignal.connect(boost::bind(&RobloxIDEDoc::onWaypointChanged,this));
else
m_CurrentGame->m_ChangeHistoryConnection.disconnect();
}
IRobloxDoc::RBXCloseRequest RobloxIDEDoc::requestClose()
{
RBX::DataModel::RequestShutdownResult shutdownRequestResult;
{
RBX::DataModel::LegacyLock lock(m_EditGame.m_Game->getDataModel(), RBX::DataModelJob::Write);
// If we're in full screen build mode, call back to LUA for save as opposed to doing QT save dialog
shutdownRequestResult = m_EditGame.m_Game->getDataModel()->requestShutdown(m_pMainWindow->getBuildMode() == BM_BASIC);
}
switch (shutdownRequestResult)
{
case RBX::DataModel::CLOSE_REQUEST_HANDLED:
return IRobloxDoc::REQUEST_HANDLED;
case RBX::DataModel::CLOSE_NOT_HANDLED:
break;
case RBX::DataModel::CLOSE_NO_SAVE_NEEDED:
if (!m_TestModeEnabled)
return IRobloxDoc::LOCAL_SAVE_NEEDED;
return IRobloxDoc::NO_SAVE_NEEDED;
case RBX::DataModel::CLOSE_LOCAL_SAVE:
return IRobloxDoc::LOCAL_SAVE_NEEDED;
}
KeepSavedChangesDialog* keepSavedChangesDialog = new KeepSavedChangesDialog(m_pMainWindow);
keepSavedChangesDialog->exec();
KeepSavedChangesDialog::DialogResult result = keepSavedChangesDialog->getResult();
delete keepSavedChangesDialog;
switch (result)
{
case KeepSavedChangesDialog::Fail:
{
QtUtilities::RBXMessageBox msgBox;
msgBox.setIcon(QMessageBox::Warning);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setText("Failed to save place online. Check your connection and try again.");
msgBox.exec();
return IRobloxDoc::CLOSE_CANCELED;
}
case KeepSavedChangesDialog::Discard:
case KeepSavedChangesDialog::Save:
{
return IRobloxDoc::NO_SAVE_NEEDED;
}
case KeepSavedChangesDialog::Cancel:
default:
{
return IRobloxDoc::CLOSE_CANCELED;
}
}
return IRobloxDoc::NO_SAVE_NEEDED;
}
bool RobloxIDEDoc::doClose()
{
MobileDevelopmentDeployer::singleton().disconnectClientsAndShutDown();
//reset debugger data
if (FFlag::LuaDebugger)
{
RBX::Scripting::DebuggerManager::singleton().setDataModel(NULL);
DebuggerClientManager::Instance().setDataModel(boost::shared_ptr<RBX::DataModel>());
//make sure we remove debugger file if we are in test mode
if (StudioUtilities::isTestMode())
QFile::remove(getDebugInfoFile());
m_EditDebuggersMap.clear();
}
if (m_pRSFHandler)
{
shared_ptr<RBX::DataModel> dataModel = getEditDataModel();
if (dataModel && dataModel->isDirty())
{
QString fileToSave = getRecentSaveFile();
if (!fileToSave.isEmpty() && StudioSerializerHelper::saveAsIfModified(m_initialDataModelHash, dataModel.get(), fileToSave))
m_pRSFHandler->addFile(fileToSave);
}
}
if (m_AnnouncementWidget)
{
m_AnnouncementWidget->deleteLater();
m_AnnouncementWidget = NULL;
}
if (m_pQOgreWidget)
{
m_pQOgreWidget->setRobloxView(NULL);
m_pQOgreWidget->deleteLater();
m_pQOgreWidget = NULL;
}
if (m_pDiagViewWidget)
{
m_pDiagViewWidget->setDataModel(boost::shared_ptr<RBX::DataModel>());
m_pDiagViewWidget->deleteLater();
m_pDiagViewWidget = NULL;
}
if (m_WrapperWidget)
{
m_WrapperWidget->deleteLater();
m_WrapperWidget = NULL;
}
setTeamCreateWidgetEnabled(false);
cleanupGameState(m_PlayGame);
cleanupGameState(m_EditGame);
UpdateUIManager::Instance().getViewWidget<RobloxExplorerWidget>(eDW_OBJECT_EXPLORER).setCurrentWidget(NULL);
// only delete autosave if we have an autosave and we did not load from an autosave
// if we loaded from an autosave, we're going to keep using the same autosave but we're
// not going to blow it away on close.
FASTLOGS(FLog::AutoSave, "Autosave name: %s", m_AutoSaveName.toStdString());
FASTLOG1(FLog::AutoSave, "Is auto save loaded: %u", m_IsAutoSaveLoad);
if (!m_AutoSaveName.isEmpty() && !m_IsAutoSaveLoad)
{
FASTLOG(FLog::AutoSave, "Removing auto save on successful exit");
QFile::remove(m_AutoSaveName);
//also remove the auto save debug file
if (FFlag::LuaDebugger)
QFile::remove(getDebugInfoFile(true));
m_AutoSaveName.clear();
m_IsAutoSaveLoad = false;
}
enableDownloadPlaceCopy(false);
UpdateUIManager::Instance().getViewWidget<RobloxGameExplorer>(eDW_GAME_EXPLORER).onCloseIdeDoc();
if (m_pFileWatcher)
{
delete m_pFileWatcher;
m_pFileWatcher = NULL;
}
//self deletion (maybe we must use reference counting!)
delete this;
return true;
}
void RobloxIDEDoc::cleanupGameState(GameState& gameState)
{
m_CurrentGame = &gameState;
gameState.m_ChangeHistoryConnection.disconnect();
if (gameState.m_Game && gameState.m_Game->getDataModel())
{
// cleanup all dock views
setDockViewsEnabled(false);
// clean up verbs
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
RBX::DataModel::LegacyLock lock(dataModel,RBX::DataModelJob::Write);
QVector<RBX::Verb*>::iterator iter = gameState.m_Verbs.begin();
while (iter != gameState.m_Verbs.end())
{
delete *iter;
++iter;
}
gameState.m_Verbs.clear();
gameState.m_UndoVerb = NULL;
gameState.m_RedoVerb = NULL;
#ifdef _WIN32
gameState.m_RecordToggleVerb = NULL;
#endif
dataModel->getWorkspace()->getAdornableCollector()->onRenderableDescendantRemoving(&gameState.m_SelectionHighlightAdornable);
}
// remove tree view
if (gameState.m_TreeWidget)
{
m_pMainWindow->treeWidgetStack().removeWidget(gameState.m_TreeWidget);
gameState.m_TreeWidget->requestDelete();
gameState.m_TreeWidget = NULL;
UpdateUIManager::Instance().getViewWidget<RobloxExplorerWidget>(eDW_OBJECT_EXPLORER).setCurrentWidget(NULL);
}
// shut down UI and plugins
if (gameState.m_Game && gameState.m_Game->getDataModel())
{
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
{
RBX::DataModel::LegacyLock lock(dataModel,RBX::DataModelJob::Write);
if (gameState.m_View)
{
delete gameState.m_View;
gameState.m_View = NULL;
}
}
gameState.m_Game->shutdown();
// Clean up plugins after the datamodel has closed (closing the datamodel ensures that
// no more plugin scripts are running)
RBX::PluginManager::singleton()->deletePlugins(dataModel.get());
gameState.m_Game.reset();
}
}
bool RobloxIDEDoc::loadFromStream(std::istream* stream)
{
if (!stream)
return false;
RBX::Security::Impersonator impersonate(RBX::Security::COM);
shared_ptr<DataModel> dm = m_EditGame.m_Game->getDataModel();
RBX::DataModel::LegacyLock lock(dm, RBX::DataModelJob::Write);
Serializer serializer;
serializer.load(*stream, dm.get());
// For live games, the gameserver script sets the place id and universe id
// before calling game:Load(placeid). loadFromStream() is taking the place of
// game:Load(), and game loading needs to happen before gameserver.ashx finishes,
// so as a workaround we use this attempt at url parsing to pull the place and
// universe id out of the gameserver script request so that they are set in the
// data model before we attempt load linked scripts.
QRegExp universeIdInGameServer(".*gameserver\\.ashx.*\\((\\d+).*(\\d+)\\).*");
universeIdInGameServer.setCaseSensitivity(Qt::CaseInsensitive);
if (universeIdInGameServer.indexIn(m_initializationScript) != -1)
{
int placeId = universeIdInGameServer.cap(1).toInt();
int universeId = universeIdInGameServer.cap(2).toInt();
dm->setPlaceID(placeId, false);
dm->setUniverseId(universeId);
}
LuaSourceContainer::blockingLoadLinkedScripts(dm->create<ContentProvider>(), dm.get());
//init debugger data (in local document or play solo mode)
if (m_initializationScript.isEmpty() || StudioUtilities::containsVisitScript(m_initializationScript))
initializeDebuggerData(getDebugInfoFile(), dm);
dm->processAfterLoad();
if (DFFlag::MaterialPropertiesEnabled)
{
RBXASSERT(!m_workspacePropertyChangedConnection.connected());
m_workspacePropertyChangedConnection = getEditDataModel()->getWorkspace()->propertyChangedSignal.connect(boost::bind(&RobloxIDEDoc::onWorkspacePropertyChanged, this, _1));
}
//Migrating CSG childData
CSGDictionaryService* dictionaryService = dm->create<CSGDictionaryService>();
ChangeHistoryService* changeHistory = dm->create<ChangeHistoryService>();
if (FFlag::CSGPhysicsLevelOfDetailEnabled)
{
RBXASSERT(!m_dataModelItemChangedConnection.connected());
m_dataModelItemChangedConnection = getEditDataModel()->itemChangedSignal.connect(boost::bind(&RobloxIDEDoc::onDMItemChanged, this, _1, _2));
}
dictionaryService->reparentAllChildData();
changeHistory->resetBaseWaypoint();
searchToolboxByDefaultSearchString();
return true;
}
void RobloxIDEDoc::preFetchResources()
{
RBX::Verb* verb = getVerb(m_EditGame,"publishToRobloxAsAction");
if(verb) {
PublishToRobloxAsVerb* publishVerb = static_cast<PublishToRobloxAsVerb*>(verb);
publishVerb->initDialog();
}
}
QString RobloxIDEDoc::displayName() const
{
if (m_fileName.isEmpty())
return m_displayName;
if (StudioUtilities::isTestMode() && !StudioUtilities::isAvatarMode() && StudioUtilities::containsGameServerScript(m_initializationScript))
return "Server";
return QFileInfo(m_fileName).fileName();
}
QString RobloxIDEDoc::windowTitle() const
{
if (m_windowTitlePrefix.isEmpty() && m_initializationScript.isEmpty())
{
// local file
if (!m_fileName.isEmpty())
return QDir::toNativeSeparators(m_fileName);
// new file
if (m_initializationScript.isEmpty())
return kNewPlaceWindowTitle;
}
QString title = displayName();
title.prepend(m_windowTitlePrefix);
// remove appended time stamp if any from the title
int index = title.lastIndexOf(" @ ");
if (index > 0)
title = title.left(index);
return title;
}
QWidget* RobloxIDEDoc::getViewer()
{
return m_WrapperWidget;
}
/**
* Checks if the data model is dirty or if we require a save.
* The data model might not be dirty if we auto-saved.
*/
bool RobloxIDEDoc::isModified()
{
applyScriptChanges();
if (StudioUtilities::isTestMode())
return false;
else if (m_RequiresSave)
return true;
// do not show save as dialog for cloud edit
if (isCloudEditSession())
return false;
shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
if (!dataModel)
{
RBXASSERT(false);
return false;
}
RBX::DataModel::LegacyLock lock(dataModel, RBX::DataModelJob::Read);
return dataModel->isDirty() && m_initialDataModelHash != StudioSerializerHelper::getDataModelHash(dataModel.get());
}
/**
* Checks if the game is currently stopped.
* Paused is still considered "running".
*/
bool RobloxIDEDoc::isSimulating()
{
if (!m_PlayGame.m_Game || !m_PlayGame.m_Game->getDataModel() || !m_PlayGame.m_Game->getDataModel()->create<RBX::RunService>())
return false;
RBX::RunState runState = m_PlayGame.m_Game->getDataModel()->create<RBX::RunService>()->getRunState();
return runState != RBX::RS_STOPPED;
}
bool RobloxIDEDoc::save()
{
bool result = saveAs(m_fileName);
m_EditGame.m_Game->getDataModel()->setDirty(!result);
return result;
}
void RobloxIDEDoc::createScriptMapping(shared_ptr<RBX::Instance> instance)
{
if (RBX::Instance::fastSharedDynamicCast<RBX::Script>(instance) || RBX::Instance::fastSharedDynamicCast<RBX::ModuleScript>(instance))
{
addScriptMapping(instance, m_PlayGame.m_Game->getDataModel());
}
}
void RobloxIDEDoc::restoreEditModelScripts()
{
RBX::DataModel::LegacyLock lock(m_EditGame.m_Game->getDataModel(), RBX::DataModelJob::Write);
// Copy the open script docs list because each script doc will have its script
// reset, and resetting the script changes the master script doc list (mutating the list
// while iterating through it).
const tScriptDocs openScriptDocs = RobloxDocManager::Instance().getOpenScriptDocs();
for (tScriptDocs::const_iterator iter = openScriptDocs.begin(); iter != openScriptDocs.end() ; ++iter)
{
shared_ptr<RBX::Instance> playInstance = (*iter)->getCurrentScript().toInstance();
if (playInstance == NULL)
{
continue;
}
shared_ptr<RBX::Instance> instance = getEditScriptByPlayInstance(playInstance.get());
if (instance && instance->isDescendantOf(m_EditGame.m_Game->getDataModel().get()))
{
LuaSourceBuffer buffer = LuaSourceBuffer::fromInstance(instance);
(*iter)->setScript(m_EditGame.m_Game->getDataModel(), buffer);
}
else
{
// use RobloxDocManager::removeDoc for proper cleanup of documents
if ((*iter) == RobloxDocManager::Instance().getCurrentDoc())
{
// if script doc is current then make sure we ignore IDE doc activate while removing script doc
// IDE doc will be activated in RobloxIDEDoc::closePlayDataModel
RBX::ScopedAssign<bool> ignoreDocActivate(m_bActive, true);
RobloxDocManager::Instance().removeDoc(**iter);
}
else
{
RobloxDocManager::Instance().removeDoc(**iter);
}
}
}
clearScriptMap();
}
void RobloxIDEDoc::patchPlayModelScripts()
{
// Build a script mapping for each script in the Edit Data Model.
RBX::DataModel* dm = m_EditGame.m_Game->getDataModel().get();
dm->visitDescendants(boost::bind(&RobloxIDEDoc::createScriptMapping, this, _1));
// Replace Edit scripts with Play scripts.
// Copy the open script docs list because each script doc will have its script
// reset, and resetting the script changes the master script doc list (mutating the list
// while iterating through it).
const tScriptDocs openScriptDocs = RobloxDocManager::Instance().getOpenScriptDocs();
for (tScriptDocs::const_iterator iter = openScriptDocs.begin(); iter != openScriptDocs.end() ; ++iter)
{
shared_ptr<RBX::Instance> backingInstance = (*iter)->getCurrentScript().toInstance();
if (backingInstance == NULL)
{
continue;
}
std::vector<int> indexHierarchy;
std::string serviceName = getScriptIndexHierarchy(backingInstance, indexHierarchy);
shared_ptr<RBX::Instance> instance = getScriptByIndexHierarchy(m_PlayGame.m_Game->getDataModel(), indexHierarchy, serviceName);
if (instance)
{
LuaSourceBuffer buffer = LuaSourceBuffer::fromInstance(instance);
if (!buffer.empty())
(*iter)->setScript(m_PlayGame.m_Game->getDataModel(), buffer);
}
}
}
bool RobloxIDEDoc::saveScriptsChangedWhileTesting()
{
bool saveChanges = true;
tPlayModifiedScriptList& playModifiedScriptList = getPlayModifiedScriptList();
if (playModifiedScriptList.size() > 0 && !isCloudEditSession())
{
saveChanges = AuthoringSettings::singleton().alwaysSaveScriptChangesWhileRunning;
if (!saveChanges)
{
UpdateUIManager::Instance().setBusy(true, false);
QtUtilities::RBXMessageBox msgBox;
msgBox.setIcon(QMessageBox::Question);
msgBox.setText("You've made script changes while playing. Would you like to keep these changes?");
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
msgBox.setDefaultButton(QMessageBox::Yes);
QPushButton *alwaysButton = msgBox.addButton(tr("Always Save"), QMessageBox::ActionRole);
int ret = msgBox.exec();
UpdateUIManager::Instance().setBusy(false, false);
if (msgBox.clickedButton() == alwaysButton)
{
AuthoringSettings::singleton().alwaysSaveScriptChangesWhileRunning = true;
RBX::GlobalAdvancedSettings::singleton()->saveState();
RBX::RobloxGoogleAnalytics::trackEvent(GA_CATEGORY_COUNTERS, "LiveCoding", "SaveDialogAlways", 1);
saveChanges = true;
}
if (ret == QMessageBox::Yes)
{
RBX::RobloxGoogleAnalytics::trackEvent(GA_CATEGORY_COUNTERS, "LiveCoding", "SaveDialogYes", 1);
saveChanges = true;
}
}
if (saveChanges)
{
RBX::RobloxGoogleAnalytics::trackEvent(GA_CATEGORY_COUNTERS, "LiveCoding", "Saves", 1);
applyScriptChanges();
RBX::DataModel::LegacyLock editLock(m_EditGame.m_Game->getDataModel(), RBX::DataModelJob::Write);
for (tPlayModifiedScriptList::iterator iter = playModifiedScriptList.begin(); iter != playModifiedScriptList.end(); ++iter)
{
shared_ptr<RBX::Instance> instance = getEditScriptByPlayInstance((*iter)->instance.get());
if (!instance)
continue;
LuaSourceBuffer sourceBuffer = LuaSourceBuffer::fromInstance((*iter)->instance);
LuaSourceBuffer destBuffer = LuaSourceBuffer::fromInstance(instance);
destBuffer.setScriptText(sourceBuffer.getScriptText());
}
}
clearPlayModifiedScriptList();
}
return saveChanges;
}
bool RobloxIDEDoc::saveAs(const QString& fileName)
{
QMutexLocker locker(&m_IOMutex);
saveScriptsChangedWhileTesting();
const bool useBinaryFormat = !(fileName.endsWith(".rbxlx", Qt::CaseInsensitive));
const bool isAutoSave = fileName == m_AutoSaveName;
if(isAutoSave)
{
FASTLOGS(FLog::AutoSave, "Saving AutoSave, filename: %s", fileName.toStdString());
}
shared_ptr<RBX::Game> game = m_EditGame.m_Game;
QString errorMessage;
bool result = StudioSerializerHelper::saveAs(
fileName,
isAutoSave ? "Auto-Saving" : "Saving",
isAutoSave,
useBinaryFormat,
game->getDataModel().get(),
errorMessage,
!isAutoSave);
if (result)
{
// modify dirty flag only for local document, we need to force saving in case of Build/Edit (DE4302)
if (m_bIsLocalDocument)
{
if (game->getDataModel()->isDirty())
m_RequiresSave = (fileName == m_AutoSaveName);
if (!FFlag::NoPromptOnAlreadySavedPlace)
{
if (game->getDataModel()->isDirty() && (fileName != m_AutoSaveName))
resetDirty(game->getDataModel().get());
}
}
if (FFlag::NoPromptOnAlreadySavedPlace)
{
if (game->getDataModel()->isDirty() && (fileName != m_AutoSaveName))
resetDirty(game->getDataModel().get());
}
// if we changed file names and it's not the autosave file name
if (fileName != m_fileName && fileName != m_AutoSaveName && !isCloudEditSession())
{
FASTLOGS(FLog::AutoSave, "Filename changed, remove auto save. New file: %s", fileName.toStdString());
FASTLOGS(FLog::AutoSave, "Old file: %s", m_fileName.toStdString());
FASTLOGS(FLog::AutoSave, "Old autoSave file: %s", m_AutoSaveName.toStdString());
// if we have an autosave, we can delete it now
if (!m_AutoSaveName.isEmpty())
{
FASTLOG(FLog::AutoSave, "Removing old autosave");
QFile::remove(m_AutoSaveName);
m_AutoSaveName.clear();
// if we loaded from an autosave, we have a real file name now and can delete the autosave at end
m_IsAutoSaveLoad = false;
}
m_fileName = fileName;
RobloxDocManager::Instance().setDocTitle(*this,displayName(),titleTooltip(),titleIcon());
}
if (isAutoSave)
m_pMainWindow->statusBar()->showMessage("Auto-Save Success",3000);
else
m_pMainWindow->statusBar()->showMessage("Save File Success",5000);
if (isAutoSave && m_pRSFHandler)
{
QString recentSaveFile = getRecentSaveFile();
if (m_fileName == recentSaveFile)
m_pRSFHandler->removeFile(recentSaveFile);
}
return true;
}
else
{
QMessageBox::critical(
m_pMainWindow,
"Save File Failure",
errorMessage);
m_pMainWindow->statusBar()->showMessage("Save File Failure",5000);
return false;
}
}
void RobloxIDEDoc::activate()
{
if (m_bActive)
return;
if (m_pQOgreWidget)
m_pQOgreWidget->activate();
shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
if (m_pDiagViewWidget)
m_pDiagViewWidget->setDataModel(dataModel);
if ( !m_pMainWindow->isRibbonStyle() ) // We never hide the plugins on ribbon mode
{
RBX::PluginManager::singleton()->disableStudioUI(dataModel.get(), false);
}
RBX::PluginManager::singleton()->setCurrentDataModel(dataModel.get());
// Init Find Replace dialogs
UpdateUIManager::Instance().getViewWidget<RobloxExplorerWidget>(eDW_OBJECT_EXPLORER).setCurrentWidget(m_CurrentGame->m_TreeWidget);
if (dataModel)
{
RBX::Workspace* workspace = dataModel->getWorkspace();
if (workspace)
{
workspace->setShowAxisWidget(UpdateUIManager::Instance().get3DAxisEnabled());
workspace->setShow3DGrid(UpdateUIManager::Instance().get3DGridEnabled());
}
m_pMainWindow->insertServiceDialog().setDataModel(dataModel);
m_pMainWindow->insertServiceAction->setEnabled(m_pMainWindow->insertServiceDialog().isAvailable());
}
// load settings
QSettings settings;
// load the grid mode setting
setDraggerGridMode((RBX::DRAG::DraggerGridMode)settings.value(DraggerGridModeSetting, RBX::DRAG::ONE_STUD).toInt());
setGridSize(settings.value(GridSizeSetting, 4).toInt());
//update toobars
UpdateUIManager::Instance().updateToolBars();
updateUndoRedo();
m_bActive = true;
}
void RobloxIDEDoc::deActivate()
{
if (!m_bActive)
return;
#ifdef _WIN32
if (m_CurrentGame->m_RecordToggleVerb && m_CurrentGame->m_RecordToggleVerb->isRecording())
m_CurrentGame->m_RecordToggleVerb->stopRecording(false);
#endif
if (m_pQOgreWidget)
m_pQOgreWidget->deActivate();
if (m_pDiagViewWidget)
m_pDiagViewWidget->setDataModel(boost::shared_ptr<RBX::DataModel>());
if (!m_pMainWindow->isRibbonStyle()) // We never hide the plugins on ribbon mode
{
RBX::PluginManager::singleton()->disableStudioUI(m_CurrentGame->m_Game->getDataModel().get(),true);
}
if (FFlag::StudioEmbeddedFindDialogEnabled)
{
FindReplaceProvider::instance().getEmbeddedFindDialog()->hide();
}
else
{
FindReplaceProvider::instance().getFindDialog()->hide();
FindReplaceProvider::instance().getReplaceDialog()->hide();
}
// save settings
QSettings settings;
settings.setValue(DraggerGridModeSetting,RBX::AdvArrowTool::advGridMode);
settings.setValue(GridSizeSetting, (int)m_CurrentGame->m_Game->getDataModel()->getWorkspace()->gridSizeModifier);
// reset the tooltips for undo/redo
m_pMainWindow->undoAction->setToolTip(tr("Undo"));
QtUtilities::setActionShortcuts(*m_pMainWindow->undoAction,QKeySequence::keyBindings(QKeySequence::Undo));
m_pMainWindow->redoAction->setToolTip(tr("Redo"));
QtUtilities::setActionShortcuts(*m_pMainWindow->redoAction,QKeySequence::keyBindings(QKeySequence::Redo));
m_bActive = false;
}
void RobloxIDEDoc::setDockViewsEnabled(bool state)
{
// update tree widget
if (m_CurrentGame->m_TreeWidget)
state ? m_CurrentGame->m_TreeWidget->activate() : m_CurrentGame->m_TreeWidget->deActivate();
// update rest of the views
shared_ptr<RBX::DataModel> dataModel = state ? m_CurrentGame->m_Game->getDataModel() : shared_ptr<RBX::DataModel>();
UpdateUIManager& uiManager = UpdateUIManager::Instance();
RobloxPropertyWidget& property_view = uiManager.getViewWidget<RobloxPropertyWidget>(eDW_PROPERTIES);
property_view.setDataModel(dataModel);
RobloxDiagnosticsView& diagnostics_view = uiManager.getViewWidget<RobloxDiagnosticsView>(eDW_DIAGNOSTICS);
diagnostics_view.setDataModel(dataModel);
RobloxScriptReview& script_view = uiManager.getViewWidget<RobloxScriptReview>(eDW_SCRIPT_REVIEW);
script_view.setDataModel(dataModel);
RobloxToolBox& toolbox_view = uiManager.getViewWidget<RobloxToolBox>(eDW_TOOLBOX);
toolbox_view.setDataModel(dataModel);
InsertObjectWidget& basic_view = uiManager.getViewWidget<InsertObjectWidget>(eDW_BASIC_OBJECTS);
basic_view.setDataModel(dataModel);
ScriptAnalysisWidget& analysis_view = uiManager.getViewWidget<ScriptAnalysisWidget>(eDW_SCRIPT_ANALYSIS);
analysis_view.setDataModel(dataModel);
if (!state)
{
RobloxFindWidget& find_view = uiManager.getViewWidget<RobloxFindWidget>(eDW_FIND);
find_view.dataModelClosing();
}
}
void RobloxIDEDoc::onWaypointChanged()
{
QMetaObject::invokeMethod(this,"updateUndoRedo",Qt::QueuedConnection);
}
void RobloxIDEDoc::updateUndoRedo()
{
RBXASSERT(m_CurrentGame->m_Game);
RBXASSERT(m_CurrentGame->m_Game->getDataModel());
if (!m_CurrentGame->m_UndoVerb || !m_CurrentGame->m_RedoVerb) // Possible on closing down Play Doc
return;
m_pMainWindow->undoAction->setEnabled(m_CurrentGame->m_UndoVerb->isEnabled());
m_pMainWindow->redoAction->setEnabled(m_CurrentGame->m_RedoVerb->isEnabled());
QString tooltip;
QList<QKeySequence> shortcuts;
shortcuts = m_pMainWindow->undoAction->shortcuts();
tooltip = m_CurrentGame->m_UndoVerb->getText().c_str();
tooltip += " (";
for (int i = 0 ; i < shortcuts.size() ; ++i)
{
if (i > 0)
tooltip += ", ";
tooltip += shortcuts[i].toString(QKeySequence::NativeText);
}
tooltip += ")";
m_pMainWindow->undoAction->setToolTip(tooltip);
shortcuts = m_pMainWindow->redoAction->shortcuts();
tooltip = m_CurrentGame->m_RedoVerb->getText().c_str();
tooltip += " (";
for (int i = 0 ; i < shortcuts.size() ; ++i)
{
if (i > 0)
tooltip += ", ";
tooltip += shortcuts[i].toString(QKeySequence::NativeText);
}
tooltip += ")";
m_pMainWindow->redoAction->setToolTip(tooltip);
}
void RobloxIDEDoc::mapActionIDWithVerb(GameState& gameState,const QString &actionID, const RBX::Name &verbName)
{
gameState.m_VerbMap[actionID] = &verbName;
}
void RobloxIDEDoc::mapActionIDWithVerb(GameState& gameState,const QString &actionID, const RBX::Verb *pVerb)
{
if (pVerb)
mapActionIDWithVerb(gameState, actionID, pVerb->getName());
}
void RobloxIDEDoc::mapActionIDWithVerb(GameState& gameState,const QString &actionID, const char *verbName)
{
if (verbName)
mapActionIDWithVerb(gameState, actionID, RBX::Name::lookup(verbName));
}
bool RobloxIDEDoc::handleDrop(const QString &fileName)
{
if (fileName.isEmpty())
return false;
if (fileName.endsWith(".rbxm", Qt::CaseInsensitive) || fileName.endsWith(".rbxmx", Qt::CaseInsensitive))
{
try
{
StudioUtilities::insertModel(m_CurrentGame->m_Game->getDataModel(), fileName, false);
}
catch (std::exception& e)
{
RBX::StandardOut::singleton()->print(RBX::MESSAGE_ERROR, e.what());
}
}
return true;
}
bool RobloxIDEDoc::doHandleAction(const QString& actionID, bool isChecked)
{
// TODO: Specific actions -- should this be moved to a separate function if more such actions?
UpdateUIManager& uiManager = UpdateUIManager::Instance();
if (uiManager.isLongProcessInProgress())
return false;
shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
if (actionID == "startPlayerAction" ||
actionID == "startServerAction" ||
actionID == "startServerAndPlayersAction" ||
actionID == "playSoloAction")
{
applyScriptChanges();
}
else if (actionID == "viewDiagnosticsAction")
{
if (dataModel)
{
RobloxDiagnosticsView& diagnostics_view = uiManager.getViewWidget<RobloxDiagnosticsView>(eDW_DIAGNOSTICS);
diagnostics_view.setDataModel(dataModel);
}
}
else if (actionID == "viewScriptPerformanceAction")
{
if (dataModel)
{
RobloxScriptReview& script_view = uiManager.getViewWidget<RobloxScriptReview>(eDW_SCRIPT_REVIEW);
script_view.setDataModel(dataModel);
}
}
else if (actionID == "actionUpdateStatusBar")
{
if (dataModel)
{
double time = dataModel->getGameTime();
QString timeLabel;
timeLabel.sprintf("t %.4g", time);
QString fpsLabel;
if (m_CurrentGame->m_View && m_CurrentGame->m_View->getViewBase().getFrameRateManager())
{
double fps = m_CurrentGame->m_View->getViewBase().getFrameRateManager()->GetFrameTimeAverage();
if (AuthoringSettings::singleton().renderThrottlePercentage >= 100 && !m_pQOgreWidget->hasApplicationFocus())
fpsLabel.sprintf("0fps");
else
fpsLabel.sprintf("%.3gfps",1000.0 / fps);
}
UpdateUIManager::Instance().setStatusLabels(timeLabel, fpsLabel);
}
}
else if (actionID == "viewToolboxAction")
{
if (dataModel)
{
RobloxToolBox& toolbox_view = uiManager.getViewWidget<RobloxToolBox>(eDW_TOOLBOX);
toolbox_view.setDataModel(dataModel);
}
}
else if (actionID == "viewBasicObjectsAction")
{
if (dataModel)
{
InsertObjectWidget& basic_view = uiManager.getViewWidget<InsertObjectWidget>(eDW_BASIC_OBJECTS);
basic_view.setDataModel(dataModel);
}
}
else if (actionID == "testStatsAction")
{
toggleStats(StatsVerb);
return true;
}
else if (actionID == "testRenderStatsAction")
{
toggleStats(RenderStatsVerb);
return true;
}
else if (actionID == "testPhysicsStatsAction")
{
toggleStats(PhysicsStatsVerb);
return true;
}
else if (actionID == "testNetworkStatsAction")
{
toggleStats(NetworkStatsVerb);
return true;
}
else if (actionID == "testSummaryStatsAction")
{
toggleStats(SummaryStatsVerb);
return true;
}
else if (actionID == "testCustomStatsAction" && FFlag::StudioCustomStatsEnabled)
{
toggleStats(CustomStatsVerb);
return true;
}
else if (actionID == "testClearStatsAction")
{
setStatsEnabled(StatsVerb,false, m_pMainWindow->testStatsAction);
setStatsEnabled(RenderStatsVerb,false, m_pMainWindow->testRenderStatsAction);
setStatsEnabled(PhysicsStatsVerb,false, m_pMainWindow->testPhysicsStatsAction);
setStatsEnabled(NetworkStatsVerb,false, m_pMainWindow->testNetworkStatsAction);
setStatsEnabled(SummaryStatsVerb,false, m_pMainWindow->testSummaryStatsAction);
setStatsEnabled(CustomStatsVerb,false, m_pMainWindow->testCustomStatsAction);
}
else if (FFlag::StudioSeparateActionByActivationMethod && actionID == "minimizeRibbonAction" && UpdateUIManager::Instance().getMainWindow().isRibbonStyle())
{
if (RobloxRibbonMainWindow* mainWindow = static_cast<RobloxRibbonMainWindow*>(&UpdateUIManager::Instance().getMainWindow()))
{
mainWindow->toggleRibbonMinimize();
return true;
}
}
else if (FFlag::StudioSeparateActionByActivationMethod && actionID == "quickInsertAction")
{
UpdateUIManager::Instance().onQuickInsertFocus();
return true;
}
else if (actionID == "materialActionAsTool")
{
StudioMaterialVerb::sMaterialActionActAsTool = isChecked;
RobloxSettings().setValue("rbxMaterialActionActAsTool", isChecked);
// reset mouse command if material tool is active
if (!isChecked)
resetMouseCommand("Material");
return true;
}
else if (actionID == "colorFillActionAsTool")
{
StudioColorVerb::sColorActionActAsTool = isChecked;
RobloxSettings().setValue("rbxColorActionActAsTool", isChecked);
// reset mouse command if fill tool is active
if (!isChecked)
resetMouseCommand("Fill");
return true;
}
else if (isCloudEditSession() && actionID == "downloadPlaceCopyAction")
{
downloadPlaceCopy();
return true;
}
QString actionIDToLookFor(actionID);
//split the QString to check if it need preProcessVerb
QStringList tokens = actionID.split("_");
//if it is a color change action, do the preProcessVerb to set rgb values, and change action to Fill automatically.
if (tokens.length() > 1)
{
preProcessVerb(tokens);
actionIDToLookFor = tokens[0];
}
if (!m_CurrentGame->m_VerbMap.contains(actionIDToLookFor))
{
IExternalHandler* pHandler = getExternalHandler(actionID);
if (pHandler)
{
RBX::DataModel::LegacyLock lock(dataModel, RBX::DataModelJob::Write);
pHandler->setDataModel(dataModel);
return pHandler->handle();
}
return false;
}
try
{
// DE2875: Doing a lock here leads to a hang with modal dialogs, if a lock is must then it has to be inside the verb!
static QString noLockVerbs(
"insertModelAction insertIntoFileAction selectionSaveToFileAction playSoloAction "
"startServerAction startPlayerAction publishToRobloxAction publishToRobloxAsAction "
"publishSelectionToRobloxAction saveToRobloxAction undoAction redoAction "
"publishAsPluginAction openToolBoxWithOptions pairRbxDeviceAction pairRbxDevDeviceAction manageEmulationDeviceAction "
"createNewLinkedSourceAction unionSelectionAction separateSelectionAction");
static QString noLockVerbsPlaySoloOptimization("simulationRunAction simulationPlayAction "
"simulationRunSelectorSim simulationRunSelectorTest simulationRunSelectorDebug");
if (noLockVerbs.contains(actionIDToLookFor) || (noLockVerbsPlaySoloOptimization.contains(actionIDToLookFor)) || (actionIDToLookFor == "simulationResetAction"))
{
RBX::Verb *pVerb = dataModel->getWorkspace()->getVerb(*m_CurrentGame->m_VerbMap[actionIDToLookFor]);
if (pVerb && pVerb->isEnabled())
pVerb->doIt(dataModel.get());
}
else
{
RBX::DataModel::LegacyLock lock(dataModel, RBX::DataModelJob::Write);
RBX::Verb *pVerb = dataModel->getWorkspace()->getVerb(*m_CurrentGame->m_VerbMap[actionIDToLookFor]);
if (pVerb && pVerb->isEnabled())
pVerb->doIt(dataModel.get());
}
}
catch (std::exception& e)
{
QtUtilities::RBXMessageBox msgBox;
msgBox.setIcon(QMessageBox::Warning);
msgBox.setText(e.what());
msgBox.exec();
}
if (actionID == "advanceJointCreationManualAction")
{
RobloxSettings settings;
settings.setValue(RBX_MANUAL_JOINT_CREATION_KEY, RBX::AdvArrowTool::advManualJointMode);
}
return true;
}
void RobloxIDEDoc::preProcessVerb(const QStringList &tokens)
{
//if it is a color changes, get the last three tokens, which will be the rgb value respectily. check the name of the color actions for detail.
if (tokens[0] == "actionFillColor")
{
QByteArray ba = tokens[tokens.length()-1].toAscii();
const char *c_str = ba.data();
RBX::FillTool::color.set(RBX::BrickColor::parse(c_str));
}
//if it is a material change, the second token is the name of the material. check the material action for detail.
else if (tokens[0] == "actionMaterial")
{
RBX::MaterialTool::material = RBX::MaterialVerb::parseMaterial(tokens[1].toStdString());
}
}
bool RobloxIDEDoc::handlePluginAction(void *pNotifier, void *pAction)
{
if (!pAction || !pNotifier)
return false;
static_cast<RBX::IHostNotifier*>(pNotifier)->buttonClick(m_CurrentGame->m_Game->getDataModel().get(), pAction);
return true;
}
RBX::Reflection::Variant RobloxIDEDoc::evaluateCommandBarItem(const char* itemToEvaluate, shared_ptr<RBX::LuaSourceContainer> script)
{
shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
RBX::DataModel::LegacyLock lock(dataModel,RBX::DataModelJob::Write);
boost::shared_ptr<RBX::ScriptContext> pScriptContext = RBX::shared_from(dataModel->create<RBX::ScriptContext>());
if(pScriptContext)
{
return pScriptContext->evaluateStudioCommandItem(itemToEvaluate, script);
}
return RBX::Reflection::Variant();
}
void RobloxIDEDoc::handleScriptCommand(const QString &execCommand)
{
if (execCommand.isEmpty())
return;
shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
RBX::DataModel::LegacyLock lock(dataModel,RBX::DataModelJob::Write);
try
{
std::string command = execCommand.toStdString();
bool isJoinScript = false;
if (RBX::ContentProvider::isHttpUrl(command))
{
if (StudioUtilities::containsJoinScript(execCommand))
isJoinScript = true;
std::auto_ptr<std::istream> stream =
RBX::ServiceProvider::create<RBX::ContentProvider>(dataModel.get())->getContent(RBX::ContentId(command));
command = std::string(static_cast<std::stringstream const&>(std::stringstream() << stream->rdbuf()).str());
}
if (isJoinScript)
{
// enable FRM in play mode
CRenderSettingsItem::singleton().setEnableFRM(true);
// Reset synchronized flags, they should be set by the server
FLog::ResetSynchronizedVariablesState();
int firstNewLineIndex = command.find("\r\n");
if (command[firstNewLineIndex+2] == '{')
{
m_CurrentGame->m_Game->configurePlayer(RBX::Security::CmdLine_, command.substr(firstNewLineIndex+2));
return;
}
}
boost::shared_ptr<RBX::ScriptContext> pScriptContext = RBX::shared_from(dataModel->create<RBX::ScriptContext>());
if (pScriptContext)
pScriptContext->executeInNewThread(RBX::Security::CmdLine_, RBX::ProtectedString::fromTrustedSource(command.c_str()), command.c_str());
}
catch (std::exception& e)
{
RBX::StandardOut::singleton()->print(RBX::MESSAGE_ERROR, e.what());
}
}
bool RobloxIDEDoc::actionState(const QString &actionID, bool &enableState, bool &checkedState)
{
if (isCloudEditSession())
{
// disable save and publish related actions
static QString cloudEditDeactiveActions(
"publishToRobloxAsAction fileSaveAction fileSaveAsAction publishToRobloxAction ");
if (cloudEditDeactiveActions.contains(actionID))
{
checkedState = false;
enableState = false;
return true;
}
static QString cloudEditActiveActions(
"downloadPlaceCopyAction ");
if (cloudEditActiveActions.contains(actionID))
{
checkedState = false;
enableState = true;
return true;
}
}
static QString defaultActiveActions(
"fileSaveAction fileSaveAsAction fileCloseAction "
"executeScriptAction publishToRobloxAsAction testClearStatsAction ");
if (defaultActiveActions.contains(actionID))
{
checkedState = false;
enableState = true;
return true;
}
if (m_pMainWindow->isRibbonStyle())
{
static QString defaultActiveRibbonActions(
"setVehiclesAction setNPCsAction setBuildingsAction setGearAction "
"setWeaponsAction setMyModelsAction setSearchAction "
"simulationScriptsEnabledAction simulationPlayerEnabledAction simulationPhysicsEnabledAction "
"actionParticleEffects actionSelectMenu "
"PartLargeAction SphereLargeAction WedgeLargeAction CylinderLargeAction startLocationAction lockMenu jointCreationMode "
"ms_Plastic ms_Wood ms_Slate ms_Concrete ms_CorrodedMetal ms_DiamondPlate ms_Foil ms_Grass ms_Ice ms_Brick ms_Sand "
"ms_Fabric ms_Granite ms_Marble ms_Pebble ms_SmoothPlastic ms_Neon ms_WoodPlanks ms_Cobblestone ms_Metal emulateDeviceAction "
"placePartAction playGameAction ScriptLargeAction LocalScriptLargeAction ModuleScriptLargeAction gridGroup __qtn_Action_Option ");
if ( defaultActiveRibbonActions.contains(actionID))
{
QAction* action = UpdateUIManager::Instance().getAction(actionID);
if (action)
{
checkedState = action->isChecked();
enableState = true;
}
return true;
}
static QString clientAndServerActions("playersMode startServerCB startServerAndPlayersAction cleanupServersAndPlayersAction pairRbxDevDeviceAction");
if (clientAndServerActions.contains(actionID))
{
if (!m_CurrentGame || !m_CurrentGame->m_Game || !m_CurrentGame->m_Game->getDataModel() || (
!RobloxIDEDoc::isEditMode(m_CurrentGame->m_Game->getDataModel().get()) && !isCloudEditSession()))
{
enableState = false;
return true;
}
else if (actionID == "pairRbxDevDeviceAction")
{
enableState = !RobloxApplicationManager::instance().hasChildProcesses();
return true;
}
else if (actionID == "cleanupServersAndPlayersAction")
{
enableState = RobloxApplicationManager::instance().hasChildProcesses();
return true;
}
else if (actionID == "playersMode")
{
enableState = true;
return true;
}
}
static QString defaultRibbonDeactiveAction("startServerAction addWatchAction ");
if (defaultRibbonDeactiveAction.contains(actionID))
{
checkedState = false;
enableState = false;
return true;
}
if (actionID == "actionSurface")
{
static QStringList surfaceActionsList = (QStringList() << "glueSurfaceAction" << "smoothSurfaceAction" << "studsAction"
<< "inletAction" << "universalsAction" << "weldSurfaceAction");
for (int ii = 0; ii < surfaceActionsList.size(); ++ii)
{
actionState(surfaceActionsList[ii], enableState, checkedState);
if (checkedState)
return true;
}
enableState = true;
return true;
}
if (actionID == "materialActionAsTool")
{
checkedState = StudioMaterialVerb::sMaterialActionActAsTool;
enableState = true;
return true;
}
if (actionID == "colorFillActionAsTool")
{
checkedState = StudioColorVerb::sColorActionActAsTool;
enableState = true;
return true;
}
if (FFlag::LuaDebugger)
{
if (actionID == "toggleAllBreakpointsStateAction")
{
enableState = DebuggerViewsManager::Instance().getViewWidget<BreakpointsWidget>(DebuggerViewsManager::eDV_BREAKPOINTS).numBreakpoints() > 0;
return true;
}
}
// get status from plugin host (this is required only for ribbon as we do not hide plugin page)
if (m_pMainWindow->pluginHost().actionState(actionID, enableState, checkedState))
return true;
}
// TODO - fix this (see below)
static QString disabledActions =
"commentSelectionAction uncommentSelectionAction toggleCommentAction "
"expandAllFoldsAction collapseAllFoldsAction replaceAction resetScriptZoomAction "
"reloadScriptAction goToLineAction downloadPlaceCopyAction ";
if (disabledActions.contains(actionID))
{
enableState = false;
return true;
}
if (UpdateUIManager::Instance().getDockActionNames().contains(actionID))
{
enableState = true;
checkedState = UpdateUIManager::Instance().getAction(actionID)->isChecked();
return true;
}
if (m_CurrentGame->m_VerbMap.contains(actionID))
{
RBX::Verb* pVerb = m_CurrentGame->m_Game->getDataModel()->getWorkspace()->getVerb(*m_CurrentGame->m_VerbMap[actionID]);
if (pVerb)
{
checkedState = pVerb->isChecked();
enableState = pVerb->isEnabled();
return true;
}
}
// TODO - all the enabled/active states should be enabled otherwise default disabled
// enabledState = false;
return false;
}
void RobloxIDEDoc::createActionIDVerbMap(GameState& gameState)
{
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
//define mapping - action name with the verb name!
mapFilesMenu(gameState);
mapEditMenu(gameState);
mapViewMenu(gameState);
mapFormatMenu(gameState);
mapToolMenu(gameState);
mapInsertMenu(gameState);
mapAdvToolsToolbar(gameState);
mapRunToolbar(gameState);
mapCameraToolbar(gameState);
mapStandardToolbar(gameState);
mapAdvanceBuildToolbar(gameState);
//cut, copy and paste
verbs.append(new CutVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"cutAction",verbs.back());
verbs.append(new CopyVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"copyAction",verbs.back());
verbs.append(new PasteVerb(dataModel.get(), false));
mapActionIDWithVerb(gameState,"pasteAction",verbs.back());
verbs.append(new PasteVerb(dataModel.get(), true));
mapActionIDWithVerb(gameState,"pasteIntoAction",verbs.back());
verbs.append(new DuplicateSelectionVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"duplicateSelectionAction",verbs.back());
verbs.append(new RBX::BoundVerb(dataModel.get(), "renameObjectVerb",
boost::bind(&RobloxIDEDoc::onObjectRename, this), boost::bind(&RobloxIDEDoc::isObjectRenameEnabled, this)));
mapActionIDWithVerb(gameState,"renameObjectAction",verbs.back());
verbs.append(new InsertModelVerb(dataModel.get(), true));
mapActionIDWithVerb(gameState,"insertIntoFileAction",verbs.back());
verbs.push_back(new SelectionSaveToFileVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "selectionSaveToFileAction", verbs.back());
verbs.append(new ExportSelectionVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "exportSelectionAction", verbs.back());
if (m_pMainWindow->isRibbonStyle())
{
verbs.push_back(new OpenToolBoxWithOptionsVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "openToolBoxWithOptions", verbs.back());
verbs.push_back(new InsertBasicObjectVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "insertBasicObject", verbs.back());
}
// no mapping required
verbs.push_back(new ShutdownClientVerb(dataModel.get(), this));
verbs.push_back(new ShutdownClientAndSaveVerb(dataModel.get(), this));
verbs.push_back(new LeaveGameVerb(dataModel.get(), this));
verbs.push_back(new ToggleFullscreenVerb(dataModel.get()));
verbs.push_back(new ToggleLocalSpaceVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "toggleLocalSpaceAction", verbs.back());
verbs.push_back(new LaunchHelpForSelectionVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "launchHelpForSelectionAction", verbs.back());
verbs.push_back(new AnalyzePhysicsToggleVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "analyzePhysicsToggleAction", verbs.back());
}
void RobloxIDEDoc::mapFilesMenu(GameState& gameState)
{
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
verbs.append(new PublishToRobloxVerb(dataModel.get(), m_pMainWindow));
mapActionIDWithVerb(gameState,"publishToRobloxAction",verbs.back());
verbs.append(new PublishToRobloxAsVerb(dataModel.get(), m_pMainWindow));
mapActionIDWithVerb(gameState,"publishToRobloxAsAction",verbs.back());
verbs.append(new PublishSelectionToRobloxVerb(dataModel.get(), m_pMainWindow));
mapActionIDWithVerb(gameState,"publishSelectionToRobloxAction",verbs.back());
/// This goes into the Tree View
mapActionIDWithVerb(gameState,"saveToRobloxAction",verbs.back());
verbs.push_back(new CreateNewLinkedSourceVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "createNewLinkedSourceAction", verbs.back());
verbs.push_back(new PublishAsPluginVerb(dataModel.get(), m_pMainWindow));
mapActionIDWithVerb(gameState, "publishAsPluginAction", verbs.back());
verbs.append(new ExportPlaceVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "exportPlaceAction", verbs.back());
}
void RobloxIDEDoc::mapEditMenu(GameState& gameState)
{
boost::shared_ptr<RBX::CommonVerbs> commonVerbs = gameState.m_Game->commonVerbs;
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
mapActionIDWithVerb(gameState,"selectAllAction", &commonVerbs->selectAllCommand);
mapActionIDWithVerb(gameState,"deleteSelectedAction", &commonVerbs->deleteSelectionVerb);
mapActionIDWithVerb(gameState,"lockAction", &commonVerbs->lockToolVerb);
mapActionIDWithVerb(gameState,"unlockAllAction", &commonVerbs->unlockAllVerb);
gameState.m_UndoVerb = new UndoVerb(dataModel.get());
verbs.append(gameState.m_UndoVerb);
mapActionIDWithVerb(gameState,"undoAction",gameState.m_UndoVerb);
gameState.m_RedoVerb = new RedoVerb(dataModel.get());
verbs.append(gameState.m_RedoVerb);
mapActionIDWithVerb(gameState,"redoAction",gameState.m_RedoVerb);
mapActionIDWithVerb(gameState,"rotateSelectionAction",&commonVerbs->rotateSelectionVerb);
mapActionIDWithVerb(gameState,"tiltSelectionAction",&commonVerbs->tiltSelectionVerb);
mapActionIDWithVerb(gameState,"moveUpBrickAction",&commonVerbs->moveUpBrickVerb);
mapActionIDWithVerb(gameState,"moveDownBrickAction",&commonVerbs->moveDownSelectionVerb);
}
void RobloxIDEDoc::mapViewMenu(GameState& gameState)
{
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
verbs.append(new ToggleAxisWidgetVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"toggleAxisWidgetAction",verbs.back());
verbs.append(new Toggle3DGridVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"toggle3DGridAction",verbs.back());
}
void RobloxIDEDoc::mapFormatMenu(GameState& gameState)
{
boost::shared_ptr<RBX::CommonVerbs> commonVerbs = gameState.m_Game->commonVerbs;
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
mapActionIDWithVerb(gameState,"rotateSelectionAction", &commonVerbs->rotateSelectionVerb);
mapActionIDWithVerb(gameState,"tiltSelectionAction", &commonVerbs->tiltSelectionVerb);
verbs.append(new GroupSelectionVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"groupSelectionAction", verbs.back());
verbs.append(new UngroupSelectionVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"ungroupSelectionAction", verbs.back());
verbs.append(new UnionSelectionVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "unionSelectionAction", verbs.back());
verbs.append(new NegateSelectionVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "negateSelectionAction", verbs.back());
verbs.append(new SeparateSelectionVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "separateSelectionAction", verbs.back());
mapActionIDWithVerb(gameState,"selectChildrenAction", &commonVerbs->selectChildrenVerb);
}
void RobloxIDEDoc::mapToolMenu(GameState& gameState)
{
boost::shared_ptr<RBX::CommonVerbs> commonVerbs = gameState.m_Game->commonVerbs;
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
verbs.append(new PlaySoloVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"playSoloAction",verbs.back());
verbs.append(new StartServerVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"startServerAction",verbs.back());
verbs.append(new StartPlayerVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"startPlayerAction",verbs.back());
mapActionIDWithVerb(gameState,"testStatsAction", &commonVerbs->statsCommand);
mapActionIDWithVerb(gameState,"testRenderStatsAction", &commonVerbs->renderStatsCommand);
mapActionIDWithVerb(gameState,"testNetworkStatsAction", &commonVerbs->networkStatsCommand);
mapActionIDWithVerb(gameState,"testPhysicsStatsAction", &commonVerbs->physicsStatsCommand);
mapActionIDWithVerb(gameState,"testSummaryStatsAction", &commonVerbs->summaryStatsCommand);
if (FFlag::StudioCustomStatsEnabled)
{
mapActionIDWithVerb(gameState,"testCustomStatsAction", &commonVerbs->customStatsCommand);
}
if (m_pQOgreWidget)
{
verbs.append(new ScreenshotVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "screenShotAction", verbs.back());
}
if (m_pMainWindow->isRibbonStyle())
{
verbs.push_back(new InsertAdvancedObjectViewVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"actionInsertAdvancedObject",verbs.back());
verbs.push_back(new CreatePluginVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"createPluginAction",verbs.back());
verbs.push_back(new StartServerAndPlayerVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"startServerAndPlayersAction",verbs.back());
verbs.push_back(new ServerPlayersStateInitVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"startServerCB",verbs.back());
verbs.push_back(new PairRbxDevVerb(dataModel.get(), NULL));
mapActionIDWithVerb(gameState,"pairRbxDevDeviceAction",verbs.back());
verbs.push_back(new ManageEmulationDevVerb(dataModel.get(), NULL));
mapActionIDWithVerb(gameState, "manageEmulationDeviceAction", verbs.back());
verbs.push_back(new AudioToggleVerb(dataModel.get()));
mapActionIDWithVerb(gameState, "audioToggleAction", verbs.back());
//verbs.push_back(new LaunchInstancesVerb(dataModel.get()));
//mapActionIDWithVerb(gameState,"launchInstancesAction",verbs.back());
}
}
void RobloxIDEDoc::mapInsertMenu(GameState& gameState)
{
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
//insert
verbs.append(new InsertModelVerb(dataModel.get(), false));
mapActionIDWithVerb(gameState,"insertModelAction",verbs.back());
}
void RobloxIDEDoc::mapAdvToolsToolbar(GameState& gameState)
{
boost::shared_ptr<RBX::CommonVerbs> commonVerbs = gameState.m_Game->commonVerbs;
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
mapActionIDWithVerb(gameState,"glueSurfaceAction", &commonVerbs->glueToolVerb);
mapActionIDWithVerb(gameState,"smoothSurfaceAction", &commonVerbs->flatToolVerb);
mapActionIDWithVerb(gameState,"weldSurfaceAction", &commonVerbs->weldToolVerb);
mapActionIDWithVerb(gameState,"studsAction", &commonVerbs->studsToolVerb);
mapActionIDWithVerb(gameState,"inletAction", &commonVerbs->inletToolVerb);
mapActionIDWithVerb(gameState,"universalsAction", &commonVerbs->universalToolVerb);
mapActionIDWithVerb(gameState,"hingeAction", &commonVerbs->hingeToolVerb);
mapActionIDWithVerb(gameState,"smoothNoOutlinesAction", &commonVerbs->smoothNoOutlinesToolVerb);
mapActionIDWithVerb(gameState,"motorRightAction", &commonVerbs->rightMotorToolVerb);
if (m_pMainWindow->isRibbonStyle())
{
// if we need to have sticky command then just remove these assignments
RBX::RightMotorTool::isStickyVerb = false;
RBX::HingeTool::isStickyVerb = false;
mapActionIDWithVerb(gameState,"anchorAction", &commonVerbs->anchorVerb);
verbs.push_back(new StudioColorVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"actionColorSelector", verbs.back());
verbs.push_back(new StudioMaterialVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"actionMaterialSelector", verbs.back());
}
else
{
mapActionIDWithVerb(gameState,"anchorAction", &commonVerbs->anchorToolVerb);
mapActionIDWithVerb(gameState,"actionFillColor", &commonVerbs->fillToolVerb);
mapActionIDWithVerb(gameState,"actionMaterial", &commonVerbs->materialToolVerb);
}
mapActionIDWithVerb(gameState,"dropperAction", &commonVerbs->dropperToolVerb);
mapActionIDWithVerb(gameState,"advArrowToolAction", &commonVerbs->advArrowToolVerb);
}
void RobloxIDEDoc::mapRunToolbar(GameState& gameState)
{
boost::shared_ptr<RBX::CommonVerbs> commonVerbs = gameState.m_Game->commonVerbs;
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
//Run
verbs.append(new RBX::BoundVerb(
dataModel.get(),
"IDE Run",
boost::bind(&RobloxIDEDoc::onIdeRun, this, false),
boost::bind(&RobloxIDEDoc::isIdeRunEnabled, this, false)));
mapActionIDWithVerb(gameState,"simulationRunAction", verbs.back());
verbs.append(new RBX::BoundVerb(
dataModel.get(),
"IDE Play",
boost::bind(&RobloxIDEDoc::onIdeRun, this, true),
boost::bind(&RobloxIDEDoc::isIdeRunEnabled, this, true)));
mapActionIDWithVerb(gameState,"simulationPlayAction", verbs.back());
verbs.append(new RBX::BoundVerb(
dataModel.get(),
"IDE Pause",
boost::bind(&RobloxIDEDoc::onIdePause, this),
boost::bind(&RobloxIDEDoc::isIdePauseEnabled, this)));
mapActionIDWithVerb(gameState,"simulationStopAction", verbs.back());
verbs.append(new RBX::BoundVerb(
dataModel.get(),
"IDE Reset",
boost::bind(&RobloxIDEDoc::onIdeReset, this),
boost::bind(&RobloxIDEDoc::isIdeResetEnabled, this)));
mapActionIDWithVerb(gameState,"simulationResetAction", verbs.back());
}
void RobloxIDEDoc::mapCameraToolbar(GameState& gameState)
{
mapActionIDWithVerb(gameState,"zoomInAction", "CameraZoomIn");
mapActionIDWithVerb(gameState,"zoomOutAction", "CameraZoomOut");
// Camera Tilt Commands apparently use an inverted pitch. We don't want
// to change anything that relies on that behavior so in Studio we're
// going to switch them. Inverted pitch might make sense playing a
// game but not when editing.
mapActionIDWithVerb(gameState,"tiltUpAction", "CameraTiltDown");
mapActionIDWithVerb(gameState,"tiltDownAction", "CameraTiltUp");
mapActionIDWithVerb(gameState,"panRightAction", "CameraPanRight");
mapActionIDWithVerb(gameState,"panLeftAction", "CameraPanLeft");
mapActionIDWithVerb(gameState,"lookAtObjectAction", "CameraCenter");
mapActionIDWithVerb(gameState,"zoomExtentsAction", "CameraZoomExtents"); // Only used in context menu on part
}
void RobloxIDEDoc::mapStandardToolbar(GameState& gameState)
{
boost::shared_ptr<RBX::CommonVerbs> commonVerbs = gameState.m_Game->commonVerbs;
mapActionIDWithVerb(gameState,"moveUpBrickAction", &commonVerbs->moveUpBrickVerb);
mapActionIDWithVerb(gameState,"moveDownBrickAction", &commonVerbs->moveDownSelectionVerb);
}
void RobloxIDEDoc::mapAdvanceBuildToolbar(GameState& gameState)
{
boost::shared_ptr<RBX::CommonVerbs> commonVerbs = gameState.m_Game->commonVerbs;
shared_ptr<RBX::DataModel> dataModel = gameState.m_Game->getDataModel();
QVector<RBX::Verb*>& verbs = gameState.m_Verbs;
//Advance build relate
if (!m_pMainWindow->isRibbonStyle())
{
RobloxSettings settings;
RBX::AdvArrowTool::advManualJointMode = settings.value(RBX_MANUAL_JOINT_CREATION_KEY, false).toBool();
mapActionIDWithVerb(gameState,"advanceJointCreationManualAction", &commonVerbs->turnOnManualJointCreationVerb);
}
else
{
verbs.push_back(new JointCreationModeVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"jointCreationMode", verbs.back());
mapActionIDWithVerb(gameState,"gridSizeToTwoAction", &commonVerbs->setGridSizeToTwoVerb);
mapActionIDWithVerb(gameState,"gridSizeToFourAction", &commonVerbs->setGridSizeToFourVerb);
mapActionIDWithVerb(gameState,"gridSizeToSixteenAction", &commonVerbs->setGridSizeToSixteenVerb);
verbs.push_back(new JointToolHelpDialogVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"advancedJointCreationHelpAction",verbs.back());
}
mapActionIDWithVerb(gameState, "gridToOneAction", &commonVerbs->setDragGridToOneVerb);
mapActionIDWithVerb(gameState, "gridToOneFifthAction", &commonVerbs->setDragGridToOneFifthVerb);
mapActionIDWithVerb(gameState, "gridToOffAction", &commonVerbs->setDragGridToOffVerb);
mapActionIDWithVerb(gameState,"advTranslateAction", &commonVerbs->advMoveToolVerb);
mapActionIDWithVerb(gameState,"advRotateAction", &commonVerbs->advRotateToolVerb);
mapActionIDWithVerb(gameState,"resizeAction", &commonVerbs->resizeToolVerb);
verbs.push_back(new ToggleCollisionCheckVerb(dataModel.get()));
mapActionIDWithVerb(gameState,"toggleCollisionCheckAction", verbs.back());
}
void RobloxIDEDoc::onIdePause()
{
if (m_PlayGame.m_Game)
{
shared_ptr<RBX::DataModel> playDataModel = m_PlayGame.m_Game->getDataModel();
RBX::DataModel::LegacyLock lock(playDataModel,RBX::DataModelJob::Write);
RBX::RunService* pRS = playDataModel->create<RBX::RunService>();
pRS->pause();
}
else
{
shared_ptr<RBX::DataModel> dataModel = m_EditGame.m_Game->getDataModel();
RBX::DataModel::LegacyLock lock(dataModel,RBX::DataModelJob::Write);
RBX::RunService* pRS = dataModel->create<RBX::RunService>();
pRS->pause();
}
}
bool RobloxIDEDoc::isIdePauseEnabled()
{
if (m_PlayGame.m_Game)
{
shared_ptr<RBX::DataModel> playDataModel = m_PlayGame.m_Game->getDataModel();
RBX::RunService* pRS = playDataModel->create<RBX::RunService>();
RBX::RunState runState = pRS->getRunState();
return runState == RBX::RS_RUNNING;
}
shared_ptr<RBX::DataModel> dataModel = m_EditGame.m_Game->getDataModel();
RBX::RunService* pRS = dataModel->create<RBX::RunService>();
RBX::RunState runState = pRS->getRunState();
return (runState == RBX::RS_RUNNING);
}
void RobloxIDEDoc::teleportToURL(QString url, bool play)
{
if (StudioUtilities::isTestMode())
{
QtUtilities::RBXMessageBox msgBox;
msgBox.setIcon(QMessageBox::Warning);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setText("Teleports not yet supported in Test Server or Create Player.");
msgBox.exec();
return;
}
closePlayDataModel();
// Check to see if the url fetched returns anything at all.
{
shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
std::string command = url.toStdString();
std::auto_ptr<std::istream> stream = RBX::ServiceProvider::create<RBX::ContentProvider>(dataModel.get())->getContent(RBX::ContentId(command));
std::string scriptStr(static_cast<std::stringstream const&>(std::stringstream() << stream->rdbuf()).str());
if (scriptStr.empty())
{
QtUtilities::RBXMessageBox msgBox;
msgBox.setIcon(QMessageBox::Warning);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.setDefaultButton(QMessageBox::Ok);
msgBox.setText("Could not teleport to place.");
msgBox.exec();
return;
}
}
loadPlayDataModel(url, play, false, true);
}
void RobloxIDEDoc::loadPlayDataModel(QString url, bool play, bool cloneDataModel, bool isTeleport)
{
shared_ptr<RBX::DataModel> dataModel = m_EditGame.m_Game->getDataModel();
if (!dataModel)
return;
{
// this will be called in case of old play solo
RBX::RunService* pRS = dataModel->create<RBX::RunService>();
RBX::DataModel::LegacyLock editLock(dataModel,RBX::DataModelJob::Write);
if (!pRS->isEditState())
{
applyScriptChanges();
pRS->run();
return;
}
}
// check if we're already running
if (m_PlayGame.m_Game &&
m_PlayGame.m_Game->getDataModel() &&
m_PlayGame.m_Game->getDataModel()->create<RBX::RunService>())
{
{
RBX::DataModel::LegacyLock lock(m_PlayGame.m_Game->getDataModel(),RBX::DataModelJob::Write);
RBX::RunState runState = m_PlayGame.m_Game->getDataModel()->create<RBX::RunService>()->getRunState();
if (runState == RBX::RS_PAUSED)
{
RBX::ServiceProvider::create<RBX::RunService>(m_PlayGame.m_Game->getDataModel().get())->run();
return;
}
}
}
// If the Edit game has been run and is currently paused, then resume it.
if (m_EditGame.m_Game &&
m_EditGame.m_Game->getDataModel())
{
{
RBX::RunService* pRunState = m_EditGame.m_Game->getDataModel()->find<RBX::RunService>();
RBX::DataModel::LegacyLock lock(m_EditGame.m_Game->getDataModel(),RBX::DataModelJob::Write);
if(pRunState && pRunState->getRunState() == RBX::RS_PAUSED)
{
pRunState->run();
return;
}
}
}
if (!isTeleport)
{
clearOutputWidget();
updateOnSimulationStateChange(true);
}
autoSave(true);
UpdateUIManager::Instance().setBusy(true);
static const int ProgressStages = 6;
RBX::BaldPtr<QProgressBar> progressBar = UpdateUIManager::Instance().showProgress("Play Game",0,ProgressStages);
// Stage 0 - initialize game
UpdateUIManager::Instance().updateProgress(progressBar,0);
deActivate();
// We never hide plugins in ribbon mode but it is requierd for NPS
if (m_pMainWindow->isRibbonStyle())
{
RBX::PluginManager::singleton()->hideStudioUI(m_EditGame.m_Game->getDataModel().get(),true);
}
if (m_EditGame.m_View)
{
// remove video recording verb since it's associated with view
cleanupVideoRecording(m_EditGame);
delete m_EditGame.m_View;
m_EditGame.m_View = NULL;
}
QString debugDataFile = getDebugInfoFile(false, PlaySoloDebugFileExt);
m_CurrentGame = &m_PlayGame;
if (play)
{
StudioUtilities::setAvatarMode(true);
}
if (!m_PlayGame.m_Game)
{
if (FFlag::LuaDebugger)
{
// save edit model debugger data so it can be merged with play model changes later
saveEditModelDebuggerData();
}
QString baseUrl = RobloxSettings::getBaseURL() + "/";
m_PlayGame.m_Game.reset(new RBX::UnsecuredStudioGame(NULL,baseUrl.toStdString().c_str()));
shared_ptr<RBX::DataModel> playDataModel = m_PlayGame.m_Game->getDataModel();
RBX::DataModel::LegacyLock lock(m_PlayGame.m_Game->getDataModel(), RBX::DataModelJob::Write);
createOptionalDMServices();
playDataModel->setName(displayName().toStdString());
m_PlayGame.m_View = new RobloxView(m_pQOgreWidget,m_PlayGame.m_Game, m_GameView, /* vr = */ true);
m_PlayGame.m_View->buildGui(StudioUtilities::isAvatarMode());
createActionIDVerbMap(m_PlayGame);
// initialize video recording
initializeVideoRecording(m_PlayGame);
m_PlayGame.m_TreeWidget = new RobloxTreeWidget(playDataModel);
UpdateUIManager::Instance().getViewWidget<RobloxExplorerWidget>(eDW_OBJECT_EXPLORER).setCurrentWidget(m_PlayGame.m_TreeWidget);
// restore in-game stats display
QSettings settings;
setStatsEnabled(StatsVerb,settings.value(StatsVerb,false).toBool(), m_pMainWindow->testStatsAction);
setStatsEnabled(RenderStatsVerb,settings.value(RenderStatsVerb,false).toBool(), m_pMainWindow->testRenderStatsAction);
setStatsEnabled(PhysicsStatsVerb,settings.value(PhysicsStatsVerb,false).toBool(), m_pMainWindow->testPhysicsStatsAction);
setStatsEnabled(NetworkStatsVerb,settings.value(NetworkStatsVerb,false).toBool(), m_pMainWindow->testNetworkStatsAction);
setStatsEnabled(SummaryStatsVerb,settings.value(SummaryStatsVerb,false).toBool(), m_pMainWindow->testSummaryStatsAction);
if (FFlag::StudioCustomStatsEnabled)
{
setStatsEnabled(CustomStatsVerb,settings.value(CustomStatsVerb,false).toBool(), m_pMainWindow->testCustomStatsAction);
}
RBX::UserInputService* userInputService = playDataModel->find<RBX::UserInputService>();
userInputService->setMouseEnabled(true);
userInputService->setKeyboardEnabled(true);
}
m_pQOgreWidget->setRobloxView(m_PlayGame.m_View);
setDockViewsEnabled(true);
activate();
// Stage 1 - save edit world
UpdateUIManager::Instance().updateProgress(progressBar, 1);
std::stringstream ss;
int placeId, universeId;
if (cloneDataModel)
{
RBX::DataModel::LegacyLock editLock(dataModel,RBX::DataModelJob::Write);
applyScriptChanges();
RBX::SerializerBinary::serialize(ss, dataModel.get());
placeId = dataModel->getPlaceID();
universeId = dataModel->getUniverseId();
}
// Stage 2 - load play world
UpdateUIManager::Instance().updateProgress(progressBar, 2);
shared_ptr<RBX::DataModel> playDataModel = m_PlayGame.m_Game->getDataModel();
{
RBX::DataModel::LegacyLock playLock(playDataModel,RBX::DataModelJob::Write);
RBX::Security::Impersonator impersonate(RBX::Security::LocalGUI_);
bool oldStudioMode = RBX::GameBasicSettings::singleton().inStudioMode();
RBX::GameBasicSettings::singleton().setStudioMode(false);
if (cloneDataModel)
{
RBX::SerializerBinary::deserialize(ss, playDataModel.get());
playDataModel->processAfterLoad();
}
// only need to load linked scripts here when we are cloning (not teleporting)
if (cloneDataModel)
{
playDataModel->setPlaceID(placeId, false /*not a roblox place*/);
playDataModel->setUniverseId(universeId);
LuaSourceContainer::blockingLoadLinkedScripts(
playDataModel->create<ContentProvider>(), playDataModel.get());
}
tDebuggersMap playModelDebuggers;
for (tDebuggersMap::const_iterator iter = m_EditDebuggersMap.begin(); iter != m_EditDebuggersMap.end(); ++iter)
{
std::vector<int> indexHierarchy;
std::string serviceName = getScriptIndexHierarchy(iter->first, indexHierarchy);
shared_ptr<RBX::Instance> instance = getScriptByIndexHierarchy(playDataModel, indexHierarchy, serviceName);
if (instance)
playModelDebuggers[instance] = iter->second;
}
initializeDebuggerData("", playDataModel, playModelDebuggers);
RobloxPluginHost::loadPlugins(playDataModel.get());
RBX::GameBasicSettings::singleton().setStudioMode(oldStudioMode);
}
if (DFFlag::UseR15Character && playDataModel->getUniverseDataRequested())
{
playDataModel->universeDataLoaded.get_future().wait();
}
// make sure we patch scripts before calling RunService
// otherwise it will create a 'Player1' instance inside Workspace, leading to a mismatch in index hierarchy
patchPlayModelScripts();
// Stage 3 - set up local player
UpdateUIManager::Instance().updateProgress(progressBar, 3);
if (play)
{
RBXASSERT(m_CurrentGame == &m_PlayGame);
if (!url.isEmpty())
{
handleScriptCommand(url);
}
}
else
{
RBX::DataModel::LegacyLock playLock(playDataModel,RBX::DataModelJob::Write);
RBX::ServiceProvider::create<RBX::RunService>(playDataModel.get())->run();
}
UpdateUIManager::Instance().hideProgress(progressBar);
UpdateUIManager::Instance().setBusy(false);
m_pQOgreWidget->setVisible(true);
RobloxDocManager::Instance().setCurrentDoc(this);
UpdateUIManager::Instance().updateToolBars();
}
void RobloxIDEDoc::closePlayDataModel()
{
if (!m_PlayGame.m_Game.get())
return;
QString debugDataFile = getDebugInfoFile(false, PlaySoloDebugFileExt);
applyScriptChanges();
if (saveScriptsChangedWhileTesting() && FFlag::LuaDebugger)
updateEditModelDebuggerData();
restoreEditModelScripts();
cleanupVideoRecording(m_PlayGame);
deActivate();
m_pQOgreWidget->setRobloxView(m_EditGame.m_View);
if (FFlag::LuaDebugger)
DebuggerClientManager::Instance().onRunTransition(RBX::RunTransition(RBX::RS_STOPPED, RBX::RS_STOPPED));
cleanupGameState(m_PlayGame);
{
RBX::DataModel::LegacyLock lock(m_EditGame.m_Game->getDataModel(), RBX::DataModelJob::Write);
RBXASSERT(!m_EditGame.m_View);
m_EditGame.m_View = new RobloxView(m_pQOgreWidget,m_EditGame.m_Game, m_GameView);
//since we are creating a new view we will be required to reinitialize video recording
initializeVideoRecording(m_EditGame);
}
m_CurrentGame = &m_EditGame;
setDockViewsEnabled(true);
activate();
// We never hide plugins in ribbon mode but it is requierd for NPS
if (m_pMainWindow->isRibbonStyle())
{
RBX::PluginManager::singleton()->hideStudioUI(m_CurrentGame->m_Game->getDataModel().get(), false);
}
m_CurrentGame->m_View->requestUpdateView();
if (isCloudEditSession())
{
m_CurrentGame->m_TreeWidget->requestUpdate();
}
StudioUtilities::setAvatarMode(false);
{
RBX::DataModel::LegacyLock lock(m_EditGame.m_Game->getDataModel(), RBX::DataModelJob::Write);
RBX::GameBasicSettings::singleton().setStudioMode(true);
// Turn off the frame rate manager when we're editing.
CRenderSettingsItem::singleton().setEnableFRM(false);
}
// again reinitialize the data for original data model
if (FFlag::LuaDebugger)
{
initializeDebuggerData("", m_EditGame.m_Game->getDataModel(), m_EditDebuggersMap);
m_EditDebuggersMap.clear();
if (RobloxDocManager::Instance().getCurrentDoc() != this)
RobloxDocManager::Instance().getCurrentDoc()->activate();
}
}
void RobloxIDEDoc::onIdeRun(bool play)
{
shared_ptr<RBX::DataModel> dataModel = m_EditGame.m_Game->getDataModel();
// We receive a crash down the stack with m_GameView equal to NULL. One explanation is somehow user pressed onIdeRun before first paint message made it
// Lets try to catch it with assert
RBXASSERT(m_GameView);
if(m_GameView == NULL)
return;
QString scriptStr;
if (FFlag::UseBuildGenericGameUrl)
{
QString pathStr = QString("game/visit.ashx?IsPlaySolo=1&UserID=%1&PlaceID=%2&universeId=%3")
.arg(RobloxUser::singleton().getUserId())
.arg(m_EditGame.m_Game->getDataModel()->getPlaceID())
.arg(m_EditGame.m_Game->getDataModel()->getUniverseId());
scriptStr = QString("loadfile(\"%1\")()\n")
.arg(QString::fromStdString(BuildGenericGameUrl(RobloxSettings::getBaseURL().toStdString(),pathStr.toStdString())));
}
else
{
scriptStr = QString("loadfile(\"%1/game/visit.ashx?IsPlaySolo=1&UserID=%2&PlaceID=%3&universeId=%4\")()\n")
.arg(RobloxSettings::getBaseURL())
.arg(RobloxUser::singleton().getUserId())
.arg(m_EditGame.m_Game->getDataModel()->getPlaceID())
.arg(m_EditGame.m_Game->getDataModel()->getUniverseId());
}
loadPlayDataModel(scriptStr, play, true);
if (DFFlag::ScriptExecutionContextApi)
{
if (!play)
{
if (shared_ptr<RBX::DataModel> playDataModel = m_PlayGame.m_Game->getDataModel())
{
playDataModel->setIsRunMode(true);
}
}
}
}
bool RobloxIDEDoc::isIdeRunEnabled(bool play)
{
if (m_PlayGame.m_Game)
{
if (play != StudioUtilities::isAvatarMode())
{
return false;
}
shared_ptr<RBX::DataModel> playDataModel = m_PlayGame.m_Game->getDataModel();
RBX::RunService* pRS = playDataModel->create<RBX::RunService>();
return pRS->getRunState() != RBX::RS_RUNNING;
}
else
{
shared_ptr<RBX::DataModel> dataModel = m_EditGame.m_Game->getDataModel();
RBX::RunService* pRS = dataModel->create<RBX::RunService>();
bool clientIsPresent = RBX::Network::Players::clientIsPresent(dataModel.get()) &&
!isCloudEditSession();
return !clientIsPresent && (pRS->getRunState() != RBX::RS_RUNNING);
}
}
void RobloxIDEDoc::onIdeReset()
{
if (m_PlayGame.m_Game)
{
closePlayDataModel();
}
else
{
shared_ptr<RBX::DataModel> dataModel = m_EditGame.m_Game->getDataModel();
RBX::DataModel::LegacyLock lock(dataModel, RBX::DataModelJob::Write);
dataModel->create<RBX::RunService>()->stop();
dataModel->create<RBX::ChangeHistoryService>()->reset();
}
updateOnSimulationStateChange(false);
}
bool RobloxIDEDoc::isIdeResetEnabled()
{
return m_PlayGame.m_Game;
}
bool RobloxIDEDoc::isCloudEditSession()
{
return m_IsCloudEditSession.get();
}
bool RobloxIDEDoc::getIsCloudEditSession()
{
if (RobloxIDEDoc* ideDoc = RobloxDocManager::Instance().getPlayDoc())
{
return ideDoc->isCloudEditSession();
}
return false;
}
bool RobloxIDEDoc::isObjectRenameEnabled()
{
QList<QTreeWidgetItem *> selectedItems = m_CurrentGame->m_TreeWidget->selectedItems();
if (selectedItems.size() == 1)
return true;
return false;
}
void RobloxIDEDoc::onObjectRename()
{
if (m_CurrentGame->m_TreeWidget->currentItem())
m_CurrentGame->m_TreeWidget->editItem(m_CurrentGame->m_TreeWidget->currentItem());
}
RBX::Verb* RobloxIDEDoc::getVerb(const QString& name) const
{
RBXASSERT(m_CurrentGame);
return getVerb(*m_CurrentGame, name);
}
RBX::Verb* RobloxIDEDoc::getVerb(GameState& gameState,const QString& name) const
{
std::string stdname = name.toStdString();
for (int i = 0; i < gameState.m_Verbs.size() ; ++i)
{
if (gameState.m_Verbs[i]->getName().str == stdname)
return gameState.m_Verbs[i];
}
return NULL;
}
bool RobloxIDEDoc::autoSave(bool force)
{
FASTLOG1(FLog::AutoSave, "Auto-saving, force: %u", force);
// don't save while we're running
if (isSimulating())
return true;
// don't save if running Play Solo, Start Server, Start Player
if (StudioUtilities::isTestMode())
return true;
// don't save unless we need to
if (!m_EditGame.m_Game || !m_EditGame.m_Game->getDataModel() || !m_EditGame.m_Game->getDataModel()->isDirty())
{
FASTLOG(FLog::AutoSave, "DM is not dirty, skipping");
return true;
}
if (force)
{
// force wait for a lock - this can cause a lockup if we're already loading or saving
FASTLOG(FLog::AutoSave, "Locking mutex");
m_IOMutex.lock();
}
else if (!force && !m_IOMutex.tryLock())
{
// if we're saving or loading, just skip this auto-save for now
FASTLOG(FLog::AutoSave, "Mutex is locked, skipping");
return true;
}
QByteArray currentDataModelHash;
try
{
currentDataModelHash = StudioSerializerHelper::getDataModelHash(m_EditGame.m_Game->getDataModel().get());
if (m_autoSaveDataModelHash == currentDataModelHash)
{
FASTLOG(FLog::AutoSave, "DM hash is same, skipping");
m_IOMutex.unlock();
return true;
}
if (m_AutoSaveName.isEmpty())
{
QString fileName;
if (m_fileName.isEmpty() || !QFile::exists(m_fileName))
fileName = "Place";
else
fileName = QFileInfo(m_fileName).baseName();
FASTLOGS(FLog::AutoSave, "AutoSave name is empty, constructing filename: %s", fileName.toStdString());
QDir dir;
QString autoSavePath = AuthoringSettings::singleton().autoSaveDir.absolutePath();
if (!dir.mkpath(autoSavePath))
{
FASTLOGS(FLog::AutoSave, "Can't make path: %s", autoSavePath.toStdString());
m_IOMutex.unlock();
return false;
}
QString fullFileName = QString("%1/%2_AutoSave_%3.rbxl").
arg(autoSavePath).
arg(fileName);
int count = 0;
while (QFile::exists(fullFileName.arg(count)) && count < 100)
++count;
FASTLOGS(FLog::AutoSave, "Full filename: %s", fullFileName.toStdString());
RBXASSERT(count < 100);
m_AutoSaveName = fullFileName.arg(count);
}
m_IOMutex.unlock();
}
catch(...)
{
FASTLOG(FLog::AutoSave, "Error on filename construction");
m_IOMutex.unlock();
return false;
}
try
{
RBX::StandardOut::singleton()->printf(RBX::MESSAGE_INFO,"Auto-Saving...");
bool result = saveAs(m_AutoSaveName);
if (result)
m_autoSaveDataModelHash = currentDataModelHash;
return result;
}
catch(...)
{
FASTLOG(FLog::AutoSave, "Error on AutoSave");
return false;
}
}
/**
* Set flag indicating that this place was loaded from an autosave file.
* The autosave file will not be deleted at close unless the file is saved with a different
* file name than the autosave name.
*/
void RobloxIDEDoc::setAutoSaveLoad()
{
FASTLOGS(FLog::AutoSave, "File was loaded from autosave, name: %s", m_fileName.toStdString());
m_AutoSaveName = m_fileName;
m_fileName.clear();
m_IsAutoSaveLoad = true;
}
void RobloxIDEDoc::resetDirty(RBX::DataModel* dataModel)
{
if (!dataModel)
return;
m_initialDataModelHash = StudioSerializerHelper::getDataModelHash(dataModel);
dataModel->setDirty(false);
m_RequiresSave = false;
}
/**
* Return the list of file filters for Open/Save dialogs
*/
const char* RobloxIDEDoc::getOpenFileFilters()
{
return "All Roblox Place Files (*rbxl *rbxlx);;Roblox Place Files (*.rbxl);;Roblox XML Place Files (*.rbxlx)";
}
const char* RobloxIDEDoc::getSaveFileFilters()
{
return "Roblox Place Files (*.rbxl);;Roblox XML Place Files (*.rbxlx)";
}
/**
* Toggle in-game stats.
*
* @param stat stats verb name
*/
void RobloxIDEDoc::toggleStats(const QString& stats)
{
RBX::Verb* verb = m_CurrentGame->m_Game->getDataModel()->getVerb(stats.toStdString());
setStatsEnabled(stats,!verb->isChecked());
}
/**
* Enable/disable in-game stats displays.
*
* @param stat stats verb name
* @param enabled true to show
*/
void RobloxIDEDoc::setStatsEnabled(const QString& stats, bool enabled, QAction* verbAction)
{
RBX::Verb* verb = m_CurrentGame->m_Game->getDataModel()->getVerb(stats.toStdString());
if (verb->isChecked() != enabled)
{
verb->doIt(m_CurrentGame->m_Game->getDataModel().get());
if (verbAction)
verbAction->setChecked(verb->isChecked());
}
QSettings settings;
settings.setValue(stats,enabled);
}
bool RobloxIDEDoc::displayAskConvertPlaceToNewMaterialsIfInsertNewModel()
{
bool conversionDialogDisabled = RobloxSettings().value(kMaterialPropertiesConvertDialogDisabled, false).toBool();
if (!conversionDialogDisabled)
{
// Create Dialog Box
std::string labelMessage = std::string("The model you are inserting was designed to work with the new Physical Properties system.") +
"\n\n To make this model work with your place, would you like to convert the place to work with new Physical Properties?\n";
QtUtilities::RBXConfirmationMessageBox msgBox(
QObject::tr(labelMessage.c_str()),
QObject::tr("Convert Place"),
QObject::tr("Do Not Convert")
);
msgBox.setMinimumWidth(350);
msgBox.setMinimumHeight(90);
// Execute Dialog Box
if (FFlag::CLI10590_FixConversionDialog)
{
UpdateUIManager::Instance().setBusy(true, false);
QApplication::setOverrideCursor(Qt::ArrowCursor);
msgBox.exec();
QApplication::restoreOverrideCursor();
UpdateUIManager::Instance().setBusy(false, false);
}
else
{
msgBox.exec();
}
// Process Dialog Response
bool convertResponse = false;
if (msgBox.getClickedYes())
{
convertResponse = true;
}
if (msgBox.getCheckBoxState())
{
RobloxSettings().setValue(kMaterialPropertiesConvertDialogDisabled, true);
RobloxSettings().setValue(kMaterialPropertiesConvertByDefault, convertResponse);
}
return convertResponse;
}
return RobloxSettings().value(kMaterialPropertiesConvertByDefault, false).toBool();
}
void RobloxIDEDoc::onWorkspacePropertyChanged(const RBX::Reflection::PropertyDescriptor* pDescriptor)
{
if (pDescriptor->name == RBX::Workspace::prop_physicalPropertiesMode.name)
{
switch (getEditDataModel()->getWorkspace()->getPhysicalPropertiesMode())
{
case PhysicalPropertiesMode_Legacy:
RBX::RobloxGoogleAnalytics::trackEvent(GA_CATEGORY_ACTION, "Physical Properties Mode", "Legacy");
break;
case PhysicalPropertiesMode_Default:
RBX::RobloxGoogleAnalytics::trackEvent(GA_CATEGORY_ACTION, "Physical Properties Mode", "Default");
break;
case PhysicalPropertiesMode_NewPartProperties:
RBX::RobloxGoogleAnalytics::trackEvent(GA_CATEGORY_ACTION, "Physical Properties Mode", "New");
break;
}
if (DFFlag::WorkspaceNotificationMasterEnable || DFInt::StudioWorkspaceNotificationLevel)
displayWorkspaceMessage();
if (getEditDataModel()->getWorkspace()->getUsingNewPhysicalProperties())
{
if (DataModel* dm = DataModel::get(getEditDataModel()->getWorkspace()))
{
RBX::PartInstance::convertToNewPhysicalPropRecursive(dm);
}
}
}
}
static void createDebuggerClient(shared_ptr<RBX::Instance> instance, RBX::Scripting::DebuggerManager* pDebuggerManager)
{
if (!instance || instance->isDescendantOf(RBX::ServiceProvider::find<RBX::CoreGuiService>(instance.get())))
return;
shared_ptr<RBX::Script> pScript = RBX::Instance::fastSharedDynamicCast<RBX::Script>(instance);
if (pScript)
{
//RBX::StandardOut::singleton()->printf(RBX::MESSAGE_INFO, "Script Name: %s", pScript->getName().c_str());
pDebuggerManager->addDebugger(pScript.get());
}
else
{
shared_ptr<RBX::ModuleScript> pModuleScript = RBX::Instance::fastSharedDynamicCast<RBX::ModuleScript>(instance);
if (pModuleScript)
pDebuggerManager->addDebugger(pModuleScript.get());
}
}
void RobloxIDEDoc::initializeDebuggerData(const QString &debugFile, const shared_ptr<RBX::DataModel> dm, const tDebuggersMap& debuggersMap)
{
if (!FFlag::LuaDebugger || (m_pMainWindow->getBuildMode() == BM_BASIC))
return;
RBX::Scripting::DebuggerManager& debuggerManager = RBX::Scripting::DebuggerManager::singleton();
// before setting data model make sure we 'cleanup' client manager to avoid receiving unnecessary signals being called
if (dm != DebuggerClientManager::Instance().getDataModel())
DebuggerClientManager::Instance().setDataModel(shared_ptr<RBX::DataModel>());
//set data model (so we can resolve references and save debugger data)
debuggerManager.setDataModel(dm.get());
//connect with debugger client manager also
DebuggerClientManager::Instance().setDataModel(dm);
//load debugger data
if (debugFile.isEmpty())
{
updateDebuggerManager(debuggersMap);
}
else
{
QFileInfo debugFileInfo(debugFile);
if (debugFileInfo.exists())
{
//deserialize data
std::ifstream stream(qPrintable(debugFile), std::ios_base::in | std::ios_base::binary);
try
{
RBX::SerializerBinary::deserialize(stream, &debuggerManager);
}
catch (std::runtime_error const&)
{
stream.close();
QFile::remove(debugFile); //remove invalid debug info file
//remove all children from debug manager and again set datamodel
debuggerManager.setDataModel(NULL);
debuggerManager.setDataModel(dm.get());
}
}
}
dm->visitDescendants(boost::bind(&createDebuggerClient, _1, &debuggerManager));
}
/**
* Sets the current grid snap mode.
*
* @param gridMode new grid snap mode
*/
void RobloxIDEDoc::setDraggerGridMode(RBX::DRAG::DraggerGridMode gridMode)
{
if ( gridMode == RBX::DRAG::ONE_STUD )
m_pMainWindow->gridToOneAction->activate(QAction::Trigger);
else if ( gridMode == RBX::DRAG::QUARTER_STUD )
m_pMainWindow->gridToOneFifthAction->activate(QAction::Trigger);
else
m_pMainWindow->gridToOffAction->activate(QAction::Trigger);
}
/**
* Sets the current 3d grid size.
*
* @param gridSize new 3d grid size
*/
void RobloxIDEDoc::setGridSize(int gridSize)
{
if ( gridSize == 2 )
m_pMainWindow->gridSizeToTwoAction->activate(QAction::Trigger);
else if ( gridSize == 16 )
m_pMainWindow->gridSizeToSixteenAction->activate(QAction::Trigger);
else
m_pMainWindow->gridSizeToFourAction->activate(QAction::Trigger);
}
static void placeNameLoadedHelperSuccess(QPointer<RobloxIDEDoc> doc, std::string json)
{
if (doc.isNull() || json.empty()) return;
QMetaObject::invokeMethod(doc, "placeNameLoaded", Qt::QueuedConnection,
Q_ARG(QString, QString::fromStdString(json)));
}
static void placeNameLoadedHelperError(QPointer<RobloxIDEDoc> doc, std::string error)
{
// didn't get name, just do nothing for now
}
void RobloxIDEDoc::placeNameLoaded(QString json)
{
RBX::Reflection::Variant v;
if (RBX::WebParser::parseJSONObject(json.toStdString(), v))
{
m_windowTitlePrefix = isCloudEditSession() ? kCloudEditPlacePrefix : kPublishedPlacePrefix;
updateDisplayName(QString::fromStdString(v.cast<shared_ptr<const Reflection::ValueTable> >()->at("Name").cast<std::string>()));
}
}
void RobloxIDEDoc::searchToolboxByDefaultSearchString()
{
RBXASSERT(m_EditGame.m_Game->getDataModel()->write_requested);
if (FFlag::SearchToolboxByDataModelSearchString)
if (Instance* defaultToolboxSearchInstance = m_EditGame.m_Game->getDataModel()->findFirstChildByName("DefaultToolboxSearch"))
if (StringValue* stringValue = RBX::Instance::fastDynamicCast<StringValue>(defaultToolboxSearchInstance))
{
QMetaObject::invokeMethod(&UpdateUIManager::Instance().getViewWidget<RobloxToolBox>(eDW_TOOLBOX),
"loadUrl", Qt::QueuedConnection, Q_ARG(QString,
QString("%1/%2%3").arg(RobloxSettings::getBaseURL()).arg("ide/clienttoolbox?searchset=").arg(stringValue->getValue().c_str())));
}
}
/**
* Slot called on emit of "workspaceLoadedSignal" signal
*/
void RobloxIDEDoc::onContentDataLoaded()
{
// required only at the time of loading
m_contentDataLoadedConnection.disconnect();
if (DFFlag::MaterialPropertiesEnabled)
{
RBXASSERT(!m_workspacePropertyChangedConnection.connected());
m_workspacePropertyChangedConnection = getEditDataModel()->getWorkspace()->propertyChangedSignal.connect(boost::bind(&RobloxIDEDoc::onWorkspacePropertyChanged, this, _1));
}
//Migrating CSG childData
CSGDictionaryService* dictionaryService = ServiceProvider::create<CSGDictionaryService>(m_EditGame.m_Game->getDataModel().get());
ChangeHistoryService* changeHistory = ServiceProvider::create<ChangeHistoryService>(m_EditGame.m_Game->getDataModel().get());
dictionaryService->reparentAllChildData();
changeHistory->resetBaseWaypoint();
if (FFlag::CSGPhysicsLevelOfDetailEnabled)
{
RBXASSERT(!m_dataModelItemChangedConnection.connected());
m_dataModelItemChangedConnection = getEditDataModel()->itemChangedSignal.connect(boost::bind(&RobloxIDEDoc::onDMItemChanged, this, _1, _2));
}
// delay initialization of debugger data
// while loading of contentData "Message" instance is created and once loading is done is gets deleted,
// but it's presence affects the child count in turn resulting in error on getting script from child number
QTimer::singleShot(0, this, SLOT(onDelayedInitializeDebuggerData()));
updateFromPlaceID(getDataModel()->getPlaceID());
QMetaObject::invokeMethod(&UpdateUIManager::Instance().getViewWidget<RobloxGameExplorer>(eDW_GAME_EXPLORER),
"openGameFromPlaceId", Qt::QueuedConnection, Q_ARG(int, m_EditGame.m_Game->getDataModel()->getPlaceID()));
searchToolboxByDefaultSearchString();
}
/**
* Slot called on emit of "saveFinishedSignal" signal
*/
void RobloxIDEDoc::onContentDataSaved()
{
// save debugger data
StudioSerializerHelper::saveDebuggerData(getDebugInfoFile());
}
/**
* Delayed initialization of debugger data
*/
void RobloxIDEDoc::onDelayedInitializeDebuggerData()
{
shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
// initialize debugger data
initializeDebuggerData(getDebugInfoFile(), dataModel);
// connect with saved data signal, so we can save the debug data
dataModel->saveFinishedSignal.connect(boost::bind(&RobloxIDEDoc::onContentDataSaved, this));
}
/**
* Gets upload URL for current datamodel
*/
QString RobloxIDEDoc::getUploadURL()
{
if (m_CurrentGame->m_Game && m_CurrentGame->m_Game->getDataModel())
{
if(RBX::Visit* pVisit = RBX::ServiceProvider::find<RBX::Visit>(m_CurrentGame->m_Game->getDataModel().get()))
return pVisit->getUploadUrl().c_str();
}
return QString();
}
/**
* Gets debug info file
*
* @param isAutoSaveFile true, if we need debug info file corresponding to auto save file
* @param debuggerFileExt extension to be added with the file name
*/
QString RobloxIDEDoc::getDebugInfoFile(bool isAutoSaveFile, const QString& debuggerFileExt)
{
QString fileName;
if (isAutoSaveFile)
{
// if we want to have autosave file name
fileName = m_AutoSaveName;
}
else
{
QString uploadURL = getUploadURL();
if (!uploadURL.isEmpty())
{
// get name based on the URL and assetID (used in EDIT mode)
fileName = uploadURL;
}
else if (m_fileName.isEmpty())
{
// if fileName is empty then get the display name
fileName = displayName();
}
else
{
// local file on disk
fileName = m_fileName;
}
}
return StudioUtilities::getDebugInfoFile(fileName, debuggerFileExt);
}
void RobloxIDEDoc::notifyScriptEdited(shared_ptr<RBX::Instance> script)
{
if (script)
{
m_playModifiedScriptList.push_back(new PlayModifiedScriptItem());
PlayModifiedScriptItem& item = *m_playModifiedScriptList.back();
item.instance = script;
item.ancestryChangedConnection = script->ancestryChangedSignal.connect(
boost::bind(&RobloxIDEDoc::onPlayModifiedAncestryChanged, this, script, _2));
}
}
void RobloxIDEDoc::onPlayModifiedAncestryChanged(shared_ptr<RBX::Instance> script, shared_ptr<RBX::Instance> newParent)
{
if (newParent==NULL)
{
for (tPlayModifiedScriptList::iterator iter = m_playModifiedScriptList.begin(); iter != m_playModifiedScriptList.end(); ++iter)
{
if ((*iter)->instance.get() == script.get())
{
delete (*iter);
m_playModifiedScriptList.erase(iter);
return;
}
}
}
}
void RobloxIDEDoc::clearPlayModifiedScriptList()
{
for (tPlayModifiedScriptList::iterator iter = m_playModifiedScriptList.begin(); iter != m_playModifiedScriptList.end(); ++iter)
{
delete (*iter);
}
m_playModifiedScriptList.clear();
}
void RobloxIDEDoc::addScriptMapping(shared_ptr<RBX::Instance> script, shared_ptr<RBX::DataModel> dataModel)
{
if (!script)
return;
std::vector<int> indexHierarchy;
std::string serviceName = getScriptIndexHierarchy(script, indexHierarchy);
shared_ptr<RBX::Instance> instance = getScriptByIndexHierarchy(dataModel, indexHierarchy, serviceName);
if (instance)
m_scriptMap[instance.get()] = script;
}
std::string RobloxIDEDoc::getScriptIndexHierarchy(shared_ptr<RBX::Instance> script, std::vector<int>& indexHierarchy)
{
if (!script)
return "";
indexHierarchy.clear();
const RBX::Instance* pParent = script->getParent();
const RBX::Instance* pChild = script.get();
while (pParent)
{
indexHierarchy.push_back(pParent->findChildIndex(pChild));
// if this parent is a service and a child of the DataModel.
if (pParent && dynamic_cast<const RBX::Service*>(pParent) &&
pParent->getParent() &&
pParent->getParent()->getParent() == NULL)
{
return pParent->getClassNameStr();
}
pChild = pParent;
pParent = pChild->getParent();
}
return "";
}
shared_ptr<RBX::Instance> RobloxIDEDoc::getScriptByIndexHierarchy(shared_ptr<RBX::DataModel> dataModel, const std::vector<int>& indexHierarchy, const std::string& serviceName)
{
if (serviceName == "")
return shared_ptr<RBX::Instance>();
shared_ptr<RBX::Instance> pParent = shared_from(dataModel->findFirstChildOfType(serviceName));
shared_ptr<RBX::Instance> pChild;
if (indexHierarchy.size() == 0)
return shared_ptr<RBX::Instance>();
for (int i = indexHierarchy.size() - 1; i >= 0; i--)
{
if (!pParent)
return shared_ptr<RBX::Instance>();
int childNum = indexHierarchy[i];
if (childNum >= (int)pParent->numChildren())
return shared_ptr<RBX::Instance>();
pChild = shared_from(pParent->getChild(childNum));
pParent = pChild;
}
if (pChild && (pChild->isA<RBX::Script>() || pChild->isA<RBX::ModuleScript>()))
return pChild;
return shared_ptr<RBX::Instance>();
}
boost::shared_ptr<RBX::Instance> RobloxIDEDoc::getEditScriptByPlayInstance(RBX::Instance* instance)
{
tScriptMap::iterator iter = m_scriptMap.find(instance);
if (iter != m_scriptMap.end())
return iter->second;
return boost::shared_ptr<RBX::Instance>();
}
void RobloxIDEDoc::initializeVideoRecording(GameState& gameState)
{
#ifdef _WIN32
if (gameState.m_View && m_pQOgreWidget)
{
RBXASSERT(!gameState.m_RecordToggleVerb);
gameState.m_RecordToggleVerb = new RecordToggleVerb(gameState.m_Game->getDataModel().get(), &gameState.m_View->getViewBase());
gameState.m_Verbs.append(gameState.m_RecordToggleVerb);
mapActionIDWithVerb(*m_CurrentGame, "toggleVideoRecordAction", gameState.m_RecordToggleVerb);
}
#endif
}
void RobloxIDEDoc::cleanupVideoRecording(GameState& gameState)
{
#ifdef _WIN32
if (gameState.m_RecordToggleVerb)
{
if (gameState.m_RecordToggleVerb->isRecording())
gameState.m_RecordToggleVerb->stopRecording(false);
gameState.m_Verbs.remove(gameState.m_Verbs.indexOf(gameState.m_RecordToggleVerb.get()));
delete gameState.m_RecordToggleVerb;
gameState.m_RecordToggleVerb = NULL;
}
#endif
}
void RobloxIDEDoc::saveEditModelDebuggerData()
{
if (m_EditGame.m_Game && m_EditGame.m_Game->getDataModel())
{
RBX::DataModel* dm = m_EditGame.m_Game->getDataModel().get();
dm->visitDescendants(boost::bind(&RobloxIDEDoc::addToDebuggersMap, this, _1, boost::ref(m_EditDebuggersMap)));
}
}
void RobloxIDEDoc::updateEditModelDebuggerData()
{
if (m_PlayGame.m_Game && m_PlayGame.m_Game->getDataModel())
{
RBX::DataModel* dm = m_PlayGame.m_Game->getDataModel().get();
dm->visitDescendants(boost::bind(&RobloxIDEDoc::updateDebuggersMap, this, _1, boost::ref(m_EditDebuggersMap)));
}
}
void RobloxIDEDoc::updateDebuggerManager(const tDebuggersMap& debuggers)
{
// recreate all debuggers based upon the saved mapping
RBX::Scripting::DebuggerManager& debuggerManager = RBX::Scripting::DebuggerManager::singleton();
boost::shared_ptr<RBX::Scripting::ScriptDebugger> debugger;
boost::shared_ptr<RBX::Scripting::DebuggerBreakpoint> breakpoint;
for (tDebuggersMap::const_iterator iter = debuggers.begin(); iter != debuggers.end(); ++iter)
{
debugger = debuggerManager.addDebugger(iter->first.get());
if (debugger)
{
const std::list<DebuggerData::BreakpointData>& breakpoints = iter->second.breakpoints;
for (std::list<DebuggerData::BreakpointData>::const_iterator bp_iter = breakpoints.begin(); bp_iter != breakpoints.end(); ++bp_iter)
{
breakpoint = debugger->setBreakpoint(bp_iter->line);
if (breakpoint)
RBX::Scripting::DebuggerBreakpoint::prop_Enabled.setValue(breakpoint.get(), bp_iter->enabled);
}
const std::list<std::string>& watches = iter->second.watches;
for (std::list<std::string>::const_iterator w_iter = watches.begin(); w_iter != watches.end(); ++w_iter)
{
debugger->addWatch(*w_iter);
}
}
}
}
void RobloxIDEDoc::addToDebuggersMap(shared_ptr<RBX::Instance> instance, tDebuggersMap& debuggersMap)
{
if (RBX::Instance::fastSharedDynamicCast<RBX::Script>(instance) || RBX::Instance::fastSharedDynamicCast<RBX::ModuleScript>(instance))
{
RBX::Scripting::DebuggerManager& debuggerManager = RBX::Scripting::DebuggerManager::singleton();
if (RBX::Scripting::ScriptDebugger* debugger = debuggerManager.findDebugger(instance.get()))
debuggersMap[instance] = getDebuggerData(debugger);
}
}
void RobloxIDEDoc::updateDebuggersMap(shared_ptr<RBX::Instance> instance, tDebuggersMap& debuggersMap)
{
if (RBX::Instance::fastSharedDynamicCast<RBX::Script>(instance) || RBX::Instance::fastSharedDynamicCast<RBX::ModuleScript>(instance))
{
shared_ptr<RBX::Instance> editScript = getEditScriptByPlayInstance(instance.get());
if (editScript)
{
RBX::Scripting::DebuggerManager& debuggerManager = RBX::Scripting::DebuggerManager::singleton();
if (RBX::Scripting::ScriptDebugger* debugger = debuggerManager.findDebugger(instance.get()))
debuggersMap[editScript] = getDebuggerData(debugger);
}
}
}
RobloxIDEDoc::DebuggerData RobloxIDEDoc::getDebuggerData(RBX::Scripting::ScriptDebugger* debugger)
{
DebuggerData data;
const Scripting::ScriptDebugger::Breakpoints& breakpoints = debugger->getBreakpoints();
for (RBX::Scripting::ScriptDebugger::Breakpoints::const_iterator iter = breakpoints.begin(); iter != breakpoints.end(); ++iter)
{
DebuggerData::BreakpointData bp;
bp.line = (iter->second->getLine());
bp.enabled = (iter->second->isEnabled());
data.breakpoints.push_back(bp);
}
data.breakpoints.sort(RobloxIDEDoc::DebuggerData::BreakpointLineNumberOrder());
const Scripting::ScriptDebugger::Watches& watches = debugger->getWatches();
for (RBX::Scripting::ScriptDebugger::Watches::const_iterator iter = watches.begin(); iter != watches.end(); ++iter)
{
data.watches.push_back((*iter)->getCondition());
}
return data;
}
bool RobloxIDEDoc::isEditMode(const RBX::Instance* context)
{
// serverIsPresent can return 'true' as soon as query for 'NetworkServer' service happens
// so explictly checking if we've actually launched Studio in server mode?
if (RobloxApplicationManager::instance().hasLocalServer())
return false;
return !RBX::Network::Players::clientIsPresent(context) && !RBX::Network::Players::findConstLocalPlayer(context);
}
void RobloxIDEDoc::forceViewSize(QSize viewSize)
{
if (!m_pQOgreWidget)
return;
if (!viewSize.isNull())
m_pQOgreWidget->setFixedSize(viewSize);
else
{
m_pQOgreWidget->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
m_pQOgreWidget->setMinimumSize(100, 100);
m_pQOgreWidget->setMaximumSize(20000, 20000);
}
m_WrapperWidget->setMinimumSize(m_pQOgreWidget->minimumSize());
}
void RobloxIDEDoc::updateDisplayName(const QString& newDisplayName)
{
if (m_displayName == newDisplayName)
return;
m_displayName = newDisplayName;
refreshDisplayName();
}
void RobloxIDEDoc::refreshDisplayName()
{
RobloxDocManager::Instance().setDocTitle(*this, displayName(), titleTooltip(), titleIcon());
}
void RobloxIDEDoc::forceReloadImages(const QStringList& contentIds)
{
if (!m_CurrentGame->m_View || !m_CurrentGame->m_Game || !m_CurrentGame->m_Game->getDataModel()) return;
RBX::ViewBase* pView = (&m_CurrentGame->m_View->getViewBase());
shared_ptr<RBX::DataModel> dm(m_CurrentGame->m_Game->getDataModel());
{
RBX::DataModel::LegacyLock lock(dm, RBX::DataModelJob::Write);
// Garbage collect calls clear content if the visual engine still has a ContentProvider,
// but the visual engine's ContentProvider is cleared when the workspace is set to null.
if (ContentProvider* cp = dm->find<ContentProvider>())
{
for (QStringList::const_iterator itr = contentIds.begin(); itr != contentIds.end(); ++itr)
{
cp->invalidateCache(ContentId(itr->toStdString()));
}
}
for (int i = 0; i < contentIds.size(); ++i)
{
std::string contentId = contentIds.at(i).toStdString();
pView->immediateAssetReload(contentId);
}
// This will trigger a full regeneration of geometry and refetching of textures.
// Calling immediateAssetReload also causes the reload to retry failed textures.
// Ideally immediateAssetReload could do a more targeted invalidation/regeneration eventually.
pView->bindWorkspace(shared_ptr<RBX::DataModel>());
pView->garbageCollect();
pView->bindWorkspace(dm);
}
}
const QIcon& RobloxIDEDoc::titleIcon() const
{
static QIcon icon;
if (icon.isNull())
icon.addFile(QString::fromUtf8(":/images/onlinePlaceIcon.png"), QSize(), QIcon::Normal, QIcon::Off);
if (DataModel* dm = getDataModel())
{
if (dm->getPlaceID() != 0)
{
return icon;
}
}
return m_emptyIcon;
}
void RobloxIDEDoc::updateFromPlaceID(int placeId)
{
if (RBX::HttpRbxApiService* apiService = RBX::ServiceProvider::find<RBX::HttpRbxApiService>(getDataModel()))
{
m_bIsLocalDocument = false;
apiService->getAsync( RBX::format("marketplace/productinfo?assetId=%d", placeId),false, RBX::PRIORITY_DEFAULT,
boost::bind(&placeNameLoadedHelperSuccess, QPointer<RobloxIDEDoc>(this), _1),
boost::bind(&placeNameLoadedHelperError, QPointer<RobloxIDEDoc>(this), _1));
}
}
const QString& RobloxIDEDoc::titleTooltip() const
{
if (!m_fileName.isEmpty())
return m_fileName;
return m_displayName;
}
void RobloxIDEDoc::resetMouseCommand(const char* mouseCommandToReset)
{
shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel();
if (dataModel)
{
RBX::Workspace* workspace = dataModel->getWorkspace();
RBX::MouseCommand* mouseCommand = workspace->getCurrentMouseCommand();
if (mouseCommand)
{
if (strcmp(mouseCommand->getName().c_str(), mouseCommandToReset) == 0)
workspace->setDefaultMouseCommand();
}
}
}
void RobloxIDEDoc::setMuteAllSounds(bool mute)
{
if (!m_CurrentGame)
{
return;
}
if (!m_CurrentGame->m_Game)
{
return;
}
RobloxMainWindow& mainWindow = UpdateUIManager::Instance().getMainWindow();
QAction* pAction = mainWindow.findChild<QAction*>("audioTurnOffAction");
if (pAction && pAction->isChecked())
{
return;
}
if (boost::shared_ptr<RBX::DataModel> dataModel = m_CurrentGame->m_Game->getDataModel())
{
if (RBX::Soundscape::SoundService* soundService = RBX::ServiceProvider::create<RBX::Soundscape::SoundService>(dataModel.get()))
{
if (soundService->isMuted() != mute)
{
soundService->muteAllChannels(mute);
if (pAction)
{
pAction->setChecked(mute);
}
}
}
}
}
void RobloxIDEDoc::initServerAudioBehavior()
{
if (AuthoringSettings::singleton().getTestServerAudioBehavior() == AuthoringSettings::Enabled)
{
return;
}
RobloxMainWindow& mainWindow = UpdateUIManager::Instance().getMainWindow();
// we want sound to behave like an online game, so completely disable sound
// also make sure the radio buttons do not work
if (AuthoringSettings::singleton().getTestServerAudioBehavior() == AuthoringSettings::OnlineGame)
{
RBX::Soundscape::SoundService::soundDisabled = true;
const QString disabledAudioText = "Audio has been disabled. Please go to File->Settings->Studio and then Server Audio Behavior to change this.";
if (QWidget* testMenu = mainWindow.findChild<QWidget*>("Test"))
{
if (QWidget* audioGroup = testMenu->findChild<QWidget*>("Audio"))
{
audioGroup->setEnabled(false);
audioGroup->setToolTip(disabledAudioText);
audioGroup->setStatusTip(disabledAudioText);
if (QAction* audioToggleWidget = mainWindow.findChild<QAction*>("audioToggleAction"))
{
audioToggleWidget->setToolTip(disabledAudioText);
audioToggleWidget->setStatusTip(disabledAudioText);
}
}
}
}
// just mute the instance for now
else if (AuthoringSettings::singleton().getTestServerAudioBehavior() == AuthoringSettings::Muted)
{
setMuteAllSounds(true);
if (QAction* audioToggleWidget = mainWindow.findChild<QAction*>("audioToggleAction"))
{
audioToggleWidget->setChecked(true);
}
}
}
void RobloxIDEDoc::promptForExistingAssetId(const std::string& assetType, boost::function<void(int)> resumeFunction, boost::function<void(std::string)> errorFunction)
{
QString assetTypeStr(assetType.c_str());
if (assetTypeStr.toLower() != "animation")
{
errorFunction("Requested asset type is not supported.");
return;
}
// make sure we launch dialog in Main Thread
QVariant resumeFunctionVar, errorFunctionVar;
resumeFunctionVar.setValue<boost::function<void(int)> >(resumeFunction);
errorFunctionVar.setValue<boost::function<void(std::string)> >(errorFunction);
QMetaObject::invokeMethod(this, "showImportAssetDialog", Qt::QueuedConnection,
Q_ARG(QVariant, resumeFunctionVar), Q_ARG(QVariant, errorFunctionVar));
}
void RobloxIDEDoc::showImportAssetDialog(QVariant resumeFunctionVar, QVariant errorFunctionVar)
{
if (!StudioUtilities::checkNetworkAndUserAuthentication())
{
boost::function<void(std::string)> errorFunction = errorFunctionVar.value<boost::function<void(std::string)> >();
RBXASSERT(errorFunction);
errorFunction("User not logged in.");
return;
}
boost::function<void(int)> resumeFunction = resumeFunctionVar.value<boost::function<void(int)> >();
RBXASSERT(resumeFunction);
QString importUrl(QString("%1/studio/animations/import").arg(RobloxSettings::getBaseURL()));
if (FFlag::StudioEnableGameAnimationsTab)
{
RobloxGameExplorer& gameExplorer = UpdateUIManager::Instance().getViewWidget<RobloxGameExplorer>(eDW_GAME_EXPLORER);
if (gameExplorer.getCurrentGameId() > 0)
importUrl.append(QString("?universeId=%1").arg(gameExplorer.getCurrentGameId()));
}
// show import dialog
ImportAssetDialog importDlg(m_pMainWindow, importUrl, getDataModel());
importDlg.exec();
// resume function returning the selected asset id
resumeFunction(importDlg.getAssetId());
}
QString RobloxIDEDoc::getRecentSaveFile()
{
QString fileToSave;
QString recentSavesPath = AuthoringSettings::singleton().recentSavesDir.absolutePath();
if (QDir().mkpath(recentSavesPath))
{
QFileInfo fileInfo(displayName());
QString baseName = fileInfo.baseName();
// make sure file name doesn't have invalid characters, replace them with '_'
baseName.replace( QRegExp( "[" + QRegExp::escape( "\\/:*?\"<>|" ) + "]" ), QString( "_" ) );
// differentiate between files with same name
// for local documents use hash created using file path
// for online documents use place id
if (m_bIsLocalDocument)
{
fileToSave = recentSavesPath+"/"+baseName+"_"+ QString::number(RBX::Hash::hash(QFileInfo(fileName()).absoluteFilePath().toStdString()))+".rbxl";
}
else
{
fileToSave = recentSavesPath+"/"+baseName+"_"+QString::number(getDataModel()->getPlaceID())+".rbxl";
}
}
return fileToSave;
}
void RobloxIDEDoc::clearOutputWidget()
{
if (AuthoringSettings::singleton().clearOutputOnStart)
m_pMainWindow->getOutputWidget()->clear();
}
void RobloxIDEDoc::onLocalPlayerAdded(shared_ptr<RBX::Instance> newPlayer)
{
m_localPlayerConnection = newPlayer->propertyChangedSignal.connect(boost::bind(&RobloxIDEDoc::onLocalPlayerNameChanged, this, _1));
}
void RobloxIDEDoc::onLocalPlayerNameChanged(const RBX::Reflection::PropertyDescriptor* pDescriptor)
{
if (*pDescriptor == RBX::Instance::desc_Name)
{
QMetaObject::invokeMethod(this, "syncPlayerName", Qt::QueuedConnection);
}
}
void RobloxIDEDoc::syncPlayerName()
{
RBX::DataModel* datamodel = getDataModel();
if (!datamodel)
return;
{
RBX::DataModel::LegacyLock lock(datamodel, RBX::DataModelJob::Read);
if (RBX::Network::Player* localPlayer = RBX::Network::Players::findLocalPlayer(datamodel))
m_displayName = localPlayer->getName().c_str();
}
// update window title and tab title
m_pMainWindow->updateWindowTitle();
refreshDisplayName();
}
void RobloxIDEDoc::appendTimeStampToDisplayName()
{
QString updatedDisplayName = displayName();
updatedDisplayName.append(" @ ");
updatedDisplayName.append(QDateTime::currentDateTime().toString("dd MMM yyyy hh:mm"));
updateDisplayName(updatedDisplayName);
}
void RobloxIDEDoc::removeTimeStampFromDisplayName()
{
QString updatedDisplayName = displayName();
int index = updatedDisplayName.lastIndexOf(" @ ");
if (index > 0)
{
updatedDisplayName = updatedDisplayName.left(index);
updateDisplayName(updatedDisplayName);
}
}
void RobloxIDEDoc::updateOnSimulationStateChange(bool run)
{
if (isCloudEditSession())
run ? appendTimeStampToDisplayName() : removeTimeStampFromDisplayName();
}
void RobloxIDEDoc::setTeamCreateWidgetEnabled(bool enable)
{
boost::shared_ptr<RBX::DataModel> dataModel;
boost::shared_ptr<PlayersDataManager> playersDataManager;
// enable only for local doc and edit mode
if (enable && !m_initializationScript.isEmpty())
enable = StudioUtilities::containsEditScript(m_initializationScript);
if (enable)
{
dataModel = m_EditGame.m_Game->getDataModel();
playersDataManager = m_EditGame.m_PlayerDataManager;
}
RobloxTeamCreateWidget& pTeamCreateWidget = UpdateUIManager::Instance().getViewWidget<RobloxTeamCreateWidget>(eDW_TEAM_CREATE);
pTeamCreateWidget.setDataModel(dataModel, playersDataManager);
if (enable)
{
// make sure we raise the dock widget to make sure it's on top if part of a tab
QWidget* pParentWidget = qobject_cast<QWidget*>(pTeamCreateWidget.parent());
if (pParentWidget && pParentWidget->isVisible())
QMetaObject::invokeMethod(pParentWidget, "raise", Qt::QueuedConnection);
}
}
void RobloxIDEDoc::initCloudEditObjects()
{
if (!isCloudEditSession())
{
RBXASSERT(false);
return;
}
shared_ptr<RBX::DataModel> dataModel = m_EditGame.m_Game->getDataModel();
m_EditGame.m_PlayerDataManager.reset(new PlayersDataManager(this, dataModel));
shared_ptr<PlayersDataManager> playersDataManager = m_EditGame.m_PlayerDataManager;
m_CloudEditAdornable.attach(dataModel, playersDataManager);
// since we want the chat widget to be enabled in Play solo session also, widget is not part of game state
QStackedWidget* pChatWidgetStack = UpdateUIManager::Instance().getChatWidgetStack();
if (pChatWidgetStack)
{
m_ChatWidget.reset(new RobloxChatWidget(pChatWidgetStack, dataModel, playersDataManager));
pChatWidgetStack->addWidget(m_ChatWidget.get());
pChatWidgetStack->setCurrentWidget(m_ChatWidget.get());
}
m_EditGame.m_TreeWidget->setPlayersDataManager(playersDataManager);
}
QString RobloxIDEDoc::downloadPlaceCopy()
{
RobloxSettings settings;
QString rbxmLastDir = settings.value("rbxm_last_directory").toString();
if (rbxmLastDir.isEmpty())
rbxmLastDir = RobloxMainWindow::getDefaultSavePath();
QString fileName = QFileDialog::getSaveFileName(&UpdateUIManager::Instance().getMainWindow(),
"Download a Copy",
rbxmLastDir,
saveFileFilters());
if (!fileName.isEmpty())
{
settings.setValue("rbxm_last_directory", QFileInfo(fileName).absolutePath());
bool result = saveAs(fileName);
if (result)
{
QString message = QString("Successfully downloaded a copy to '%1'").arg(QDir::toNativeSeparators(fileName));
RBX::StandardOut::singleton()->printf(RBX::MESSAGE_INFO, qPrintable(message));
return fileName;
}
}
return QString();
}
void RobloxIDEDoc::enableDownloadPlaceCopy(bool state)
{
// show only downloadPlaceCopyAction, reset of the actions must be invisible for CloudEdit
UpdateUIManager::Instance().getMainWindow().downloadPlaceCopyAction->setVisible(state);
UpdateUIManager::Instance().getMainWindow().publishToRobloxAsAction->setVisible(!state);
UpdateUIManager::Instance().getMainWindow().fileSaveAction->setVisible(!state);
UpdateUIManager::Instance().getMainWindow().fileSaveAsAction->setVisible(!state);
UpdateUIManager::Instance().getMainWindow().publishToRobloxAction->setVisible(!state);
}
static const int kMaxRecentlySavedFile = 5;
static QString recentlySavedFilesFile()
{
QString xmlFilePath(AuthoringSettings::singleton().recentSavesDir.absolutePath());
xmlFilePath.append("/");
xmlFilePath.append("RecentSaves.xml");
return xmlFilePath;
}
RecentlySavedFilesHandler::RecentlySavedFilesHandler()
{ readFileList(); }
RecentlySavedFilesHandler::~RecentlySavedFilesHandler()
{ saveFileList(); }
void RecentlySavedFilesHandler::addFile(const QString& fileName)
{
removeFile(fileName);
m_RecentlySavedFiles.prepend(fileName);
}
void RecentlySavedFilesHandler::removeFile(const QString& fileName)
{
if (m_RecentlySavedFiles.contains(fileName))
m_RecentlySavedFiles.removeAll(fileName);
}
void RecentlySavedFilesHandler::updateFileList()
{
while (m_RecentlySavedFiles.size() > kMaxRecentlySavedFile)
{
QFile::remove(m_RecentlySavedFiles.last());
m_RecentlySavedFiles.removeLast();
}
}
void RecentlySavedFilesHandler::saveFileList()
{
QFile file(recentlySavedFilesFile());
if (file.open(QFile::WriteOnly | QFile::Text))
{
//update list
updateFileList();
// create dom document
QDomDocument doc;
QDomElement root = doc.createElement("RecentSaves");
doc.appendChild(root);
for (int ii = 0; ii < m_RecentlySavedFiles.size(); ii++)
{
QDomElement newElement = doc.createElement("file");
newElement.setAttribute("name", m_RecentlySavedFiles.at(ii));
root.appendChild(newElement);
}
// save dom document to file
QTextStream out(&file);
out << doc.toString();
file.close();
}
}
void RecentlySavedFilesHandler::readFileList()
{
m_RecentlySavedFiles.clear();
QFile file(recentlySavedFilesFile());
if (file.open(QIODevice::ReadOnly))
{
QDomDocument doc;
if (doc.setContent(&file))
{
QDomElement domElement = doc.documentElement();
for (QDomElement iter = domElement.firstChildElement(); !iter.isNull(); iter = iter.nextSiblingElement())
{
if (iter.tagName().toLower() == "file")
{
QString fileName = iter.attribute("name");
if (QFileInfo(fileName).exists())
m_RecentlySavedFiles.append(fileName);
}
}
}
}
}
const char* attentionMessageStyleSheet = "QFrame{background:rgb(246, 136, 2);}:";
static const char* kWorkspaceNotificationMessageAlreadyClosed = "WorkspaceNotificationMessageAlreadyClosed";
std::string getNotificationId()
{
return DFString::WorkspaceMessageText + boost::to_string(DFInt::StudioWorkspaceNotificationLevel);
}
WorkspaceAnnouncementTooltip::WorkspaceAnnouncementTooltip(QWidget* parent)
{
resize(QSize(1,1));
setAttribute(Qt::WA_ShowWithoutActivating);
setFocusPolicy(Qt::NoFocus);
setWindowFlags(Qt::WindowStaysOnTopHint | Qt::ToolTip | Qt::FramelessWindowHint);
QSize parentSize = parent->size();
show();
setVisible(false);
resize(parentSize.width(), 50);
QHBoxLayout* mainLayout = new QHBoxLayout();
toolTipLabel = new QLabel(this);
toolTipLabel->setGeometry(4, 4, width(), 20);
toolTipLabel->setOpenExternalLinks(true);
toolTipLabel->setWordWrap(true);
toolTipLabel->setAlignment(Qt::AlignCenter);
toolTipLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
toolTipLabel->setTextFormat(Qt::RichText);
toolTipLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
closeButton = new QPushButton(this);
closeButton->setIcon(QIcon(":/RibbonBar/images/Studio 2.0 icons/32x32/x_white_32.png"));
closeButton->setIconSize(QSize(32, 32));
closeButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
closeButton->setFlat(true);
mainLayout->addWidget(toolTipLabel, 8);
mainLayout->addWidget(closeButton, 1);
setLayout(mainLayout);
setMaximumHeight(50);
setAutoFillBackground(true);
setStyleSheet(attentionMessageStyleSheet);
setParent(parent);
setLastClosedMessage(RobloxSettings().value(kWorkspaceNotificationMessageAlreadyClosed, "").toString());
connect(closeButton, SIGNAL (clicked()), this, SLOT (closeText()));
}
void WorkspaceAnnouncementTooltip::showText()
{
if (getLastClosedMessage() != QString(getNotificationId().c_str()))
{
if (!isVisible())
{
RBX::RobloxGoogleAnalytics::trackEvent(GA_CATEGORY_ACTION, "WorkspaceNotification - ShowText", getNotificationId().c_str());
QString customTextHyperlinkFormat;
QFont boldFont = toolTipLabel->font();
boldFont.setPointSize(10);
boldFont.setBold(true);
if (DFString::WorkspaceMessageLink == std::string(""))
{
// No Link
customTextHyperlinkFormat = QString("<a style='color: white;'>%2</a>");
toolTipLabel->setText(customTextHyperlinkFormat.arg(
DFString::WorkspaceMessageText.c_str()));
}
else
{
customTextHyperlinkFormat = QString("<a href=%1 style='color: white;'>%2</a>");
toolTipLabel->setText(customTextHyperlinkFormat.arg(
DFString::WorkspaceMessageLink.c_str(),
DFString::WorkspaceMessageText.c_str()));
}
toolTipLabel->setFont(boldFont);
}
QPoint ownerPosition = parentWidget()->pos();
setGeometry(ownerPosition.x(), ownerPosition.y(), parentWidget()->size().width(), 50);
setVisible(true);
}
}
void WorkspaceAnnouncementTooltip::hideText()
{
if (isVisible())
{
setVisible(false);
}
}
void WorkspaceAnnouncementTooltip::closeText()
{
RBX::RobloxGoogleAnalytics::trackEvent(GA_CATEGORY_ACTION, "WorkspaceNotification - CloseText", getNotificationId().c_str());
setVisible(false);
RobloxSettings().setValue(kWorkspaceNotificationMessageAlreadyClosed, getNotificationId().c_str());
setLastClosedMessage(getNotificationId().c_str());
}
Reference in New Issue View Git Blame Copy Permalink