mirror of
https://github.com/copyrighttxt/watrbx-game-engine.git
synced 2026-09-04 20:57:49 +00:00
748 lines
17 KiB
C++
748 lines
17 KiB
C++
/**
|
|
* RobloxStudioVerbs.h
|
|
* Copyright (c) 2013 ROBLOX Corp. All Rights Reserved.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
// Qt Headers
|
|
#include <QProcess>
|
|
#include <QMutex>
|
|
|
|
// Roblox Headers
|
|
#include "v8tree/Verb.h"
|
|
#include "v8datamodel/Commands.h"
|
|
#include "MobileDevelopmentDeployer.h"
|
|
|
|
//Studio Headers
|
|
#include "RobloxIDEDoc.h"
|
|
#include "RobloxDocManager.h"
|
|
#include "PairRbxDeviceDialog.h"
|
|
#include "ManageEmulationDeviceDialog.h"
|
|
#include "ScriptPickerDialog.h"
|
|
|
|
namespace RBX {
|
|
class Instance;
|
|
class DataModel;
|
|
class VideoControl;
|
|
class ViewBase;
|
|
class ChangeHistoryService;
|
|
class LuaSourceContainer;
|
|
}
|
|
|
|
class RobloxMainWindow;
|
|
class WebDialog;
|
|
class IRobloxDoc;
|
|
class InsertAdvancedObjectDialog;
|
|
|
|
|
|
class GroupSelectionVerb : public RBX::EditSelectionVerb
|
|
{
|
|
private:
|
|
typedef RBX::EditSelectionVerb Super;
|
|
|
|
public:
|
|
GroupSelectionVerb(RBX::DataModel* dataModel);
|
|
virtual bool isEnabled() const;
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
};
|
|
|
|
class UngroupSelectionVerb : public RBX::EditSelectionVerb
|
|
{
|
|
private:
|
|
typedef RBX::EditSelectionVerb Super;
|
|
|
|
public:
|
|
UngroupSelectionVerb(RBX::DataModel* dataModel);
|
|
virtual bool isEnabled() const;
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// CSG Operations
|
|
|
|
class UnionSelectionVerb : public RBX::EditSelectionVerb
|
|
{
|
|
private:
|
|
typedef RBX::EditSelectionVerb Super;
|
|
|
|
public:
|
|
UnionSelectionVerb(RBX::DataModel* dataModel);
|
|
|
|
void performUnion(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const;
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
};
|
|
|
|
class NegateSelectionVerb : public RBX::EditSelectionVerb
|
|
{
|
|
private:
|
|
typedef RBX::EditSelectionVerb Super;
|
|
|
|
public:
|
|
NegateSelectionVerb(RBX::DataModel* dataModel);
|
|
|
|
virtual bool isEnabled() const;
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
};
|
|
|
|
class SeparateSelectionVerb : public RBX::EditSelectionVerb
|
|
{
|
|
private:
|
|
typedef RBX::EditSelectionVerb Super;
|
|
|
|
public:
|
|
SeparateSelectionVerb(RBX::DataModel* dataModel);
|
|
|
|
virtual bool isEnabled() const;
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
void performSeparate(RBX::IDataState* dataState);
|
|
};
|
|
|
|
class CutVerb : public RBX::DeleteSelectionVerb
|
|
{
|
|
public:
|
|
CutVerb(RBX::DataModel* dataModel);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
};
|
|
|
|
class CopyVerb : public RBX::EditSelectionVerb
|
|
{
|
|
public:
|
|
CopyVerb(RBX::DataModel* dataModel);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
};
|
|
|
|
class PasteVerb :public QObject, public RBX::Verb
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
PasteVerb(RBX::DataModel* dataModel, bool pasteInto);
|
|
virtual bool isEnabled() const;
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
private Q_SLOTS:
|
|
void onClipboardModified();
|
|
|
|
private:
|
|
void createInstancesFromClipboard(shared_ptr<RBX::Instances> items);
|
|
void insertInstancesIntoParent(shared_ptr<RBX::Instances> items);
|
|
void createInstancesFromClipboardDep(RBX::Instances& itemsToPaste);
|
|
void insertInstancesIntoParentDep(RBX::Instances& itemsToPaste);
|
|
|
|
bool isPasteInfoAvailable() const;
|
|
|
|
RBX::DataModel *m_pDataModel;
|
|
const bool m_bPasteInto;
|
|
bool m_bIsPasteInfoAvailable;
|
|
};
|
|
|
|
class DuplicateSelectionVerb :public QObject, public RBX::EditSelectionVerb
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
DuplicateSelectionVerb(RBX::DataModel* dataModel);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
};
|
|
|
|
class UndoVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
UndoVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isChecked() const
|
|
{ return false; }
|
|
|
|
virtual bool isEnabled() const;
|
|
virtual std::string getText() const;
|
|
private:
|
|
RBX::DataModel* m_pDataModel;
|
|
boost::shared_ptr<RBX::ChangeHistoryService> m_pChangeHistory;
|
|
};
|
|
|
|
class RedoVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
RedoVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isChecked() const
|
|
{ return false; }
|
|
|
|
virtual bool isEnabled() const;
|
|
virtual std::string getText() const;
|
|
private:
|
|
RBX::DataModel* m_pDataModel;
|
|
boost::shared_ptr<RBX::ChangeHistoryService> m_pChangeHistory;
|
|
};
|
|
|
|
class InsertModelVerb:public RBX::Verb
|
|
{
|
|
public:
|
|
InsertModelVerb(RBX::VerbContainer* pVerbContainer, bool insertInto);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isChecked() const
|
|
{ return false; }
|
|
|
|
virtual bool isEnabled() const { return true; };
|
|
|
|
private:
|
|
void insertModel();
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
const bool m_bInsertInto;
|
|
};
|
|
|
|
class SelectionSaveToFileVerb:public RBX::Verb
|
|
{
|
|
public:
|
|
SelectionSaveToFileVerb(RBX::VerbContainer* pVerbContainer);
|
|
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
virtual bool isEnabled() const;
|
|
|
|
private:
|
|
void saveToFile();
|
|
std::auto_ptr<XmlElement> writeSelection();
|
|
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class PublishToRobloxAsVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
PublishToRobloxAsVerb(RBX::VerbContainer* pVerbContainer, RobloxMainWindow* mainWnd);
|
|
virtual ~PublishToRobloxAsVerb();
|
|
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isChecked() const
|
|
{ return false; }
|
|
|
|
virtual bool isEnabled() const;
|
|
void initDialog();
|
|
|
|
QDialog* getPublishDialog();
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
RobloxMainWindow *m_pMainWindow;
|
|
WebDialog *m_dlg;
|
|
};
|
|
|
|
class PublishToRobloxVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
PublishToRobloxVerb(RBX::VerbContainer* pVerbContainer, RobloxMainWindow* mainWnd);
|
|
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
virtual bool isChecked() const { return false; }
|
|
virtual bool isEnabled() const;
|
|
void onEventPublishingFinished();
|
|
|
|
private:
|
|
|
|
void save(RBX::ContentId contentID,bool* outError,QString* outErrorTitle,QString* outErrorText);
|
|
|
|
bool m_bIsPublishInProcess;
|
|
RBX::DataModel *m_pDataModel;
|
|
RobloxMainWindow *m_pMainWindow;
|
|
QMutex publishingMutex;
|
|
};
|
|
|
|
class PublishSelectionToRobloxVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
PublishSelectionToRobloxVerb(RBX::VerbContainer* pVerbContainer, RobloxMainWindow* mainWnd);
|
|
virtual ~PublishSelectionToRobloxVerb();
|
|
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isChecked() const
|
|
{ return false; }
|
|
|
|
virtual bool isEnabled() const;
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
RobloxMainWindow *m_pMainWindow;
|
|
WebDialog* m_dlg;
|
|
};
|
|
|
|
class CreateNewLinkedSourceVerb : public QObject, public RBX::Verb
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
CreateNewLinkedSourceVerb(RBX::DataModel* pVerbContainer);
|
|
|
|
virtual bool isEnabled() const;
|
|
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
|
|
shared_ptr<RBX::LuaSourceContainer> getLuaSourceContainer() const;
|
|
void doItThread(std::string source, int currentGameId, boost::optional<int> groupId, QString name, bool* success);
|
|
};
|
|
|
|
class PublishAsPluginVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
PublishAsPluginVerb(RBX::VerbContainer* pVerbContainer, RobloxMainWindow* mainWnd);
|
|
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const;
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
RobloxMainWindow *m_pMainWindow;
|
|
boost::scoped_ptr<WebDialog> m_dlg;
|
|
};
|
|
|
|
class LaunchInstancesVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
enum SimulationType
|
|
{
|
|
PLAYSOLO = 1,
|
|
SERVERONEPLAYER = 2,
|
|
SERVERFOURPLAYERS = 5
|
|
};
|
|
|
|
LaunchInstancesVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
|
|
|
|
private:
|
|
RBX::VerbContainer *m_pVerbContainer;
|
|
};
|
|
|
|
class StartServerAndPlayerVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
StartServerAndPlayerVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
void launchPlayers(int numPlayers);
|
|
|
|
private:
|
|
static void launchStudioInstances(RBX::VerbContainer *pVerbContainer, int numPlayers);
|
|
RBX::VerbContainer *m_pVerbContainer;
|
|
};
|
|
|
|
class ServerPlayersStateInitVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
ServerPlayersStateInitVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isChecked() const;
|
|
};
|
|
|
|
class CreatePluginVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
CreatePluginVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
|
|
private:
|
|
RBX::VerbContainer *m_pVerbContainer;
|
|
};
|
|
|
|
class PairRbxDevVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
PairRbxDevVerb(RBX::VerbContainer* pVerbContainer, QWidget* newParent);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
|
|
private:
|
|
shared_ptr<PairRbxDeviceDialog> dialog;
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class ManageEmulationDevVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
ManageEmulationDevVerb(RBX::VerbContainer* pVerbContainer, QWidget* newParent);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
|
|
private:
|
|
shared_ptr<ManageEmulationDeviceDialog> dialog;
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class AudioToggleVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
AudioToggleVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
virtual bool isChecked() const;
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class AnalyzePhysicsToggleVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
AnalyzePhysicsToggleVerb(RBX::DataModel*);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
void startAnalyze();
|
|
void stopAnalyze();
|
|
|
|
virtual bool isEnabled() const;
|
|
virtual bool isChecked() const;
|
|
|
|
private:
|
|
RBX::DataModel* m_pDataModel;
|
|
};
|
|
|
|
class PlaySoloVerb: public RBX::Verb
|
|
{
|
|
|
|
public:
|
|
PlaySoloVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class StartServerVerb: public RBX::Verb
|
|
{
|
|
|
|
public:
|
|
StartServerVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class StartPlayerVerb: public RBX::Verb
|
|
{
|
|
|
|
public:
|
|
StartPlayerVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class ToggleFullscreenVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
ToggleFullscreenVerb(RBX::VerbContainer* container);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
virtual bool isEnabled() const;
|
|
};
|
|
|
|
class ShutdownClientVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
ShutdownClientVerb(RBX::VerbContainer* container, IRobloxDoc *pDoc);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
private:
|
|
IRobloxDoc *m_pIDEDoc;
|
|
};
|
|
|
|
class ShutdownClientAndSaveVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
ShutdownClientAndSaveVerb(RBX::VerbContainer* container, IRobloxDoc* pDoc);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
private:
|
|
IRobloxDoc* m_pIDEDoc;
|
|
};
|
|
|
|
class LeaveGameVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
LeaveGameVerb(RBX::VerbContainer* container, IRobloxDoc *pDoc);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
private:
|
|
IRobloxDoc *m_pIDEDoc;
|
|
};
|
|
|
|
|
|
|
|
class ToggleAxisWidgetVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
ToggleAxisWidgetVerb(RBX::DataModel*);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
virtual bool isEnabled() const { return true; }
|
|
virtual bool isChecked() const;
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class Toggle3DGridVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
Toggle3DGridVerb(RBX::DataModel*);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
virtual bool isEnabled() const;
|
|
virtual bool isChecked() const;
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class ToggleCollisionCheckVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
ToggleCollisionCheckVerb(RBX::DataModel*);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
virtual bool isEnabled() const { return true; }
|
|
virtual bool isChecked() const;
|
|
};
|
|
|
|
class ToggleLocalSpaceVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
ToggleLocalSpaceVerb(RBX::DataModel*);
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
virtual bool isEnabled() const { return true; }
|
|
virtual bool isChecked() const;
|
|
private:
|
|
RBX::DataModel* m_pDataModel;
|
|
};
|
|
|
|
class ScreenshotVerb : public QObject, public RBX::Verb
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
ScreenshotVerb(RBX::DataModel* pDataModel);
|
|
|
|
virtual void doIt(RBX::IDataState*);
|
|
virtual bool isEnabled() const;
|
|
|
|
static void DoPostImage(shared_ptr<RBX::DataModel> spDataModel, const QString &fileName, const QString &seoStr);
|
|
|
|
void reconnectScreenshotSignal();
|
|
|
|
private Q_SLOTS:
|
|
void showPostImageWebDialog();
|
|
void copyImageToClipboard();
|
|
|
|
private:
|
|
void onScreenshotFinished(const std::string &filename);
|
|
void onUploadSignal(bool finished);
|
|
QString getSEOStr();
|
|
|
|
|
|
static void PostImageFinished(std::string *pResponse, std::exception *pException, weak_ptr<RBX::DataModel> pWeakDataModel);
|
|
static void showMessage(shared_ptr<RBX::DataModel> pWeakDataModel, const char* message);
|
|
|
|
boost::shared_ptr<RBX::DataModel> m_spDataModel;
|
|
QString m_fileToUpload;
|
|
};
|
|
|
|
class InsertAdvancedObjectViewVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
InsertAdvancedObjectViewVerb(RBX::VerbContainer* pVerbContainer);
|
|
virtual ~InsertAdvancedObjectViewVerb();
|
|
|
|
void doIt(RBX::IDataState* dataState);
|
|
virtual bool isEnabled() const;
|
|
virtual bool isChecked() const;
|
|
};
|
|
|
|
class JointToolHelpDialogVerb: public RBX::Verb
|
|
{
|
|
|
|
public:
|
|
JointToolHelpDialogVerb(RBX::VerbContainer* pVerbContainer);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
virtual bool isChecked() const { return false; }
|
|
};
|
|
|
|
class StudioMaterialVerb: public RBX::MaterialVerb
|
|
{
|
|
public:
|
|
StudioMaterialVerb(RBX::DataModel* dataModel);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
virtual bool isChecked() const;
|
|
|
|
static bool sMaterialActionActAsTool;
|
|
};
|
|
|
|
class StudioColorVerb: public RBX::ColorVerb
|
|
{
|
|
public:
|
|
StudioColorVerb(RBX::DataModel* dataModel);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled() const { return true; }
|
|
virtual bool isChecked() const;
|
|
|
|
static bool sColorActionActAsTool;
|
|
|
|
private:
|
|
void addColorToIcon();
|
|
};
|
|
|
|
class OpenToolBoxWithOptionsVerb: public QObject, public RBX::Verb
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
OpenToolBoxWithOptionsVerb(RBX::VerbContainer* pVerbContainer);
|
|
~OpenToolBoxWithOptionsVerb();
|
|
|
|
void doIt(RBX::IDataState* dataState);
|
|
virtual bool isEnabled();
|
|
|
|
private Q_SLOTS:
|
|
void handleDockVisibilityChanged(bool isVisible);
|
|
};
|
|
|
|
class InsertBasicObjectVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
InsertBasicObjectVerb(RBX::DataModel* dataModel);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
virtual bool isEnabled();
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class JointCreationModeVerb: public RBX::Verb
|
|
{
|
|
public:
|
|
JointCreationModeVerb(RBX::DataModel* dataModel);
|
|
void doIt(RBX::IDataState* dataState);
|
|
|
|
private:
|
|
void updateMenuIcon();
|
|
void updateMenuActions();
|
|
};
|
|
|
|
#ifdef Q_WS_WIN32 // must be Q_WS_WIN32 so moc picks it up
|
|
|
|
class RecordToggleVerb:public QObject, public RBX::Verb
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
RecordToggleVerb(RBX::DataModel*, RBX::ViewBase* pViewGfx);
|
|
~RecordToggleVerb();
|
|
|
|
virtual bool isEnabled() const;
|
|
virtual bool isChecked() const;
|
|
virtual bool isSelected() const;
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
void startRecording();
|
|
void stopRecording(bool showUploadDialog = true);
|
|
bool isRecording() const;
|
|
|
|
private Q_SLOTS:
|
|
void uploadVideo();
|
|
|
|
private:
|
|
void action();
|
|
|
|
boost::scoped_ptr<RBX::VideoControl> m_pVideoControl;
|
|
boost::scoped_ptr<boost::thread> m_helperThread;
|
|
|
|
RBX::DataModel *m_pDataModel;
|
|
boost::function<void()> m_job;
|
|
|
|
RBX::CEvent m_jobWait;
|
|
RBX::CEvent m_jobDone;
|
|
RBX::CEvent m_threadDone;
|
|
|
|
bool m_bStop;
|
|
bool m_bIsBusy;
|
|
};
|
|
|
|
#endif
|
|
|
|
class ExportSelectionVerb:public QObject, public RBX::Verb
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
ExportSelectionVerb(RBX::DataModel*);
|
|
|
|
virtual bool isEnabled() const { return (RobloxDocManager::Instance().getPlayDoc() != NULL); }
|
|
virtual bool isChecked() const { return false; }
|
|
virtual bool isSelected() const { return false; }
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class ExportPlaceVerb : public QObject, public RBX::Verb
|
|
{
|
|
Q_OBJECT
|
|
public:
|
|
ExportPlaceVerb(RBX::DataModel*);
|
|
|
|
virtual bool isEnabled() const { return (RobloxDocManager::Instance().getPlayDoc() != NULL); }
|
|
virtual bool isChecked() const { return false; }
|
|
virtual bool isSelected() const { return false; }
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class LaunchHelpForSelectionVerb : public RBX::Verb
|
|
{
|
|
public:
|
|
LaunchHelpForSelectionVerb(RBX::DataModel*);
|
|
|
|
virtual bool isEnabled() const;
|
|
virtual void doIt(RBX::IDataState* dataState);
|
|
|
|
private:
|
|
RBX::DataModel *m_pDataModel;
|
|
};
|
|
|
|
class DummyVerb : public RBX::Verb {
|
|
public:
|
|
DummyVerb(RBX::VerbContainer* container, const char* name)
|
|
:Verb(container, name)
|
|
{
|
|
}
|
|
virtual bool isEnabled() const {return false;}
|
|
|
|
virtual void doIt(RBX::IDataState* dataState) {}
|
|
};
|