void SplitPaneLayout::constructMenus()
{
// Hide the camera toggle option for non-floating views
IMenuManager& menuManager = GlobalUIManager().getMenuManager();
menuManager.setVisibility("main/view/cameraview", false);
// Add the commands for changing the camera position
GlobalEventManager().addToggle("CameraPositionTopLeft", boost::bind(&SplitPaneLayout::setCameraTopLeft, this, _1));
GlobalEventManager().addToggle("CameraPositionTopRight", boost::bind(&SplitPaneLayout::setCameraTopRight, this, _1));
GlobalEventManager().addToggle("CameraPositionBottomLeft", boost::bind(&SplitPaneLayout::setCameraBottomLeft, this, _1));
GlobalEventManager().addToggle("CameraPositionBottomRight", boost::bind(&SplitPaneLayout::setCameraBottomRight, this, _1));
// Add the corresponding menu items
menuManager.insert("main/view/camera", "cameraposition",
ui::menuFolder, _("Camera Position"), "", "");
menuManager.add("main/view/cameraposition", "camtopleft",
ui::menuItem, _("Top Left"), "", "CameraPositionTopLeft");
menuManager.add("main/view/cameraposition", "camtopright",
ui::menuItem, _("Top Right"), "", "CameraPositionTopRight");
menuManager.add("main/view/cameraposition", "cambottomleft",
ui::menuItem, _("Bottom Left"), "", "CameraPositionBottomLeft");
menuManager.add("main/view/cameraposition", "cambottomright",
ui::menuItem, _("Bottom Right"), "", "CameraPositionBottomRight");
updateCameraPositionToggles();
}
bool ShortcutChooser::onShortcutKeyPress(GdkEventKey* ev)
{
std::string statusText("");
/** greebo: Workaround for allowing Shift+TAB as well (Tab becomes ISO_Left_Tab in that case)
*/
if (ev->keyval == GDK_ISO_Left_Tab)
{
ev->keyval = GDK_Tab;
}
// Store the shortcut string representation into the Entry field
_entry->set_text(GlobalEventManager().getGDKEventStr(ev));
// Store this key/modifier combination for later use (UPPERCASE!)
_keyval = gdk_keyval_to_upper(ev->keyval);
_state = ev->state;
IEventPtr foundEvent = GlobalEventManager().findEvent(ev);
// Only display the note if any event was found and it's not the "self" event
if (!foundEvent->empty() && foundEvent != _event)
{
statusText = (boost::format(_("Note: This is already assigned to: <b>%s</b>")) %
GlobalEventManager().getEventName(foundEvent)).str();
}
_statusWidget->set_markup(statusText);
return true; // don't propagate
}
gboolean ShortcutChooser::onShortcutKeyPress(GtkWidget* widget, GdkEventKey* event, ShortcutChooser* self) {
std::string statusText("");
/** greebo: Workaround for allowing Shift+TAB as well (Tab becomes ISO_Left_Tab in that case)
*/
if (event->keyval == GDK_ISO_Left_Tab) {
event->keyval = GDK_Tab;
}
// Store the shortcut string representation into the GtkEntry field
gtk_entry_set_text(GTK_ENTRY(widget), GlobalEventManager().getGDKEventStr(event).c_str());
// Store this key/modifier combination for later use (UPPERCASE!)
self->_keyval = gdk_keyval_to_upper(event->keyval);
self->_state = event->state;
IEvent* foundEvent = GlobalEventManager().findEvent(event);
// Only display the note if any event was found and it's not the "self" event
if (foundEvent != NULL && foundEvent != self->_event) {
statusText = "Note: This is already assigned to: <b>";
statusText += GlobalEventManager().getEventName(foundEvent) + "</b>";
}
gtk_label_set_markup(GTK_LABEL(self->_statusWidget), statusText.c_str());
return true;
}
void Clipper::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "Clipper::initialiseModule called\n";
_useCaulk = registry::getValue<bool>(RKEY_CLIPPER_USE_CAULK);
_caulkShader = GlobalRegistry().get(RKEY_CLIPPER_CAULK_SHADER);
GlobalRegistry().signalForKey(RKEY_CLIPPER_USE_CAULK).connect(
sigc::mem_fun(this, &Clipper::keyChanged)
);
GlobalRegistry().signalForKey(RKEY_CLIPPER_CAULK_SHADER).connect(
sigc::mem_fun(this, &Clipper::keyChanged)
);
constructPreferences();
// Register the clip commands
GlobalCommandSystem().addCommand("ClipSelected", boost::bind(&Clipper::clipSelectionCmd, this, _1));
GlobalCommandSystem().addCommand("SplitSelected", boost::bind(&Clipper::splitSelectedCmd, this, _1));
GlobalCommandSystem().addCommand("FlipClip", boost::bind(&Clipper::flipClipperCmd, this, _1));
// Connect some events to these commands
GlobalEventManager().addCommand("ClipSelected", "ClipSelected");
GlobalEventManager().addCommand("SplitSelected", "SplitSelected");
GlobalEventManager().addCommand("FlipClip", "FlipClip");
}
void SplitPaneLayout::updateCameraPositionToggles()
{
// Update toggle state
GlobalEventManager().setToggled("CameraPositionTopLeft", _cameraPosition == QuadrantTopLeft);
GlobalEventManager().setToggled("CameraPositionTopRight", _cameraPosition == QuadrantTopRight);
GlobalEventManager().setToggled("CameraPositionBottomLeft", _cameraPosition == QuadrantBottomLeft);
GlobalEventManager().setToggled("CameraPositionBottomRight", _cameraPosition == QuadrantBottomRight);
}
void Entity_Construct ()
{
// instanciate once to register the preferences
entity::EntitySettings::Instance();
GlobalEventManager().addCommand("ConnectSelection", FreeCaller<selection::algorithm::connectSelectedEntities>());
GlobalEventManager().addCommand("GroupSelection", FreeCaller<selection::algorithm::groupSelected> ());
GlobalEventManager().addCommand("UngroupSelection", FreeCaller<selection::algorithm::ungroupSelected> ());
}
void ToolChanged ()
{
GlobalEventManager().setToggled("ToggleClipper", GlobalClipper().clipMode());
GlobalEventManager().setToggled("MouseTranslate", GlobalSelectionSystem().ManipulatorMode()
== SelectionSystem::eTranslate);
GlobalEventManager().setToggled("MouseRotate", GlobalSelectionSystem().ManipulatorMode()
== SelectionSystem::eRotate);
GlobalEventManager().setToggled("MouseScale", GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eScale);
GlobalEventManager().setToggled("MouseDrag", GlobalSelectionSystem().ManipulatorMode() == SelectionSystem::eDrag);
}
void CamWnd::disableDiscreteMoveEvents() {
GlobalEventManager().disableEvent("CameraForward");
GlobalEventManager().disableEvent("CameraBack");
GlobalEventManager().disableEvent("CameraLeft");
GlobalEventManager().disableEvent("CameraRight");
GlobalEventManager().disableEvent("CameraStrafeRight");
GlobalEventManager().disableEvent("CameraStrafeLeft");
GlobalEventManager().disableEvent("CameraUp");
GlobalEventManager().disableEvent("CameraDown");
GlobalEventManager().disableEvent("CameraAngleUp");
GlobalEventManager().disableEvent("CameraAngleDown");
}
static void Camera_motionDelta(int x, int y, unsigned int state, void *data) {
Camera* cam = reinterpret_cast<Camera*>(data);
cam->m_mouseMove.motion_delta(x, y, state);
cam->m_strafe = GlobalEventManager().MouseEvents().strafeActive(state);
if (cam->m_strafe) {
cam->m_strafe_forward = GlobalEventManager().MouseEvents().strafeForwardActive(state);
} else {
cam->m_strafe_forward = false;
}
}
void registerCommands()
{
GlobalCommandSystem().addCommand("CSGSubtract", subtractBrushesFromUnselected);
GlobalCommandSystem().addCommand("CSGMerge", mergeSelectedBrushes);
GlobalCommandSystem().addCommand("CSGHollow", hollowSelectedBrushes);
GlobalCommandSystem().addCommand("CSGRoom", makeRoomForSelectedBrushes);
GlobalEventManager().addCommand("CSGSubtract", "CSGSubtract");
GlobalEventManager().addCommand("CSGMerge", "CSGMerge");
GlobalEventManager().addCommand("CSGHollow", "CSGHollow");
GlobalEventManager().addCommand("CSGRoom", "CSGRoom");
}
void registerCommands()
{
GlobalCommandSystem().addCommand("ConnectSelection", selection::algorithm::connectSelectedEntities);
GlobalCommandSystem().addCommand("BindSelection", selection::algorithm::bindEntities);
GlobalCommandSystem().addCommand("CreateCurveNURBS", entity::createCurveNURBS);
GlobalCommandSystem().addCommand("CreateCurveCatmullRom", entity::createCurveCatmullRom);
GlobalEventManager().addCommand("ConnectSelection", "ConnectSelection");
GlobalEventManager().addCommand("BindSelection", "BindSelection");
GlobalEventManager().addRegistryToggle("ToggleFreeModelRotation", RKEY_FREE_MODEL_ROTATION);
GlobalEventManager().addCommand("CreateCurveNURBS", "CreateCurveNURBS");
GlobalEventManager().addCommand("CreateCurveCatmullRom", "CreateCurveCatmullRom");
}
void SplitPaneLayout::deconstructMenus()
{
// Show the camera toggle option again
GlobalUIManager().getMenuManager().setVisibility("main/view/cameraview", true);
// Remove the camera position menu items
GlobalUIManager().getMenuManager().remove("main/view/cameraposition");
// Remove the camera position events
GlobalEventManager().removeEvent("CameraPositionTopLeft");
GlobalEventManager().removeEvent("CameraPositionTopRight");
GlobalEventManager().removeEvent("CameraPositionBottomLeft");
GlobalEventManager().removeEvent("CameraPositionBottomRight");
}
void ModelCache::initialiseModule(const ApplicationContext& ctx) {
rMessage() << "ModelCache::initialiseModule called.\n";
GlobalCommandSystem().addCommand(
"RefreshModels",
boost::bind(&ModelCache::refreshModels, this, _1)
);
GlobalCommandSystem().addCommand(
"RefreshSelectedModels",
boost::bind(&ModelCache::refreshSelectedModels, this, _1)
);
GlobalEventManager().addCommand("RefreshModels", "RefreshModels");
GlobalEventManager().addCommand("RefreshSelectedModels", "RefreshSelectedModels");
}
virtual void initialiseModule(const ApplicationContext& ctx)
{
rMessage() << getName() << "::initialiseModule called." << std::endl;
// Associated "def_head" with an empty property editor instance
GlobalEntityInspector().registerPropertyEditor(
ui::DEF_HEAD_KEY, ui::IPropertyEditorPtr(new ui::AIHeadPropertyEditor())
);
GlobalEntityInspector().registerPropertyEditor(
ui::DEF_VOCAL_SET_KEY, ui::IPropertyEditorPtr(new ui::AIVocalSetPropertyEditor())
);
GlobalCommandSystem().addCommand("FixupMapDialog", ui::FixupMapDialog::RunDialog);
GlobalEventManager().addCommand("FixupMapDialog", "FixupMapDialog");
GlobalUIManager().getMenuManager().add("main/map",
"FixupMapDialog", ui::menuItem,
_("Fixup Map..."), // caption
"", // icon
"FixupMapDialog"
);
GlobalRadiant().signal_radiantStarted().connect(
sigc::ptr_fun(ui::AIEditingPanel::onRadiantStartup)
);
}
MRU::MRU() :
_numMaxFiles(registry::getValue<int>(RKEY_MRU_LENGTH)),
_loadLastMap(registry::getValue<bool>(RKEY_LOAD_LAST_MAP)),
_list(_numMaxFiles),
_emptyMenuItem(_(RECENT_FILES_CAPTION), *this, 0)
{
GlobalRegistry().signalForKey(RKEY_MRU_LENGTH).connect(
sigc::mem_fun(this, &MRU::keyChanged)
);
// Add the preference settings
constructPreferences();
// Create _numMaxFiles menu items
for (std::size_t i = 0; i < _numMaxFiles; i++) {
_menuItems.push_back(MRUMenuItem(string::to_string(i), *this, i+1));
MRUMenuItem& item = (*_menuItems.rbegin());
const std::string commandName = std::string("MRUOpen") + string::to_string(i+1);
// Connect the command to the last inserted menuItem
GlobalCommandSystem().addCommand(
commandName,
std::bind(&MRUMenuItem::activate, &item, std::placeholders::_1)
);
GlobalEventManager().addCommand(commandName, commandName);
}
}
void RadiantSelectionSystem::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "RadiantSelectionSystem::initialiseModule called.\n";
constructStatic();
SetManipulatorMode(eTranslate);
pivotChanged();
_sigSelectionChanged.connect(
sigc::mem_fun(this, &RadiantSelectionSystem::pivotChangedSelection)
);
GlobalGrid().signal_gridChanged().connect(
sigc::mem_fun(this, &RadiantSelectionSystem::pivotChanged)
);
GlobalRegistry().signalForKey(RKEY_ROTATION_PIVOT).connect(
sigc::mem_fun(this, &RadiantSelectionSystem::keyChanged)
);
// Pass a reference to self to the global event manager
GlobalEventManager().connectSelectionSystem(this);
// Connect the bounds changed caller
GlobalSceneGraph().signal_boundsChanged().connect(
sigc::mem_fun(this, &RadiantSelectionSystem::onSceneBoundsChanged)
);
GlobalRenderSystem().attachRenderable(*this);
}
void UIManager::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "UIManager::initialiseModule called" << std::endl;
_dialogManager = DialogManagerPtr(new DialogManager);
_menuManager.loadFromRegistry();
_toolbarManager.initialise();
ColourSchemeManager::Instance().loadColourSchemes();
GlobalCommandSystem().addCommand("EditColourScheme", ColourSchemeEditor::editColourSchemes);
GlobalEventManager().addCommand("EditColourScheme", "EditColourScheme");
GlobalRadiant().signal_radiantShutdown().connect(
sigc::mem_fun(this, &UIManager::clear)
);
// Add the statusbar command text item
_statusBarManager.addTextElement(
STATUSBAR_COMMAND,
"", // no icon
IStatusBarManager::POS_COMMAND
);
addLocalBitmapsAsIconFactory();
}
void SelectionSetToolmenu::onSelectionChanged(GtkComboBox* comboBox,
SelectionSetToolmenu* self)
{
GtkTreeIter iter;
if (gtk_combo_box_get_active_iter(comboBox, &iter))
{
std::string name = gtkutil::ComboBox::getActiveText(comboBox);
if (name.empty()) return;
ISelectionSetPtr set = GlobalSelectionSetManager().findSelectionSet(name);
if (set == NULL) return;
// The user can choose to DESELECT the set nodes when holding down shift
if ((GlobalEventManager().getModifierState() & GDK_SHIFT_MASK) != 0)
{
set->deselect();
}
else
{
set->select();
}
GtkWidget* childEntry = gtk_bin_get_child(GTK_BIN(self->_entry));
gtk_entry_set_text(GTK_ENTRY(childEntry), "");
}
}
/* greebo: Handle the mouseUp event. Usually, this means the end of an operation, so
* this has to check, if there are any callbacks connected, and call them if this is the case
*/
void RadiantWindowObserver::onMouseUp(const WindowVector& position, GdkEventButton* ev)
{
// Retrieve the according ObserverEvent for the GdkEventButton
ui::ObserverEvent observerEvent = GlobalEventManager().MouseEvents().getObserverEvent(ev);
// Only react, if the "select" or "manipulate" is held, ignore this otherwise
bool reactToEvent = (observerEvent == ui::obsManipulate || observerEvent == ui::obsSelect ||
observerEvent == ui::obsToggle || observerEvent == ui::obsToggleFace ||
observerEvent == ui::obsToggleGroupPart ||
observerEvent == ui::obsReplace || observerEvent == ui::obsReplaceFace);
if (reactToEvent)
{
// No mouse button is active anymore
_mouseDown = false;
// Store the current event in the observer classes
_selectObserver.setEvent(ev);
_manipulateObserver.setEvent(ev);
// Get the callback and call it with the arguments
if (_mouseUpCallback)
{
_mouseUpCallback(window_to_normalised_device(position, _width, _height));
}
}
// Stop listening for cancel events
_listenForCancelEvents = false;
// Disconnect the mouseMoved and mouseUp callbacks, mouse has been released
_mouseMotionCallback.clear();
_mouseUpCallback.clear();
}
void Doom3EntityCreator::initialiseModule(const ApplicationContext& ctx)
{
globalOutputStream() << "Doom3EntityCreator::initialiseModule called." << std::endl;
LightShader::m_defaultShader = GlobalRegistry().get("game/defaults/lightShader");
// Construct Doom3Group stuff
CurveEditInstance::initialiseShaders();
RenderablePivot::StaticShader() = GlobalRenderSystem().capture("$PIVOT");
GlobalRenderSystem().attachRenderable(RenderableTargetInstances::Instance());
GlobalEventManager().addRegistryToggle("ToggleShowAllLightRadii", RKEY_SHOW_ALL_LIGHT_RADII);
GlobalEventManager().addRegistryToggle("ToggleShowAllSpeakerRadii", RKEY_SHOW_ALL_SPEAKER_RADII);
GlobalEventManager().addRegistryToggle("ToggleDragResizeEntitiesSymmetrically", RKEY_DRAG_RESIZE_SYMMETRICALLY);
}
void MediaBrowser::registerCommandsAndPreferences()
{
// Add a page to the given group
PreferencesPagePtr page = GlobalPreferenceSystem().getPage(_("Settings/Media Browser"));
page->appendCheckBox("", _("Load media tree at startup"), RKEY_MEDIA_BROWSER_PRELOAD);
GlobalCommandSystem().addCommand("ToggleMediaBrowser", toggle);
GlobalEventManager().addCommand("ToggleMediaBrowser", "ToggleMediaBrowser");
}
gboolean CamWnd::disable_freelook_button_press(GtkWidget* widget, GdkEventButton* event, CamWnd* camwnd) {
if (event->type == GDK_BUTTON_PRESS) {
if (GlobalEventManager().MouseEvents().stateMatchesCameraViewEvent(ui::camDisableFreeLookMode, event)) {
camwnd->disableFreeMove();
return TRUE;
}
}
return FALSE;
}
void EClassManager::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "EntityClassDoom3::initialiseModule called." << std::endl;
GlobalFileSystem().addObserver(*this);
realise();
GlobalCommandSystem().addCommand("ReloadDefs", boost::bind(&EClassManager::reloadDefsCmd, this, _1));
GlobalEventManager().addCommand("ReloadDefs", "ReloadDefs");
}
/* Checks the passed xmlNode for a recognized item (ToolButton, ToggleToolButton, Separator)
* Returns the widget or NULL if nothing useful is found
*/
GtkWidget* ToolbarCreator::createToolItem(xml::Node& node, GtkToolbar* toolbar) {
const std::string nodeName = node.getName();
GtkWidget* toolItem;
if (nodeName == "separator") {
toolItem = GTK_WIDGET(gtk_separator_tool_item_new());
}
else if (nodeName == "toolbutton" || nodeName == "toggletoolbutton") {
// Found a button, load the values that are shared by both types
const std::string name = node.getAttributeValue("name");
const std::string icon = node.getAttributeValue("icon");
const std::string tooltip = _(node.getAttributeValue("tooltip").c_str());
const std::string action = node.getAttributeValue("action");
if (nodeName == "toolbutton") {
// Create a new GtkToolButton and assign the right callback
toolItem = GTK_WIDGET(gtk_tool_button_new(NULL, name.c_str()));
}
else {
// Create a new GtkToggleToolButton and assign the right callback
toolItem = GTK_WIDGET(gtk_toggle_tool_button_new());
}
IEvent* event = GlobalEventManager().findEvent(action);
if (event != NULL) {
event->connectWidget(GTK_WIDGET(toolItem));
// Tell the event to update the state of this button
event->updateWidgets();
} else {
globalErrorStream() << "ToolbarCreator: Failed to lookup command " << action << "\n";
}
// Set the tooltip, if not empty
if (!tooltip.empty()) {
gtk_tooltips_set_tip(_tooltips, GTK_WIDGET(toolItem), tooltip.c_str(), "");
//gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(toolItem), _tooltips, tooltip.c_str(), "");
}
// Load and assign the icon, if specified
if (icon != "") {
GtkWidget* image = gtk_image_new_from_pixbuf(gtkutil::getLocalPixbufWithMask(icon));
gtk_widget_show(image);
gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(toolItem), image);
}
}
else {
return NULL;
}
gtk_widget_show(toolItem);
return toolItem;
}
void ParticlesManager::initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "ParticlesManager::initialiseModule called" << std::endl;
// Load the .prt files
reloadParticleDefs();
// Register the "ReloadParticles" commands
GlobalCommandSystem().addCommand("ReloadParticles", boost::bind(&ParticlesManager::reloadParticleDefs, this));
GlobalEventManager().addCommand("ReloadParticles", "ReloadParticles");
}
void EntityList::onRadiantShutdown()
{
// Tell the position tracker to save the information
_windowPosition.saveToPath(RKEY_WINDOW_STATE);
GlobalSelectionSystem().removeObserver(this);
GlobalEventManager().disconnectDialogWindow(GTK_WINDOW(getWindow()));
// Destroy the transient window
destroy();
}
CamWnd::~CamWnd() {
// Subscribe to the global scene graph update
GlobalSceneGraph().removeSceneObserver(this);
if (m_bFreeMove) {
disableFreeMove();
}
removeHandlersMove();
g_signal_handler_disconnect(G_OBJECT(m_gl_widget), m_sizeHandler);
g_signal_handler_disconnect(G_OBJECT(m_gl_widget), m_exposeHandler);
gtk_widget_unref(m_gl_widget);
// Disconnect self from EventManager\r
GlobalEventManager().disconnect(GTK_OBJECT(m_gl_widget));
GlobalEventManager().disconnect(GTK_OBJECT(m_parent));
delete m_window_observer;
}
LayerCommandTarget::LayerCommandTarget(int layerID) :
_layerID(layerID)
{
GlobalCommandSystem().addCommand(
COMMAND_PREFIX_ADDTOLAYER + string::to_string(_layerID),
std::bind(&LayerCommandTarget::addSelectionToLayer, this, std::placeholders::_1)
);
GlobalEventManager().addCommand(
COMMAND_PREFIX_ADDTOLAYER + string::to_string(_layerID),
COMMAND_PREFIX_ADDTOLAYER + string::to_string(_layerID)
);
GlobalCommandSystem().addCommand(
COMMAND_PREFIX_MOVETOLAYER + string::to_string(_layerID),
std::bind(&LayerCommandTarget::moveSelectionToLayer, this, std::placeholders::_1)
);
GlobalEventManager().addCommand(
COMMAND_PREFIX_MOVETOLAYER + string::to_string(_layerID),
COMMAND_PREFIX_MOVETOLAYER + string::to_string(_layerID)
);
GlobalCommandSystem().addCommand(
COMMAND_PREFIX_SHOWLAYER + string::to_string(_layerID),
std::bind(&LayerCommandTarget::showLayer, this, std::placeholders::_1)
);
GlobalEventManager().addCommand(
COMMAND_PREFIX_SHOWLAYER + string::to_string(_layerID),
COMMAND_PREFIX_SHOWLAYER + string::to_string(_layerID)
);
GlobalCommandSystem().addCommand(
COMMAND_PREFIX_HIDELAYER + string::to_string(_layerID),
std::bind(&LayerCommandTarget::hideLayer, this, std::placeholders::_1)
);
GlobalEventManager().addCommand(
COMMAND_PREFIX_HIDELAYER + string::to_string(_layerID),
COMMAND_PREFIX_HIDELAYER + string::to_string(_layerID)
);
}
FindAndReplaceShader::FindAndReplaceShader() :
gtkutil::BlockingTransientWindow(_(FINDDLG_WINDOW_TITLE), GlobalMainFrame().getTopLevelWindow())
{
set_default_size(FINDDLG_DEFAULT_SIZE_X, FINDDLG_DEFAULT_SIZE_Y);
set_border_width(12);
set_type_hint(Gdk::WINDOW_TYPE_HINT_DIALOG);
// Create all the widgets
populateWindow();
// Propagate shortcuts to the main window
GlobalEventManager().connectDialogWindow(this);
}
virtual void initialiseModule(const ApplicationContext& ctx)
{
rMessage() << "UndoSystem::initialiseModule called" << std::endl;
// Add commands for console input
GlobalCommandSystem().addCommand("Undo", boost::bind(&RadiantUndoSystem::undoCmd, this, _1));
GlobalCommandSystem().addCommand("Redo", boost::bind(&RadiantUndoSystem::redoCmd, this, _1));
// Bind events to commands
GlobalEventManager().addCommand("Undo", "Undo");
GlobalEventManager().addCommand("Redo", "Redo");
_undoLevels = registry::getValue<int>(RKEY_UNDO_QUEUE_SIZE);
// Add self to the key observers to get notified on change
GlobalRegistry().signalForKey(RKEY_UNDO_QUEUE_SIZE).connect(
sigc::mem_fun(this, &RadiantUndoSystem::keyChanged)
);
// add the preference settings
constructPreferences();
}
