Changeset 92d756 for src


Ignore:
Timestamp:
Dec 16, 2010, 5:32:22 PM (14 years ago)
Author:
Frederik Heber <heber@…>
Branches:
Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable
Children:
125002
Parents:
0bbfa1
git-author:
Frederik Heber <heber@…> (12/07/10 22:05:18)
git-committer:
Frederik Heber <heber@…> (12/16/10 17:32:22)
Message:

Larger update of selections.

Location:
src
Files:
12 added
37 edited

Legend:

Unmodified
Added
Removed

  • src/Actions/Makefile.am

    r0bbfa1 r92d756  
    134134        SelectionAction/MoleculeByFormulaAction.cpp \
    135135        SelectionAction/MoleculeByIdAction.cpp \
     136        SelectionAction/MoleculeByNameAction.cpp \
    136137        SelectionAction/MoleculeByOrderAction.cpp \
    137138        SelectionAction/MoleculeOfAtomAction.cpp \
    … …  
    145146        SelectionAction/NotMoleculeByFormulaAction.cpp \
    146147        SelectionAction/NotMoleculeByIdAction.cpp \
     148        SelectionAction/NotMoleculeByNameAction.cpp \
     149        SelectionAction/NotMoleculeByOrderAction.cpp \
    147150        SelectionAction/NotMoleculeOfAtomAction.cpp
    148151SELECTIONACTIONHEADER = \
    … …  
    158161        SelectionAction/MoleculeByFormulaAction.hpp \
    159162        SelectionAction/MoleculeByIdAction.hpp \
     163        SelectionAction/MoleculeByNameAction.hpp \
    160164        SelectionAction/MoleculeByOrderAction.hpp \
    161165        SelectionAction/MoleculeOfAtomAction.hpp \
    … …  
    169173        SelectionAction/NotMoleculeByFormulaAction.hpp \
    170174        SelectionAction/NotMoleculeByIdAction.hpp \
    171         SelectionAction/NotMoleculeOfAtomAction.cpp
     175        SelectionAction/NotMoleculeByNameAction.hpp \
     176        SelectionAction/NotMoleculeByOrderAction.hpp \
     177        SelectionAction/NotMoleculeOfAtomAction.hpp
    172178
    173179TESSELATIONACTIONSOURCE = \

  • src/Actions/SelectionAction/AllAtomsAction.cpp

    r0bbfa1 r92d756  
    2626#include "World.hpp"
    2727
     28#include <boost/foreach.hpp>
    2829#include <iostream>
    2930#include <string>
    … …  
    5152
    5253  World::getInstance().clearAtomSelection();
    53   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    54     World::getInstance().selectAtom(*iter);
     54
     55  BOOST_FOREACH(atom *_atom, state->selectedAtoms)
     56    World::getInstance().selectAtom(_atom);
    5557
    5658  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/AllAtomsInsideCuboidAction.cpp

    r0bbfa1 r92d756  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Descriptors/AtomDescriptor.hpp"
    2322#include "Descriptors/AtomShapeDescriptor.hpp"
     23#include "Descriptors/AtomSelectionDescriptor.hpp"
    2424#include "atom.hpp"
    2525#include "Helpers/Log.hpp"
    … …  
    3232#include "World.hpp"
    3333
     34#include <boost/foreach.hpp>
    3435#include <iostream>
    3536#include <string>
    … …  
    4445/** =========== define the function ====================== */
    4546Action::state_ptr SelectionAllAtomsInsideCuboidAction::performCall() {
    46   std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    4747  RealSpaceMatrix RotationMatrix;
    4848
    … …  
    5454  DoLog(1) && (Log() << Verbose(1) << "Selecting all atoms inside a rotated " << RotationMatrix << " cuboid at " << params.position << " and extension of " << params.extension << "." << endl);
    5555  Shape s = translate(transform(stretch(Cuboid(),params.extension),RotationMatrix),params.position);
     56  std::vector<atom *> selectedAtoms = World::getInstance().getAllAtoms(AtomsBySelection() && AtomByShape(s));
    5657  World::getInstance().selectAllAtoms(AtomByShape(s));
    57   return Action::state_ptr(new SelectionAllAtomsInsideCuboidState(selectedAtoms, params));
     58  return Action::state_ptr(new SelectionAllAtomsInsideCuboidState(selectedAtoms, s, params));
    5859}
    5960
    … …  
    6162  SelectionAllAtomsInsideCuboidState *state = assert_cast<SelectionAllAtomsInsideCuboidState*>(_state.get());
    6263
    63   World::getInstance().clearAtomSelection();
    64   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    65     World::getInstance().selectAtom(*iter);
     64  World::getInstance().unselectAllAtoms(AtomByShape(state->s));
     65  BOOST_FOREACH(atom *_atom, state->selectedAtoms)
     66    World::getInstance().selectAtom(_atom);
    6667
    6768  return Action::state_ptr(_state);
    … …  
    7273  RealSpaceMatrix RotationMatrix;
    7374
    74   RotationMatrix.setRotation(state->params.Xangle, state->params.Yangle, state->params.Zangle);
    75   Shape s = translate(transform(stretch(Cuboid(),state->params.extension),RotationMatrix),state->params.position);
    76   World::getInstance().selectAllAtoms(AtomByShape(s));
     75  World::getInstance().selectAllAtoms(AtomByShape(state->s));
    7776
    7877  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/AllAtomsInsideCuboidAction.def

    r0bbfa1 r92d756  
    1010
    1111class Vector;
     12class Shape;
    1213
    1314// i.e. there is an integer with variable name Z that can be found in
    … …  
    2021#define paramreferences (extension)(position)(Xangle)(Yangle)(Zangle)
    2122
    22 #define statetypes (std::vector<atom*>)
    23 #define statereferences (selectedAtoms)
     23#define statetypes (std::vector<atom*>)(Shape)
     24#define statereferences (selectedAtoms)(s)
    2425
    2526// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/AllAtomsInsideSphereAction.cpp

    r0bbfa1 r92d756  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Descriptors/AtomDescriptor.hpp"
    2322#include "Descriptors/AtomShapeDescriptor.hpp"
     23#include "Descriptors/AtomSelectionDescriptor.hpp"
    2424#include "atom.hpp"
    2525#include "Helpers/Log.hpp"
    … …  
    3131#include "World.hpp"
    3232
     33#include <boost/foreach.hpp>
    3334#include <iostream>
    3435#include <string>
    … …  
    4344/** =========== define the function ====================== */
    4445Action::state_ptr SelectionAllAtomsInsideSphereAction::performCall() {
    45   std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    46 
    4746  // obtain information
    4847  getParametersfromValueStorage();
    … …  
    5049  DoLog(1) && (Log() << Verbose(1) << "Selecting all atoms inside a sphere at " << params.position << " with radius " << params.radius << "." << endl);
    5150  Shape s = translate(resize(Sphere(),params.radius),params.position);
     51  std::vector<atom *> selectedAtoms = World::getInstance().getAllAtoms(AtomsBySelection() && AtomByShape(s));
    5252  World::getInstance().selectAllAtoms(AtomByShape(s));
    53   return Action::state_ptr(new SelectionAllAtomsInsideSphereState(selectedAtoms, params));
     53  return Action::state_ptr(new SelectionAllAtomsInsideSphereState(selectedAtoms, s, params));
    5454}
    5555
    … …  
    5757  SelectionAllAtomsInsideSphereState *state = assert_cast<SelectionAllAtomsInsideSphereState*>(_state.get());
    5858
    59   World::getInstance().clearAtomSelection();
    60   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    61     World::getInstance().selectAtom(*iter);
     59  World::getInstance().unselectAllAtoms(AtomByShape(state->s));
     60  BOOST_FOREACH(atom *_atom, state->selectedAtoms)
     61    World::getInstance().selectAtom(_atom);
    6262
    6363  return Action::state_ptr(_state);
    … …  
    6767  SelectionAllAtomsInsideSphereState *state = assert_cast<SelectionAllAtomsInsideSphereState*>(_state.get());
    6868
    69   Shape s = translate(resize(Sphere(),state->params.radius),state->params.position);
    70   World::getInstance().selectAllAtoms(AtomByShape(s));
     69  World::getInstance().selectAllAtoms(AtomByShape(state->s));
    7170
    7271  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/AllAtomsInsideSphereAction.def

    r0bbfa1 r92d756  
    88// all includes and forward declarations necessary for non-integral types below
    99class Vector;
     10class Shape;
    1011
    1112// i.e. there is an integer with variable name Z that can be found in
    … …  
    1819#define paramreferences (radius)(position)
    1920
    20 #define statetypes (std::vector<atom*>)
    21 #define statereferences (selectedAtoms)
     21#define statetypes (std::vector<atom*>)(Shape)
     22#define statereferences (selectedAtoms)(s)
    2223
    2324// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/AllAtomsOfMoleculeAction.cpp

    r0bbfa1 r92d756  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Descriptors/AtomDescriptor.hpp"
     22#include "Descriptors/AtomSelectionDescriptor.hpp"
    2323#include "atom.hpp"
    2424#include "molecule.hpp"
    … …  
    2727#include "World.hpp"
    2828
     29#include <boost/foreach.hpp>
    2930#include <iostream>
    3031#include <string>
    … …  
    3940/** =========== define the function ====================== */
    4041Action::state_ptr SelectionAllAtomsOfMoleculeAction::performCall() {
    41   std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    42 
    4342  // obtain information
    4443  getParametersfromValueStorage();
    4544
    4645  DoLog(1) && (Log() << Verbose(1) << "Selecting all atoms of molecule " << params.mol->getName() << "." << endl);
     46  std::vector<atom *> selectedAtoms = World::getInstance().getAllAtoms(AtomsBySelection());
    4747  World::getInstance().selectAtomsOfMolecule(params.mol);
    4848  return Action::state_ptr(new SelectionAllAtomsOfMoleculeState(selectedAtoms, params));
    … …  
    5252  SelectionAllAtomsOfMoleculeState *state = assert_cast<SelectionAllAtomsOfMoleculeState*>(_state.get());
    5353
    54   World::getInstance().clearAtomSelection();
    55   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    56     World::getInstance().selectAtom(*iter);
     54  World::getInstance().unselectAtomsOfMolecule(state->params.mol);
     55  BOOST_FOREACH(atom *_atom, state->selectedAtoms)
     56    World::getInstance().selectAtom(_atom);
    5757
    5858  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/AllMoleculesAction.cpp

    r0bbfa1 r92d756  
    2121
    2222#include "Descriptors/MoleculeDescriptor.hpp"
     23#include "Descriptors/MoleculeSelectionDescriptor.hpp"
    2324#include "atom.hpp"
    2425#include "Helpers/Log.hpp"
    … …  
    2627#include "World.hpp"
    2728
     29#include <boost/foreach.hpp>
    2830#include <iostream>
    2931#include <string>
    … …  
    5153
    5254  World::getInstance().clearMoleculeSelection();
    53   for(std::vector<molecule *>::iterator iter = state->selectedMolecules.begin(); iter != state->selectedMolecules.end(); ++iter)
    54     World::getInstance().selectMolecule(*iter);
     55  BOOST_FOREACH(molecule *_mol, state->selectedMolecules)
     56    World::getInstance().selectMolecule(_mol);
    5557
    5658  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/AtomByElementAction.cpp

    r0bbfa1 r92d756  
    2121
    2222#include "Descriptors/AtomTypeDescriptor.hpp"
     23#include "Descriptors/AtomSelectionDescriptor.hpp"
    2324#include "atom.hpp"
    2425#include "element.hpp"
    … …  
    2728#include "World.hpp"
    2829
     30#include <boost/foreach.hpp>
    2931#include <iostream>
    3032#include <string>
    … …  
    3941/** =========== define the function ====================== */
    4042Action::state_ptr SelectionAtomByElementAction::performCall() {
    41   std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    42 
    4343  // obtain information
    4444  getParametersfromValueStorage();
    4545
    4646  DoLog(1) && (Log() << Verbose(1) << "Selecting atoms of type " << *params.elemental << endl);
     47  std::vector<atom *> selectedAtoms = World::getInstance().getAllAtoms(AtomsBySelection());
    4748  World::getInstance().selectAllAtoms(AtomByType(params.elemental));
    4849  return Action::state_ptr(new SelectionAtomByElementState(selectedAtoms,params));
    … …  
    5253  SelectionAtomByElementState *state = assert_cast<SelectionAtomByElementState*>(_state.get());
    5354
    54   World::getInstance().clearAtomSelection();
    55   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    56     World::getInstance().selectAtom(*iter);
     55  World::getInstance().unselectAllAtoms(AtomByType(state->params.elemental));
     56  BOOST_FOREACH(atom *_atom, state->selectedAtoms)
     57    World::getInstance().selectAtom(_atom);
    5758
    5859  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/AtomByIdAction.cpp

    r0bbfa1 r92d756  
    4040  getParametersfromValueStorage();
    4141
    42   if (!World::getInstance().isSelected(params.Walker)) {
    43     DoLog(1) && (Log() << Verbose(1) << "Selecting atom " << *params.Walker << endl);
    44     World::getInstance().selectAtom(params.Walker);
    45     return Action::state_ptr(new SelectionAtomByIdState(params));
     42  if (params.Walker != NULL) {
     43    if (!World::getInstance().isSelected(params.Walker)) {
     44      DoLog(1) && (Log() << Verbose(1) << "Selecting atom " << *params.Walker << endl);
     45      World::getInstance().selectAtom(params.Walker);
     46      return Action::state_ptr(new SelectionAtomByIdState(params));
     47    } else {
     48      return Action::success;
     49    }
    4650  } else {
    47     return Action::success;
     51    return Action::failure;
    4852  }
    4953}
    … …  
    5256  SelectionAtomByIdState *state = assert_cast<SelectionAtomByIdState*>(_state.get());
    5357
    54   if (state->params.Walker != NULL)
    55     World::getInstance().unselectAtom(state->params.Walker);
     58  World::getInstance().unselectAtom(state->params.Walker);
    5659
    5760  return Action::state_ptr(_state);
    … …  
    6164  SelectionAtomByIdState *state = assert_cast<SelectionAtomByIdState*>(_state.get());
    6265
    63   if (state->params.Walker != NULL)
    64     World::getInstance().selectAtom(state->params.Walker);
     66  World::getInstance().selectAtom(state->params.Walker);
    6567
    6668  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/ClearAllAtomsAction.cpp

    r0bbfa1 r92d756  
    2626#include "World.hpp"
    2727
     28#include <boost/foreach.hpp>
    2829#include <iostream>
    2930#include <string>
    … …  
    5152
    5253  World::getInstance().clearAtomSelection();
    53   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    54     World::getInstance().selectAtom(*iter);
     54  BOOST_FOREACH(atom *_atom, state->selectedAtoms)
     55    World::getInstance().selectAtom(_atom);
    5556
    5657  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/ClearAllMoleculesAction.cpp

    r0bbfa1 r92d756  
    2626#include "World.hpp"
    2727
     28#include <boost/foreach.hpp>
    2829#include <iostream>
    2930#include <string>
    … …  
    5152
    5253  World::getInstance().clearMoleculeSelection();
    53   for(std::vector<molecule *>::iterator iter = state->selectedMolecules.begin(); iter != state->selectedMolecules.end(); ++iter)
    54     World::getInstance().selectMolecule(*iter);
     54  BOOST_FOREACH(molecule *_mol, state->selectedMolecules)
     55    World::getInstance().selectMolecule(_mol);
    5556
    5657  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/MoleculeByFormulaAction.cpp

    r0bbfa1 r92d756  
    2121
    2222#include "Descriptors/MoleculeFormulaDescriptor.hpp"
     23#include "Descriptors/MoleculeSelectionDescriptor.hpp"
    2324#include "molecule.hpp"
    2425#include "Helpers/Log.hpp"
    … …  
    2627#include "World.hpp"
    2728
     29#include <boost/foreach.hpp>
    2830#include <iostream>
    2931#include <string>
    … …  
    3840/** =========== define the function ====================== */
    3941Action::state_ptr SelectionMoleculeByFormulaAction::performCall() {
    40   std::vector<molecule *> selectedMolecules = World::getInstance().getSelectedMolecules();
    41 
    4242  // obtain information
    4343  getParametersfromValueStorage();
    4444
    4545  DoLog(1) && (Log() << Verbose(1) << "Selecting molecules with chemical formula " << params.formula << ":" << endl);
    46   std::vector<molecule *> matchingMolecules = World::getInstance().getAllMolecules(MoleculeByFormula(params.formula));
    47   for (std::vector<molecule *>::const_iterator iter = matchingMolecules.begin(); iter != matchingMolecules.end(); ++iter) {
    48     DoLog(1) && (Log() << Verbose(1) << "\t" << (*iter)->getId() << ", " << (*iter)->getName() << "." << endl);
    49   }
     46//  std::vector<molecule *> matchingMolecules = World::getInstance().getAllMolecules(MoleculeByFormula(params.formula));
     47  std::vector<molecule *> selectedMolecules =
     48      World::getInstance().getAllMolecules(MoleculesBySelection() && MoleculeByFormula(params.formula));
     49//  BOOST_FOREACH(molecule *mol, matchingMolecules)
     50//    DoLog(1) && (Log() << Verbose(1) << "\t" << mol->getId() << ", " << mol->getName() << "." << endl);
    5051  World::getInstance().selectAllMolecules(MoleculeByFormula(params.formula));
    5152  return Action::state_ptr(new SelectionMoleculeByFormulaState(selectedMolecules,params));
    … …  
    5556  SelectionMoleculeByFormulaState *state = assert_cast<SelectionMoleculeByFormulaState*>(_state.get());
    5657
    57   World::getInstance().clearMoleculeSelection();
    58   for(std::vector<molecule *>::iterator iter = state->selectedMolecules.begin(); iter != state->selectedMolecules.end(); ++iter)
    59     World::getInstance().selectMolecule(*iter);
     58  World::getInstance().unselectAllMolecules(MoleculeByFormula(state->params.formula));
     59  BOOST_FOREACH( molecule *mol, state->selectedMolecules)
     60    World::getInstance().selectMolecule(mol);
    6061
    6162  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/MoleculeByIdAction.cpp

    r0bbfa1 r92d756  
    4040  getParametersfromValueStorage();
    4141
    42   if (!World::getInstance().isSelected(params.mol)) {
    43     DoLog(1) && (Log() << Verbose(1) << "Selecting molecule " << params.mol->name << endl);
    44     World::getInstance().selectMolecule(params.mol);
    45     return Action::state_ptr(new SelectionMoleculeByIdState(params));
     42  if (params.mol != NULL) {
     43    if (!World::getInstance().isSelected(params.mol)) {
     44      DoLog(1) && (Log() << Verbose(1) << "Selecting molecule " << params.mol->name << endl);
     45      World::getInstance().selectMolecule(params.mol);
     46      return Action::state_ptr(new SelectionMoleculeByIdState(params));
     47    } else {
     48      return Action::success;
     49    }
    4650  } else {
    47     return Action::success;
     51    return Action::failure;
    4852  }
    4953}
    … …  
    5256  SelectionMoleculeByIdState *state = assert_cast<SelectionMoleculeByIdState*>(_state.get());
    5357
    54   if (state->params.mol != NULL)
    55     World::getInstance().unselectMolecule(state->params.mol);
     58  World::getInstance().unselectMolecule(state->params.mol);
    5659
    5760  return Action::state_ptr(_state);
    … …  
    6164  SelectionMoleculeByIdState *state = assert_cast<SelectionMoleculeByIdState*>(_state.get());
    6265
    63   if (state->params.mol != NULL)
    64     World::getInstance().selectMolecule(state->params.mol);
     66  World::getInstance().selectMolecule(state->params.mol);
    6567
    6668  return Action::state_ptr(state);

  • src/Actions/SelectionAction/MoleculeByOrderAction.cpp

    r0bbfa1 r92d756  
    2323#include "Helpers/Log.hpp"
    2424#include "Helpers/Verbose.hpp"
     25#include "Descriptors/MoleculeOrderDescriptor.hpp"
    2526#include "World.hpp"
    2627
    … …  
    3738/** =========== define the function ====================== */
    3839
    39 molecule * SearchMoleculeByOrder(int molindex)
    40 {
    41   molecule *mol = NULL;
    42   std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
    43   int i=0;
    44   if (molindex > 0) {
    45     std::vector<molecule *>::const_iterator iter = molecules.begin();
    46     for (;iter != molecules.end();++iter) {
    47       ++i;
    48       if (molindex == i)
    49         break;
    50     }
    51     mol = *iter;
    52   } else {
    53     std::vector<molecule *>::const_reverse_iterator iter = molecules.rbegin();
    54     for (;iter != molecules.rend();--iter) {
    55       --i;
    56       if (molindex == i)
    57         break;
    58     }
    59     mol = *iter;
    60   }
    61 
    62   return mol;
    63 }
    64 
    6540Action::state_ptr SelectionMoleculeByOrderAction::performCall() {
    6641  // obtain information
    6742  getParametersfromValueStorage();
    6843
    69   molecule *mol = SearchMoleculeByOrder(params.molindex);
     44  molecule *mol = World::getInstance().getMolecule(MoleculeByOrder(params.molindex));
    7045
    7146  if (mol != NULL) {
    … …  
    7348      DoLog(1) && (Log() << Verbose(1) << "Selecting molecule " << mol->name << endl);
    7449      World::getInstance().selectMolecule(mol);
    75       return Action::state_ptr(new SelectionMoleculeByOrderState(params));
     50      return Action::state_ptr(new SelectionMoleculeByOrderState(mol, params));
    7651    } else {
    7752      return Action::success;
    … …  
    8560  SelectionMoleculeByOrderState *state = assert_cast<SelectionMoleculeByOrderState*>(_state.get());
    8661
    87   molecule *mol = SearchMoleculeByOrder(state->params.molindex);
    88 
    89   if (mol != NULL) {
    90     World::getInstance().unselectMolecule(mol);
    91     return Action::state_ptr(_state);
    92   } else {
    93     return Action::failure;
    94   }
     62  World::getInstance().unselectMolecule(state->mol);
     63  return Action::state_ptr(_state);
    9564}
    9665
    … …  
    9867  SelectionMoleculeByOrderState *state = assert_cast<SelectionMoleculeByOrderState*>(_state.get());
    9968
    100   molecule *mol = SearchMoleculeByOrder(state->params.molindex);
    101 
    102   if (mol != NULL) {
    103     World::getInstance().selectMolecule(mol);
    104     return Action::state_ptr(state);
    105   } else {
    106     return Action::failure;
    107   }
     69  World::getInstance().selectMolecule(state->mol);
     70  return Action::state_ptr(_state);
    10871}
    10972

  • src/Actions/SelectionAction/MoleculeByOrderAction.def

    r0bbfa1 r92d756  
    1818#define paramreferences (molindex)
    1919
    20 #undef statetypes
    21 #undef statereferences
     20#define statetypes (const molecule *)
     21#define statereferences (mol)
    2222
    2323// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/MoleculeOfAtomAction.cpp

    r0bbfa1 r92d756  
    2626#include "World.hpp"
    2727
     28#include <boost/foreach.hpp>
    2829#include <iostream>
    2930#include <string>
    … …  
    5152
    5253  World::getInstance().clearMoleculeSelection();
    53   for(std::vector<molecule *>::iterator iter = state->selectedMolecules.begin(); iter != state->selectedMolecules.end(); ++iter)
    54     World::getInstance().selectMolecule(*iter);
     54  BOOST_FOREACH(molecule *_mol, state->selectedMolecules)
     55    World::getInstance().selectMolecule(_mol);
    5556
    5657  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotAllAtomsAction.cpp

    r0bbfa1 r92d756  
    2626#include "World.hpp"
    2727
     28#include <boost/foreach.hpp>
    2829#include <iostream>
    2930#include <string>
    … …  
    5152
    5253  World::getInstance().clearAtomSelection();
    53   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    54     World::getInstance().selectAtom(*iter);
     54  BOOST_FOREACH(atom *_atom, state->unselectedAtoms)
     55    World::getInstance().selectAtom(_atom);
    5556
    5657  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotAllAtomsAction.def

    r0bbfa1 r92d756  
    1919
    2020#define statetypes (std::vector<atom*>)
    21 #define statereferences (selectedAtoms)
     21#define statereferences (unselectedAtoms)
    2222
    2323// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/NotAllAtomsInsideCuboidAction.cpp

    r0bbfa1 r92d756  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Descriptors/AtomDescriptor.hpp"
     22#include "Descriptors/AtomSelectionDescriptor.hpp"
    2323#include "Descriptors/AtomShapeDescriptor.hpp"
    2424#include "atom.hpp"
    … …  
    3232#include "World.hpp"
    3333
     34#include <boost/foreach.hpp>
    3435#include <iostream>
    3536#include <string>
    … …  
    4445/** =========== define the function ====================== */
    4546Action::state_ptr SelectionNotAllAtomsInsideCuboidAction::performCall() {
    46   std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    4747  RealSpaceMatrix RotationMatrix;
    4848
    … …  
    5353  DoLog(1) && (Log() << Verbose(1) << "Unselecting all atoms inside a rotated " << RotationMatrix << " cuboid at " << params.position << " and extension of " << params.extension << "." << endl);
    5454  Shape s = translate(transform(stretch(Cuboid(),params.extension),RotationMatrix),params.position);
    55 
     55  std::vector<atom *> unselectedAtoms = World::getInstance().getAllAtoms((!AtomsBySelection()) && AtomByShape(s));
    5656  World::getInstance().unselectAllAtoms(AtomByShape(s));
    57   return Action::state_ptr(new SelectionNotAllAtomsInsideCuboidState(selectedAtoms, params));
     57  return Action::state_ptr(new SelectionNotAllAtomsInsideCuboidState(unselectedAtoms, s, params));
    5858}
    5959
    … …  
    6161  SelectionNotAllAtomsInsideCuboidState *state = assert_cast<SelectionNotAllAtomsInsideCuboidState*>(_state.get());
    6262
    63   World::getInstance().clearAtomSelection();
    64   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    65     World::getInstance().selectAtom(*iter);
     63  World::getInstance().selectAllAtoms(AtomByShape(state->s));
     64  BOOST_FOREACH(atom *_atom, state->unselectedAtoms)
     65    World::getInstance().unselectAtom(_atom);
    6666
    6767  return Action::state_ptr(_state);
    … …  
    7272  RealSpaceMatrix RotationMatrix;
    7373
    74   RotationMatrix.setRotation(state->params.Xangle, state->params.Yangle, state->params.Zangle);
    75   Shape s = translate(transform(stretch(Cuboid(),state->params.extension),RotationMatrix),state->params.position);
    76   World::getInstance().unselectAllAtoms(AtomByShape(s));
     74  World::getInstance().unselectAllAtoms(AtomByShape(state->s));
    7775
    7876  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotAllAtomsInsideCuboidAction.def

    r0bbfa1 r92d756  
    99#include "Actions/Values.hpp"
    1010
     11class Shape;
    1112class Vector;
    1213
    … …  
    2021#define paramreferences (extension)(position)(Xangle)(Yangle)(Zangle)
    2122
    22 #define statetypes (std::vector<atom*>)
    23 #define statereferences (selectedAtoms)
     23#define statetypes (std::vector<atom*>)(Shape)
     24#define statereferences (unselectedAtoms)(s)
    2425
    2526// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/NotAllAtomsInsideSphereAction.cpp

    r0bbfa1 r92d756  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Descriptors/AtomDescriptor.hpp"
     22#include "Descriptors/AtomSelectionDescriptor.hpp"
    2323#include "Descriptors/AtomShapeDescriptor.hpp"
    2424#include "atom.hpp"
    … …  
    3131#include "World.hpp"
    3232
     33#include <boost/foreach.hpp>
    3334#include <iostream>
    3435#include <string>
    … …  
    4344/** =========== define the function ====================== */
    4445Action::state_ptr SelectionNotAllAtomsInsideSphereAction::performCall() {
    45   std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    46 
    4746  // obtain information
    4847  getParametersfromValueStorage();
    … …  
    5049  DoLog(1) && (Log() << Verbose(1) << "Unselecting all atoms inside a sphere at " << params.position << " with radius " << params.radius << "." << endl);
    5150  Shape s = translate(resize(Sphere(),params.radius),params.position);
     51  std::vector<atom *> unselectedAtoms = World::getInstance().getAllAtoms((!AtomsBySelection()) && AtomByShape(s));
    5252  World::getInstance().unselectAllAtoms(AtomByShape(s));
    53   return Action::state_ptr(new SelectionNotAllAtomsInsideSphereState(selectedAtoms, params));
     53  return Action::state_ptr(new SelectionNotAllAtomsInsideSphereState(unselectedAtoms, s, params));
    5454}
    5555
    … …  
    5757  SelectionNotAllAtomsInsideSphereState *state = assert_cast<SelectionNotAllAtomsInsideSphereState*>(_state.get());
    5858
    59   World::getInstance().clearAtomSelection();
    60   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    61     World::getInstance().selectAtom(*iter);
     59  World::getInstance().selectAllAtoms(AtomByShape(state->s));
     60  BOOST_FOREACH(atom *_atom, state->unselectedAtoms)
     61    World::getInstance().unselectAtom(_atom);
    6262
    6363  return Action::state_ptr(_state);
    … …  
    6767  SelectionNotAllAtomsInsideSphereState *state = assert_cast<SelectionNotAllAtomsInsideSphereState*>(_state.get());
    6868
    69   Shape s = translate(resize(Sphere(),state->params.radius),state->params.position);
    70   World::getInstance().unselectAllAtoms(AtomByShape(s));
     69  World::getInstance().unselectAllAtoms(AtomByShape(state->s));
    7170
    7271  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotAllAtomsInsideSphereAction.def

    r0bbfa1 r92d756  
    77
    88// all includes and forward declarations necessary for non-integral types below
     9class Shape;
    910class Vector;
    1011
    … …  
    1819#define paramreferences (radius)(position)
    1920
    20 #define statetypes (std::vector<atom*>)
    21 #define statereferences (selectedAtoms)
     21#define statetypes (std::vector<atom*>)(Shape)
     22#define statereferences (unselectedAtoms)(s)
    2223
    2324// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/NotAllAtomsOfMoleculeAction.cpp

    r0bbfa1 r92d756  
    2020#include "Helpers/MemDebug.hpp"
    2121
    22 #include "Descriptors/AtomDescriptor.hpp"
     22#include "Descriptors/AtomSelectionDescriptor.hpp"
    2323#include "atom.hpp"
    2424#include "molecule.hpp"
    … …  
    2727#include "World.hpp"
    2828
     29#include <boost/foreach.hpp>
    2930#include <iostream>
    3031#include <string>
    … …  
    3940/** =========== define the function ====================== */
    4041Action::state_ptr SelectionNotAllAtomsOfMoleculeAction::performCall() {
    41   std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    42 
    4342  // obtain information
    4443  getParametersfromValueStorage();
    4544
    4645  DoLog(1) && (Log() << Verbose(1) << "Unselecting all atoms of molecule " << params.mol->getName() << "." << endl);
     46  std::vector<atom *> unselectedAtoms = World::getInstance().getAllAtoms(!AtomsBySelection());
    4747  World::getInstance().unselectAtomsOfMolecule(params.mol);
    48   return Action::state_ptr(new SelectionNotAllAtomsOfMoleculeState(selectedAtoms, params));
     48  return Action::state_ptr(new SelectionNotAllAtomsOfMoleculeState(unselectedAtoms, params));
    4949}
    5050
    … …  
    5252  SelectionNotAllAtomsOfMoleculeState *state = assert_cast<SelectionNotAllAtomsOfMoleculeState*>(_state.get());
    5353
    54   World::getInstance().clearAtomSelection();
    55   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    56     World::getInstance().selectAtom(*iter);
     54  World::getInstance().selectAtomsOfMolecule(state->params.mol);
     55  BOOST_FOREACH(atom *_atom, state->unselectedAtoms)
     56    World::getInstance().unselectAtom(_atom);
    5757
    5858  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotAllAtomsOfMoleculeAction.def

    r0bbfa1 r92d756  
    1919
    2020#define statetypes (std::vector<atom*>)
    21 #define statereferences (selectedAtoms)
     21#define statereferences (unselectedAtoms)
    2222
    2323// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/NotAllMoleculesAction.cpp

    r0bbfa1 r92d756  
    2626#include "World.hpp"
    2727
     28#include <boost/foreach.hpp>
    2829#include <iostream>
    2930#include <string>
    … …  
    5152
    5253  World::getInstance().clearMoleculeSelection();
    53   for(std::vector<molecule *>::iterator iter = state->selectedMolecules.begin(); iter != state->selectedMolecules.end(); ++iter)
    54     World::getInstance().selectMolecule(*iter);
     54  BOOST_FOREACH(molecule *_mol, state->unselectedMolecules)
     55    World::getInstance().selectMolecule(_mol);
    5556
    5657  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotAllMoleculesAction.def

    r0bbfa1 r92d756  
    1818
    1919#define statetypes (std::vector<molecule*>)
    20 #define statereferences (selectedMolecules)
     20#define statereferences (unselectedMolecules)
    2121
    2222// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/NotAtomByElementAction.cpp

    r0bbfa1 r92d756  
    2020#include "Helpers/MemDebug.hpp"
    2121
     22#include "Descriptors/AtomSelectionDescriptor.hpp"
    2223#include "Descriptors/AtomTypeDescriptor.hpp"
    2324#include "atom.hpp"
    … …  
    2728#include "World.hpp"
    2829
     30#include <boost/foreach.hpp>
    2931#include <iostream>
    3032#include <string>
    … …  
    3941/** =========== define the function ====================== */
    4042Action::state_ptr SelectionNotAtomByElementAction::performCall() {
    41   std::vector<atom *> selectedAtoms = World::getInstance().getSelectedAtoms();
    42 
    4343  // obtain information
    4444  getParametersfromValueStorage();
    4545
    4646  DoLog(1) && (Log() << Verbose(1) << "Unselecting atoms of type " << *params.elemental << endl);
     47  std::vector<atom *> unselectedAtoms = World::getInstance().getAllAtoms(!AtomsBySelection());
    4748  World::getInstance().unselectAllAtoms(AtomByType(params.elemental));
    48   return Action::state_ptr(new SelectionNotAtomByElementState(selectedAtoms,params));
     49  return Action::state_ptr(new SelectionNotAtomByElementState(unselectedAtoms,params));
    4950}
    5051
    … …  
    5253  SelectionNotAtomByElementState *state = assert_cast<SelectionNotAtomByElementState*>(_state.get());
    5354
    54   World::getInstance().clearAtomSelection();
    55   for(std::vector<atom *>::iterator iter = state->selectedAtoms.begin(); iter != state->selectedAtoms.end(); ++iter)
    56     World::getInstance().selectAtom(*iter);
     55  World::getInstance().selectAllAtoms(AtomByType(state->params.elemental));
     56  BOOST_FOREACH(atom *_atom, state->unselectedAtoms)
     57    World::getInstance().unselectAtom(_atom);
    5758
    5859  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotAtomByElementAction.def

    r0bbfa1 r92d756  
    1919
    2020#define statetypes (std::vector<atom*>)
    21 #define statereferences (selectedAtoms)
     21#define statereferences (unselectedAtoms)
    2222
    2323// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/NotAtomByIdAction.cpp

    r0bbfa1 r92d756  
    4040  getParametersfromValueStorage();
    4141
    42   if (World::getInstance().isSelected(params.Walker)) {
    43     DoLog(1) && (Log() << Verbose(1) << "Unselecting atom " << *params.Walker << endl);
    44     World::getInstance().unselectAtom(params.Walker);
    45     return Action::state_ptr(new SelectionNotAtomByIdState(params));
     42  if (params.Walker != NULL) {
     43    if (World::getInstance().isSelected(params.Walker)) {
     44      DoLog(1) && (Log() << Verbose(1) << "Unselecting atom " << *params.Walker << endl);
     45      World::getInstance().unselectAtom(params.Walker);
     46      return Action::state_ptr(new SelectionNotAtomByIdState(params));
     47    } else {
     48      return Action::success;
     49    }
    4650  } else {
    47     return Action::success;
     51    return Action::failure;
    4852  }
    4953}
    … …  
    5256  SelectionNotAtomByIdState *state = assert_cast<SelectionNotAtomByIdState*>(_state.get());
    5357
    54   if (state->params.Walker != NULL)
    55     World::getInstance().selectAtom(state->params.Walker);
     58  World::getInstance().selectAtom(state->params.Walker);
    5659
    5760  return Action::state_ptr(_state);
    … …  
    6164  SelectionNotAtomByIdState *state = assert_cast<SelectionNotAtomByIdState*>(_state.get());
    6265
    63   if (state->params.Walker != NULL)
    64     World::getInstance().unselectAtom(state->params.Walker);
     66  World::getInstance().unselectAtom(state->params.Walker);
    6567
    6668  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotMoleculeByFormulaAction.cpp

    r0bbfa1 r92d756  
    2626#include "World.hpp"
    2727
     28#include <boost/foreach.hpp>
    2829#include <iostream>
    2930#include <string>
    … …  
    3839/** =========== define the function ====================== */
    3940Action::state_ptr SelectionNotMoleculeByFormulaAction::performCall() {
    40   std::vector<molecule *> selectedMolecules = World::getInstance().getSelectedMolecules();
    41 
    4241  // obtain information
    4342  getParametersfromValueStorage();
    … …  
    4544  DoLog(1) && (Log() << Verbose(1) << "Unselecting molecules with chemical formula " << params.formula << ":" << endl);
    4645  std::vector<molecule *> matchingMolecules = World::getInstance().getAllMolecules(MoleculeByFormula(params.formula));
     46  std::vector<molecule *> unselectedMolecules;
    4747  for (std::vector<molecule *>::const_iterator iter = matchingMolecules.begin(); iter != matchingMolecules.end(); ++iter) {
     48    if (World::getInstance().isSelected(*iter))
     49      unselectedMolecules.push_back(*iter);
    4850    DoLog(1) && (Log() << Verbose(1) << "\t" << (*iter)->getId() << ", " << (*iter)->getName() << "." << endl);
    4951  }
    5052  World::getInstance().unselectAllMolecules(MoleculeByFormula(params.formula));
    51   return Action::state_ptr(new SelectionNotMoleculeByFormulaState(selectedMolecules,params));
     53  return Action::state_ptr(new SelectionNotMoleculeByFormulaState(unselectedMolecules,params));
    5254}
    5355
    … …  
    5557  SelectionNotMoleculeByFormulaState *state = assert_cast<SelectionNotMoleculeByFormulaState*>(_state.get());
    5658
    57   World::getInstance().clearMoleculeSelection();
    58   for(std::vector<molecule *>::iterator iter = state->selectedMolecules.begin(); iter != state->selectedMolecules.end(); ++iter)
    59     World::getInstance().selectMolecule(*iter);
     59  World::getInstance().selectAllMolecules(MoleculeByFormula(state->params.formula));
     60  BOOST_FOREACH( molecule *mol, state->unselectedMolecules)
     61    World::getInstance().unselectMolecule(mol);
    6062
    6163  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotMoleculeByFormulaAction.def

    r0bbfa1 r92d756  
    1919
    2020#define statetypes (std::vector<molecule*>)
    21 #define statereferences (selectedMolecules)
     21#define statereferences (unselectedMolecules)
    2222
    2323// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Actions/SelectionAction/NotMoleculeByIdAction.cpp

    r0bbfa1 r92d756  
    4040  getParametersfromValueStorage();
    4141
    42   if (World::getInstance().isSelected(params.mol)) {
    43     DoLog(1) && (Log() << Verbose(1) << "Unselecting molecule " << params.mol->name << endl);
    44     World::getInstance().unselectMolecule(params.mol);
    45     return Action::state_ptr(new SelectionNotMoleculeByIdState(params));
     42  if (params.mol != NULL) {
     43    if (World::getInstance().isSelected(params.mol)) {
     44      DoLog(1) && (Log() << Verbose(1) << "Unselecting molecule " << params.mol->name << endl);
     45      World::getInstance().unselectMolecule(params.mol);
     46      return Action::state_ptr(new SelectionNotMoleculeByIdState(params));
     47    } else {
     48      return Action::success;
     49    }
    4650  } else {
    47     return Action::success;
     51    return Action::failure;
    4852  }
    4953}
    … …  
    5256  SelectionNotMoleculeByIdState *state = assert_cast<SelectionNotMoleculeByIdState*>(_state.get());
    5357
    54   if (state->params.mol != NULL)
    55     World::getInstance().selectMolecule(state->params.mol);
     58  World::getInstance().selectMolecule(state->params.mol);
    5659
    5760  return Action::state_ptr(_state);
    … …  
    6164  SelectionNotMoleculeByIdState *state = assert_cast<SelectionNotMoleculeByIdState*>(_state.get());
    6265
    63   if (state->params.mol != NULL)
    64     World::getInstance().unselectMolecule(state->params.mol);
     66  World::getInstance().unselectMolecule(state->params.mol);
    6567
    6668  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotMoleculeOfAtomAction.cpp

    r0bbfa1 r92d756  
    2626#include "World.hpp"
    2727
     28#include <boost/foreach.hpp>
    2829#include <iostream>
    2930#include <string>
    … …  
    4142  getParametersfromValueStorage();
    4243
    43   std::vector<molecule *> selectedMolecules = World::getInstance().getSelectedMolecules();
     44  std::vector<molecule *> unselectedMolecules = World::getInstance().getSelectedMolecules();
    4445  DoLog(1) && (Log() << Verbose(1) << "Unselecting molecule to which " << params.Walker->getName() << " belongs." << endl);
    4546  World::getInstance().unselectMoleculeOfAtom(params.Walker);
    46   return Action::state_ptr(new SelectionNotMoleculeOfAtomState(selectedMolecules, params));
     47  return Action::state_ptr(new SelectionNotMoleculeOfAtomState(unselectedMolecules, params));
    4748}
    4849
    … …  
    5152
    5253  World::getInstance().clearMoleculeSelection();
    53   for(std::vector<molecule *>::iterator iter = state->selectedMolecules.begin(); iter != state->selectedMolecules.end(); ++iter)
    54     World::getInstance().selectMolecule(*iter);
     54  BOOST_FOREACH(molecule *_mol, state->unselectedMolecules)
     55    World::getInstance().selectMolecule(_mol);
    5556
    5657  return Action::state_ptr(_state);

  • src/Actions/SelectionAction/NotMoleculeOfAtomAction.def

    r0bbfa1 r92d756  
    1818
    1919#define statetypes (std::vector<molecule*>)
    20 #define statereferences (selectedMolecules)
     20#define statereferences (unselectedMolecules)
    2121
    2222// some defines for all the names, you may use ACTION, STATE and PARAMS

  • src/Descriptors/MoleculeNameDescriptor.cpp

    r0bbfa1 r92d756  
    5353
    5454vector<molecule*> MoleculeNameDescriptor_impl::findAll(){
    55   molecule *res = find();
    56   return (res)?(vector<molecule*>(1,res)):(vector<molecule*>());
     55  vector<molecule *> foundMolecules;
     56  World::MoleculeSet &molecules = getMolecules();
     57  World::MoleculeSet::iterator res = molecules.begin();
     58  for (; res != molecules.end(); res++)
     59    if (res->second->name == name)
     60      foundMolecules.push_back(res->second);
     61  return foundMolecules;
    5762}

  • src/Makefile.am

    r0bbfa1 r92d756  
    9393  Descriptors/MoleculeIdDescriptor.cpp \
    9494  Descriptors/MoleculeNameDescriptor.cpp \
     95  Descriptors/MoleculeOrderDescriptor.cpp \
    9596  Descriptors/MoleculePtrDescriptor.cpp \
    9697  Descriptors/MoleculeSelectionDescriptor.cpp
    … …  
    106107  Descriptors/MoleculeIdDescriptor.hpp \
    107108  Descriptors/MoleculeNameDescriptor.hpp \
     109  Descriptors/MoleculeOrderDescriptor.hpp \
    108110  Descriptors/MoleculePtrDescriptor.hpp \
    109111  Descriptors/MoleculeSelectionDescriptor.cpp
Note: See TracChangeset for help on using the changeset viewer.