radiant/filters.cpp

   1 /*
   2 Copyright (C) 2001-2006, William Joseph.
   3 All Rights Reserved.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 #include "filters.h"
  23
  24 #include "debugging/debugging.h"
  25
  26 #include "ifilter.h"
  27
  28 #include "scenelib.h"
  29
  30 #include <list>
  31 #include <set>
  32
  33 #include "gtkutil/widget.h"
  34 #include "gtkutil/menu.h"
  35 #include "gtkmisc.h"
  36 #include "mainframe.h"
  37 #include "commands.h"
  38 #include "preferences.h"
  39
  40 struct filters_globals_t
  41 {
  42   std::size_t exclude;
  43
  44   filters_globals_t() :
  45     exclude(0)
  46   {
  47   }
  48 };
  49
  50 filters_globals_t g_filters_globals;
  51
  52 inline bool filter_active(int mask)
  53 {
  54   return (g_filters_globals.exclude & mask) > 0;
  55 }
  56
  57 class FilterWrapper
  58 {
  59 public:
  60   FilterWrapper(Filter& filter, int mask) : m_filter(filter), m_mask(mask)
  61   {
  62   }
  63   void update()
  64   {
  65     m_filter.setActive(filter_active(m_mask));
  66   }
  67 private:
  68   Filter& m_filter;
  69   int m_mask;
  70 };
  71
  72 typedef std::list<FilterWrapper> Filters;
  73 Filters g_filters;
  74
  75 typedef std::set<Filterable*> Filterables;
  76 Filterables g_filterables;
  77
  78 void UpdateFilters()
  79 {
  80   {
  81     for(Filters::iterator i = g_filters.begin(); i != g_filters.end(); ++i)
  82     {
  83       (*i).update();
  84     }
  85   }
  86
  87   {
  88     for(Filterables::iterator i = g_filterables.begin(); i != g_filterables.end(); ++i)
  89     {
  90       (*i)->updateFiltered();
  91     }
  92   }
  93 }
  94
  95
  96 class BasicFilterSystem : public FilterSystem
  97 {
  98 public:
  99   void addFilter(Filter& filter, int mask)
 100   {
 101     g_filters.push_back(FilterWrapper(filter, mask));
 102     g_filters.back().update();
 103   }
 104   void registerFilterable(Filterable& filterable)
 105   {
 106     ASSERT_MESSAGE(g_filterables.find(&filterable) == g_filterables.end(), "filterable already registered");
 107     filterable.updateFiltered();
 108     g_filterables.insert(&filterable);
 109   }
 110   void unregisterFilterable(Filterable& filterable)
 111   {
 112     ASSERT_MESSAGE(g_filterables.find(&filterable) != g_filterables.end(), "filterable not registered");
 113     g_filterables.erase(&filterable);
 114   }
 115 };
 116
 117 BasicFilterSystem g_FilterSystem;
 118
 119 FilterSystem& GetFilterSystem()
 120 {
 121   return g_FilterSystem;
 122 }
 123
 124 void PerformFiltering()
 125 {
 126   UpdateFilters();
 127   SceneChangeNotify();
 128 }
 129
 130 class ToggleFilterFlag
 131 {
 132   const unsigned int m_mask;
 133 public:
 134   ToggleItem m_item;
 135
 136   ToggleFilterFlag(unsigned int mask) : m_mask(mask), m_item(ActiveCaller(*this))
 137   {
 138   }
 139   ToggleFilterFlag(const ToggleFilterFlag& other) : m_mask(other.m_mask), m_item(ActiveCaller(*this))
 140   {
 141   }
 142   void active(const BoolImportCallback& importCallback)
 143   {
 144     importCallback((g_filters_globals.exclude & m_mask) != 0);
 145   }
 146   typedef MemberCaller1<ToggleFilterFlag, const BoolImportCallback&, &ToggleFilterFlag::active> ActiveCaller;
 147   void toggle()
 148   {
 149     g_filters_globals.exclude ^= m_mask;
 150     m_item.update();
 151     PerformFiltering();
 152   }
 153   void reset()
 154   {
 155     g_filters_globals.exclude = 0;
 156     m_item.update();
 157     PerformFiltering();
 158   }
 159   typedef MemberCaller<ToggleFilterFlag, &ToggleFilterFlag::toggle> ToggleCaller;
 160 };
 161
 162
 163 typedef std::list<ToggleFilterFlag> ToggleFilterFlags;
 164 ToggleFilterFlags g_filter_items;
 165
 166 void add_filter_command(unsigned int flag, const char* command, const Accelerator& accelerator)
 167 {
 168   g_filter_items.push_back(ToggleFilterFlag(flag));
 169   GlobalToggles_insert(command, ToggleFilterFlag::ToggleCaller(g_filter_items.back()), ToggleItem::AddCallbackCaller(g_filter_items.back().m_item), accelerator);
 170 }
 171
 172 void InvertFilters()
 173 {
 174   std::list<ToggleFilterFlag>::iterator iter;
 175
 176   for(iter = g_filter_items.begin(); iter != g_filter_items.end(); ++iter)
 177   {
 178       iter->toggle();
 179   }
 180 }
 181
 182 void ResetFilters()
 183 {
 184   std::list<ToggleFilterFlag>::iterator iter;
 185
 186   for(iter = g_filter_items.begin(); iter != g_filter_items.end(); ++iter)
 187   {
 188       iter->reset();
 189   }
 190 }
 191
 192 void Filters_constructMenu(GtkMenu* menu_in_menu)
 193 {
 194   create_check_menu_item_with_mnemonic(menu_in_menu, "World", "FilterWorldBrushes");
 195   create_check_menu_item_with_mnemonic(menu_in_menu, "Entities", "FilterEntities");
 196   if(g_pGameDescription->mGameType == "doom3")
 197   {
 198     create_check_menu_item_with_mnemonic(menu_in_menu, "Visportals", "FilterVisportals");
 199   }
 200   else
 201   {
 202     create_check_menu_item_with_mnemonic(menu_in_menu, "Areaportals", "FilterAreaportals");
 203   }
 204   create_check_menu_item_with_mnemonic(menu_in_menu, "Translucent", "FilterTranslucent");
 205   if(g_pGameDescription->mGameType != "doom3")
 206   {
 207     create_check_menu_item_with_mnemonic(menu_in_menu, "Liquids", "FilterLiquids");
 208   }
 209   create_check_menu_item_with_mnemonic(menu_in_menu, "Caulk", "FilterCaulk");
 210   create_check_menu_item_with_mnemonic(menu_in_menu, "Clips", "FilterClips");
 211   create_check_menu_item_with_mnemonic(menu_in_menu, "Paths", "FilterPaths");
 212   if(g_pGameDescription->mGameType != "doom3")
 213   {
 214     create_check_menu_item_with_mnemonic(menu_in_menu, "Clusterportals", "FilterClusterportals");
 215   }
 216   create_check_menu_item_with_mnemonic(menu_in_menu, "Lights", "FilterLights");
 217   create_check_menu_item_with_mnemonic(menu_in_menu, "Structural", "FilterStructural");
 218   if(g_pGameDescription->mGameType != "doom3")
 219   {
 220     create_check_menu_item_with_mnemonic(menu_in_menu, "Lightgrid", "FilterLightgrid");
 221   }
 222   create_check_menu_item_with_mnemonic(menu_in_menu, "Patches", "FilterPatches");
 223   create_check_menu_item_with_mnemonic(menu_in_menu, "Details", "FilterDetails");
 224   create_check_menu_item_with_mnemonic(menu_in_menu, "Hints", "FilterHintsSkips");
 225   create_check_menu_item_with_mnemonic(menu_in_menu, "Models", "FilterModels");
 226   create_check_menu_item_with_mnemonic(menu_in_menu, "Triggers", "FilterTriggers");
 227   if(g_pGameDescription->mGameType != "doom3")
 228   {
 229     create_check_menu_item_with_mnemonic(menu_in_menu, "Botclips", "FilterBotClips");
 230   }
 231   // filter manipulation
 232   menu_separator(menu_in_menu);
 233   create_menu_item_with_mnemonic(menu_in_menu, "Invert filters", "InvertFilters");
 234   create_menu_item_with_mnemonic(menu_in_menu, "Reset filters", "ResetFilters");
 235 }
 236
 237
 238 #include "preferencesystem.h"
 239 #include "stringio.h"
 240
 241 void ConstructFilters()
 242 {
 243   GlobalPreferenceSystem().registerPreference("SI_Exclude", SizeImportStringCaller(g_filters_globals.exclude), SizeExportStringCaller(g_filters_globals.exclude));
 244
 245   GlobalCommands_insert("InvertFilters", FreeCaller<InvertFilters>());
 246   GlobalCommands_insert("ResetFilters", FreeCaller<ResetFilters>());
 247
 248   add_filter_command(EXCLUDE_WORLD, "FilterWorldBrushes", Accelerator('1', (GdkModifierType)GDK_MOD1_MASK));
 249   add_filter_command(EXCLUDE_ENT, "FilterEntities", Accelerator('2', (GdkModifierType)GDK_MOD1_MASK));
 250   if(g_pGameDescription->mGameType == "doom3")
 251   {
 252     add_filter_command(EXCLUDE_VISPORTALS, "FilterVisportals", Accelerator('3', (GdkModifierType)GDK_MOD1_MASK));
 253   }
 254   else
 255   {
 256     add_filter_command(EXCLUDE_AREAPORTALS, "FilterAreaportals", Accelerator('3', (GdkModifierType)GDK_MOD1_MASK));
 257   }
 258   add_filter_command(EXCLUDE_TRANSLUCENT, "FilterTranslucent", Accelerator('4', (GdkModifierType)GDK_MOD1_MASK));
 259   add_filter_command(EXCLUDE_LIQUIDS, "FilterLiquids", Accelerator('5', (GdkModifierType)GDK_MOD1_MASK));
 260   add_filter_command(EXCLUDE_CAULK, "FilterCaulk", Accelerator('6', (GdkModifierType)GDK_MOD1_MASK ));
 261   add_filter_command(EXCLUDE_CLIP, "FilterClips", Accelerator('7', (GdkModifierType)GDK_MOD1_MASK));
 262   add_filter_command(EXCLUDE_PATHS, "FilterPaths", Accelerator('8', (GdkModifierType)GDK_MOD1_MASK));
 263   if(g_pGameDescription->mGameType != "doom3")
 264   {
 265     add_filter_command(EXCLUDE_CLUSTERPORTALS, "FilterClusterportals", Accelerator('9', (GdkModifierType)GDK_MOD1_MASK));
 266   }
 267   add_filter_command(EXCLUDE_LIGHTS, "FilterLights", Accelerator('0', (GdkModifierType)GDK_MOD1_MASK));
 268   add_filter_command(EXCLUDE_STRUCTURAL, "FilterStructural", Accelerator('D', (GdkModifierType)(GDK_SHIFT_MASK|GDK_CONTROL_MASK)));
 269   if(g_pGameDescription->mGameType != "doom3")
 270   {
 271     add_filter_command(EXCLUDE_LIGHTGRID, "FilterLightgrid", accelerator_null());
 272   }
 273   add_filter_command(EXCLUDE_CURVES, "FilterPatches", Accelerator('P', (GdkModifierType)GDK_CONTROL_MASK));
 274   add_filter_command(EXCLUDE_DETAILS, "FilterDetails", Accelerator('D', (GdkModifierType)GDK_CONTROL_MASK));
 275   add_filter_command(EXCLUDE_HINTSSKIPS, "FilterHintsSkips", Accelerator('H', (GdkModifierType)GDK_CONTROL_MASK));
 276   add_filter_command(EXCLUDE_MODELS, "FilterModels", Accelerator('M', (GdkModifierType)GDK_SHIFT_MASK));
 277   add_filter_command(EXCLUDE_TRIGGERS, "FilterTriggers", Accelerator('T', (GdkModifierType)(GDK_SHIFT_MASK|GDK_CONTROL_MASK)));
 278   if(g_pGameDescription->mGameType != "doom3")
 279   {
 280     add_filter_command(EXCLUDE_BOTCLIP, "FilterBotClips", Accelerator('M', (GdkModifierType)GDK_MOD1_MASK));
 281   }
 282
 283   PerformFiltering();
 284 }
 285
 286 void DestroyFilters()
 287 {
 288   g_filters.clear();
 289 }
 290
 291 #include "modulesystem/singletonmodule.h"
 292 #include "modulesystem/moduleregistry.h"
 293
 294 class FilterAPI
 295 {
 296   FilterSystem* m_filter;
 297 public:
 298   typedef FilterSystem Type;
 299   STRING_CONSTANT(Name, "*");
 300
 301   FilterAPI()
 302   {
 303     ConstructFilters();
 304
 305     m_filter = &GetFilterSystem();
 306   }
 307   ~FilterAPI()
 308   {
 309     DestroyFilters();
 310   }
 311   FilterSystem* getTable()
 312   {
 313     return m_filter;
 314   }
 315 };
 316
 317 typedef SingletonModule<FilterAPI> FilterModule;
 318 typedef Static<FilterModule> StaticFilterModule;
 319 StaticRegisterModule staticRegisterFilter(StaticFilterModule::instance());
 320
 321