// greebo: This should be called "onComponentSelectionChanged", as it is a similar function of the above one
// Updates the internal list of component nodes if the component selection gets changed
void RadiantSelectionSystem::onComponentSelection(const scene::INodePtr& node, const Selectable& selectable) {
int delta = selectable.isSelected() ? +1 : -1;
_countComponent += delta;
_sigSelectionChanged(selectable);
_selectionInfo.totalCount += delta;
_selectionInfo.componentCount += delta;
// If the instance got selected, add it to the list, otherwise remove it
if (selectable.isSelected()) {
_componentSelection.append(node);
}
else {
_componentSelection.erase(node);
}
// Notify observers, TRUE => this is a component selection change
notifyObservers(node, true);
// Check if the number of selected components in the list matches the value of the selection counter
ASSERT_MESSAGE(_componentSelection.size() == _countComponent, "component selection-tracking error");
// Schedule an idle callback
requestIdleCallback();
_requestWorkZoneRecalculation = true;
_requestSceneGraphChange = true;
}
// This is called if the selection changes, so that the local list of selected instances can be updated
void RadiantSelectionSystem::onSelectedChanged(scene::Instance& instance, const Selectable& selectable) {
// Cache the selection state
bool isSelected = selectable.isSelected();
_countPrimitive += (isSelected) ? +1 : -1;
_selectionChangedCallbacks(selectable); // legacy
_selectionInfo.totalCount += (isSelected) ? +1 : -1;
if (Instance_getBrush(instance) != NULL) {
_selectionInfo.brushCount += (isSelected) ? +1 : -1;
}
else {
_selectionInfo.entityCount += (isSelected) ? +1 : -1;
}
// If the selectable is selected, add it to the local selection list, otherwise remove it
if (isSelected) {
_selection.append(instance);
}
else {
_selection.erase(instance);
}
// Notify observers, FALSE = primitive selection change
notifyObservers(instance, false);
// Check if the number of selected primitives in the list matches the value of the selection counter
ASSERT_MESSAGE(_selection.size() == _countPrimitive, "selection-tracking error");
// Schedule an idle callback
requestIdleCallback();
_requestWorkZoneRecalculation = true;
}
void post( const scene::Path& path, scene::Instance& instance ) const {
Selectable *selectable = Instance_getSelectable( instance );
if ( selectable && selectable->isSelected() ) {
Entity* entity = Node_getEntity( path.top() );
if ( entity == 0 && Node_isPrimitive( path.top() ) ) {
NodeSmartReference child( path.top().get() );
NodeSmartReference parent( path.parent().get() );
if ( path.size() >= 3 && parent != worldspawn ) {
NodeSmartReference parentparent( path[path.size() - 3].get() );
Node_getTraversable( parent )->erase( child );
Node_getTraversable( group )->insert( child );
if ( Node_getTraversable( parent )->empty() ) {
//deleteme.push(DeletionPair(parentparent, parent));
Node_getTraversable( parentparent )->erase( parent );
}
}
else
{
Node_getTraversable( parent )->erase( child );
Node_getTraversable( group )->insert( child );
}
}
}
}
void FaceInstance::selectedChanged (const Selectable& selectable)
{
if (selectable.isSelected()) {
g_SelectedFaceInstances.insert(*this);
} else {
g_SelectedFaceInstances.erase(*this);
}
m_selectionChanged(selectable);
}
// greebo: This should be called "onComponentSelectionChanged", as it is a similar function of the above one
// Updates the internal list of component instances if the component selection gets changed
void RadiantSelectionSystem::onComponentSelection(scene::Instance& instance, const Selectable& selectable) {
_countComponent += (selectable.isSelected()) ? +1 : -1;
_selectionChangedCallbacks(selectable); // legacy
_selectionInfo.totalCount += (selectable.isSelected()) ? +1 : -1;
// If the instance got selected, add it to the list, otherwise remove it
if (selectable.isSelected()) {
_componentSelection.append(instance);
}
else {
_componentSelection.erase(instance);
}
notifyObservers(instance, true);
// Check if the number of selected components in the list matches the value of the selection counter
ASSERT_MESSAGE(_componentSelection.size() == _countComponent, "selection-tracking error");
// Schedule an idle callback
requestIdleCallback();
_requestWorkZoneRecalculation = true;
}
bool PlaneSelectableSelectPlanes::pre(const scene::Path& path, scene::Instance& instance) const {
if(path.top().get().visible())
{
Selectable* selectable = Instance_getSelectable(instance);
if(selectable != 0 && selectable->isSelected())
{
PlaneSelectable* planeSelectable = Instance_getPlaneSelectable(instance);
if(planeSelectable != 0)
{
planeSelectable->selectPlanes(_selector, _test, _selectedPlaneCallback);
}
}
}
return true;
}
// This is called if the selection changes, so that the local list of selected nodes can be updated
void RadiantSelectionSystem::onSelectedChanged(const scene::INodePtr& node, const Selectable& selectable) {
// Cache the selection state
bool isSelected = selectable.isSelected();
int delta = isSelected ? +1 : -1;
_countPrimitive += delta;
_sigSelectionChanged(selectable);
_selectionInfo.totalCount += delta;
if (Node_getPatch(node) != NULL) {
_selectionInfo.patchCount += delta;
}
else if (Node_getBrush(node) != NULL) {
_selectionInfo.brushCount += delta;
}
else {
_selectionInfo.entityCount += delta;
}
// If the selectable is selected, add it to the local selection list, otherwise remove it
if (isSelected) {
_selection.append(node);
}
else {
_selection.erase(node);
}
// Notify observers, FALSE = primitive selection change
notifyObservers(node, false);
// Check if the number of selected primitives in the list matches the value of the selection counter
ASSERT_MESSAGE(_selection.size() == _countPrimitive, "selection-tracking error");
// Schedule an idle callback
requestIdleCallback();
_requestWorkZoneRecalculation = true;
_requestSceneGraphChange = true;
}
void FaceInstance::selectedChanged(const Selectable& selectable)
{
if (selectable.isSelected())
{
Selection().push_back(this);
}
else
{
FaceInstanceSet::reverse_iterator found = std::find(Selection().rbegin(), Selection().rend(), this);
// Emit an error if the instance is not in the list
ASSERT_MESSAGE(found != Selection().rend(), "selection-tracking error");
Selection().erase(--found.base());
}
if (m_selectionChanged)
{
m_selectionChanged(selectable);
}
}
gboolean treemodel_update_selection(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer data)
{
GtkTreeView* view = reinterpret_cast<GtkTreeView*>(data);
scene::Instance* instance;
gtk_tree_model_get_pointer(model, iter, 1, &instance);
Selectable* selectable = Instance_getSelectable(*instance);
if(selectable != 0)
{
GtkTreeSelection* selection = gtk_tree_view_get_selection(view);
if(selectable->isSelected())
{
gtk_tree_selection_select_path(selection, path);
}
else
{
gtk_tree_selection_unselect_path(selection, path);
}
}
return FALSE;
}
/* greebo: This gets called by SelectObserver if the user just clicks into the scene (without dragging)
* It checks for any possible targets (in the "line of click") and takes the actions according
* to the modifiers that are held down (Alt-Shift, etc.)
*/
void RadiantSelectionSystem::SelectPoint(const View& view,
const Vector2& device_point,
const Vector2& device_epsilon,
SelectionSystem::EModifier modifier,
bool face)
{
ASSERT_MESSAGE(fabs(device_point[0]) <= 1.0f && fabs(device_point[1]) <= 1.0f, "point-selection error");
// If the user is holding the replace modifiers (default: Alt-Shift), deselect the current selection
if (modifier == SelectionSystem::eReplace) {
if (face) {
setSelectedAllComponents(false);
}
else {
deselectAll();
}
}
{
View scissored(view);
// Construct a selection test according to a small box with 2*epsilon edge length
ConstructSelectionTest(scissored, Rectangle::ConstructFromPoint(device_point, device_epsilon));
// Create a new SelectionPool instance and fill it with possible candidates
SelectionVolume volume(scissored);
// The possible candidates are stored in the SelectablesSet
SelectablesList candidates;
if (face)
{
SelectionPool selector;
ComponentSelector selectionTester(selector, volume, eFace);
GlobalSceneGraph().foreachVisibleNodeInVolume(scissored, selectionTester);
// Load them all into the vector
for (SelectionPool::iterator i = selector.begin(); i != selector.end(); ++i)
{
candidates.push_back(i->second);
}
}
else {
testSelectScene(candidates, volume, scissored, Mode(), ComponentMode());
}
// Was the selection test successful (have we found anything to select)?
if (candidates.size() > 0) {
// Yes, now determine how we should interpret the click
switch (modifier) {
// If we are in toggle mode (Shift-Left-Click by default), just toggle the
// selection of the "topmost" item
case SelectionSystem::eToggle: {
Selectable* best = *candidates.begin();
// toggle selection of the object with least depth (=first in the list)
best->setSelected(!best->isSelected());
}
break;
// greebo: eReplace mode gets active as soon as the user holds the replace modifiers down
// and clicks (by default: Alt-Shift). eReplace is only active during the first click
// afterwards we are in cycle mode.
// if cycle mode not enabled, enable it
case SelectionSystem::eReplace: {
// select closest (=first in the list)
(*candidates.begin())->setSelected(true);
}
break;
// select the next object in the list from the one already selected
// greebo: eCycle is set if the user keeps holding the replace modifiers (Alt-Shift)
// and does NOT move the mouse between the clicks, otherwise we fall back into eReplace mode
// Note: The mode is set in SelectObserver::testSelect()
case SelectionSystem::eCycle: {
// Cycle through the selection pool and activate the item right after the currently selected
SelectablesList::iterator i = candidates.begin();
while (i != candidates.end()) {
if ((*i)->isSelected()) {
// unselect the currently selected one
(*i)->setSelected(false);
// check if there is a "next" item in the list, if not: select the first item
++i;
if (i != candidates.end()) {
(*i)->setSelected(true);
}
else {
(*candidates.begin())->setSelected(true);
}
break;
}
++i;
} // while
} // case
break;
default:
break;
} // switch
}
}
}
void notify(const Selectable& arguments)
{
bool bleh = arguments.isSelected();
}
