contrib/ufoaiplug/ufoai_gtk.cpp

   1 /*
   2    This file is part of GtkRadiant.
   3
   4    GtkRadiant is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2 of the License, or
   7    (at your option) any later version.
   8
   9    GtkRadiant is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with GtkRadiant; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #include "ufoai_gtk.h"
  20 #include "ufoai_filters.h"
  21
  22 #include "itoolbar.h"
  23 #include "iscenegraph.h"
  24
  25 #include <gtk/gtk.h>
  26 #include <uilib/uilib.h>
  27
  28 /**
  29  * @brief If you return FALSE in the "delete_event" signal handler,
  30  * GTK will emit the "destroy" signal. Returning TRUE means
  31  * you don't want the window to be destroyed.
  32  * This is useful for popping up 'are you sure you want to quit?'
  33  * type dialogs.
  34  */
  35 static gboolean delete_event(ui::Widget widget, GdkEvent *event, gpointer data)
  36 {
  37     return FALSE;
  38 }
  39
  40 /**
  41  * @brief destroy widget if destroy signal is passed to widget
  42  */
  43 static void destroy(ui::Widget widget, gpointer data)
  44 {
  45     widget.destroy();
  46 }
  47
  48 /**
  49  * @brief function for close button to destroy the toplevel widget
  50  */
  51 static void close_window(ui::Widget widget, gpointer data)
  52 {
  53     widget.window().destroy();
  54 }
  55
  56 /* =============================== */
  57
  58 const int NUM_TOOLBARBUTTONS = 12;
  59
  60 /**
  61  * @brief
  62  */
  63 std::size_t ToolbarButtonCount(void)
  64 {
  65     return NUM_TOOLBARBUTTONS;
  66 }
  67
  68 /**
  69  * @brief Used if the ufo plugin should not be visible (at least the toolbar stuff)
  70  */
  71 std::size_t ToolbarNoButtons(void)
  72 {
  73     return 0;
  74 }
  75
  76 /**
  77  * @brief
  78  */
  79 class CUFOAIToolbarButton : public IToolbarButton {
  80 public:
  81     virtual const char *getImage() const
  82     {
  83         switch (mIndex) {
  84             case 0:
  85                 return "ufoai_level1.png";
  86             case 1:
  87                 return "ufoai_level2.png";
  88             case 2:
  89                 return "ufoai_level3.png";
  90             case 3:
  91                 return "ufoai_level4.png";
  92             case 4:
  93                 return "ufoai_level5.png";
  94             case 5:
  95                 return "ufoai_level6.png";
  96             case 6:
  97                 return "ufoai_level7.png";
  98             case 7:
  99                 return "ufoai_level8.png";
 100             case 8:
 101                 return "ufoai_stepon.png";
 102             case 9:
 103                 return "ufoai_actorclip.png";
 104             case 10:
 105                 return "ufoai_weaponclip.png";
 106             case 11:
 107                 return "ufoai_nodraw.png";
 108         }
 109         return NULL;
 110     }
 111
 112     virtual EType getType() const
 113     {
 114         switch (mIndex) {
 115 /*              case 3: return eButton;*/
 116             case 8:
 117                 return eToggleButton;
 118             case 9:
 119                 return eToggleButton;
 120             case 10:
 121                 return eToggleButton;
 122             case 11:
 123                 return eToggleButton;
 124             default:
 125                 return eButton;
 126         }
 127     }
 128
 129     virtual const char *getText() const
 130     {
 131         switch (mIndex) {
 132             case 0:
 133                 return "Level 1";
 134             case 1:
 135                 return "Level 2";
 136             case 2:
 137                 return "Level 3";
 138             case 3:
 139                 return "Level 4";
 140             case 4:
 141                 return "Level 5";
 142             case 5:
 143                 return "Level 6";
 144             case 6:
 145                 return "Level 7";
 146             case 7:
 147                 return "Level 8";
 148             case 8:
 149                 return "Stepon";
 150             case 9:
 151                 return "Actorclip";
 152             case 10:
 153                 return "Weaponclip";
 154             case 11:
 155                 return "Nodraw";
 156         }
 157         return NULL;
 158     }
 159
 160     virtual const char *getTooltip() const
 161     {
 162         switch (mIndex) {
 163             case 0:
 164                 return "Show only level 1";
 165             case 1:
 166                 return "Show only level 2";
 167             case 2:
 168                 return "Show only level 3";
 169             case 3:
 170                 return "Show only level 4";
 171             case 4:
 172                 return "Show only level 5";
 173             case 5:
 174                 return "Show only level 6";
 175             case 6:
 176                 return "Show only level 7";
 177             case 7:
 178                 return "Show only level 8";
 179             case 8:
 180                 return "Hide stepon brushes";
 181             case 9:
 182                 return "Hide actorclip brushes";
 183             case 10:
 184                 return "Hide weaponclip brushes";
 185             case 11:
 186                 return "Hide nodraw brushes";
 187         }
 188         return NULL;
 189     }
 190
 191     virtual void activate() const
 192     {
 193         switch (mIndex) {
 194             case 0:
 195                 filter_level(CONTENTS_LEVEL1);
 196                 break;
 197             case 1:
 198                 filter_level(CONTENTS_LEVEL2);
 199                 break;
 200             case 2:
 201                 filter_level(CONTENTS_LEVEL3);
 202                 break;
 203             case 3:
 204                 filter_level(CONTENTS_LEVEL4);
 205                 break;
 206             case 4:
 207                 filter_level(CONTENTS_LEVEL5);
 208                 break;
 209             case 5:
 210                 filter_level(CONTENTS_LEVEL6);
 211                 break;
 212             case 6:
 213                 filter_level(CONTENTS_LEVEL7);
 214                 break;
 215             case 7:
 216                 filter_level(CONTENTS_LEVEL8);
 217                 break;
 218             case 8:
 219                 filter_stepon();
 220                 break;
 221             case 9:
 222                 filter_actorclip();
 223                 break;
 224             case 10:
 225                 filter_weaponclip();
 226                 break;
 227             case 11:
 228                 filter_nodraw();
 229                 break;
 230         }
 231         SceneChangeNotify();
 232     }
 233
 234     std::size_t mIndex;
 235 };
 236
 237 /**
 238  * @brief
 239  */
 240 CUFOAIToolbarButton g_ufoaiToolbarButtons[NUM_TOOLBARBUTTONS];
 241
 242 /**
 243  * @brief
 244  */
 245 const IToolbarButton *GetToolbarButton(std::size_t index)
 246 {
 247     g_ufoaiToolbarButtons[index].mIndex = index;
 248     return &g_ufoaiToolbarButtons[index];
 249 }
 250
 251 /**
 252  * @brief
 253  */
 254 const IToolbarButton *GetToolbarNoButton(std::size_t index)
 255 {
 256     return NULL;
 257 }