gemrb/core/Slider.cpp

   1 /* GemRB - Infinity Engine Emulator
   2  * Copyright (C) 2003 The GemRB Project
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program 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 this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  *
  19  */
  20
  21 #include <cmath>
  22 #include "win32def.h"
  23 #include "Slider.h"
  24 #include "Interface.h"
  25 #include "Video.h"
  26 #include "Variables.h"
  27
  28 Slider::Slider(short KnobXPos, short KnobYPos, short KnobStep,
  29         unsigned short KnobStepsCount, bool Clear)
  30 {
  31         this->KnobXPos = KnobXPos;
  32         this->KnobYPos = KnobYPos;
  33         this->KnobStep = KnobStep;
  34         this->KnobStepsCount = KnobStepsCount;
  35         Knob = NULL;
  36         GrabbedKnob = NULL;
  37         BackGround = NULL;
  38         this->Clear = Clear;
  39         ResetEventHandler( SliderOnChange );
  40         State = IE_GUI_SLIDER_KNOB;
  41         Pos = 0;
  42         Value = 1;
  43 }
  44
  45 Slider::~Slider()
  46 {
  47         if (!Clear) {
  48                 return;
  49         }
  50         if (Knob) {
  51                 core->GetVideoDriver()->FreeSprite( Knob );
  52         }
  53         if (GrabbedKnob) {
  54                 core->GetVideoDriver()->FreeSprite( GrabbedKnob );
  55         }
  56         if (BackGround) {
  57                 core->GetVideoDriver()->FreeSprite( BackGround );
  58         }
  59 }
  60
  61 /** Draws the Control on the Output Display */
  62 void Slider::Draw(unsigned short x, unsigned short y)
  63 {
  64         if (!Changed && !(Owner->Flags&WF_FLOAT) ) {
  65                 return;
  66         }
  67         Changed = false;
  68         if (XPos == 65535) {
  69                 return;
  70         }
  71         Region r( x + XPos, y + YPos, Width, Height );
  72         if (BackGround) {
  73                 if (( BackGround->Width < Width ) || ( BackGround->Height < Height )) {
  74                         core->GetVideoDriver()->BlitTiled( r, BackGround, true );
  75                 } else {
  76                         core->GetVideoDriver()->BlitSprite( BackGround, x + XPos, y + YPos, true, &r );
  77                 }
  78         }
  79         switch (State) {
  80                 case IE_GUI_SLIDER_KNOB:
  81                         core->GetVideoDriver()->BlitSprite( Knob,
  82                                 x + XPos + KnobXPos + ( Pos * KnobStep ),
  83                                 y + YPos + KnobYPos, true );
  84                         break;
  85
  86                 case IE_GUI_SLIDER_GRABBEDKNOB:
  87                         core->GetVideoDriver()->BlitSprite( GrabbedKnob,
  88                                 x + XPos + KnobXPos + ( Pos * KnobStep ),
  89                                 y + YPos + KnobYPos, true );
  90                         break;
  91         }
  92 }
  93
  94 /** Returns the actual Slider Position */
  95 unsigned int Slider::GetPosition()
  96 {
  97         return Pos;
  98 }
  99
 100 /** Sets the actual Slider Position trimming to the Max and Min Values */
 101 void Slider::SetPosition(unsigned int pos)
 102 {
 103         if (pos <= KnobStepsCount) {
 104                 Pos = pos;
 105         }
 106         if (VarName[0] != 0) {
 107                 if (!Value)
 108                         Value = 1;
 109                 core->GetDictionary()->SetAt( VarName, pos * Value );
 110         }
 111         Changed = true;
 112 }
 113
 114 /** Redraws a slider which is associated with VariableName */
 115 void Slider::RedrawSlider(const char* VariableName, int Sum)
 116 {
 117         if (strnicmp( VarName, VariableName, MAX_VARIABLE_LENGTH )) {
 118                 return;
 119         }
 120         if (!Value) {
 121                 Value = 1;
 122         }
 123         Sum /= Value;
 124         if (Sum <= KnobStepsCount) {
 125                 Pos = Sum;
 126         }
 127         Changed = true;
 128 }
 129
 130 /** Sets the selected image */
 131 void Slider::SetImage(unsigned char type, Sprite2D* img)
 132 {
 133         switch (type) {
 134                 case IE_GUI_SLIDER_KNOB:
 135                         if (Knob && Clear)
 136                                 core->GetVideoDriver()->FreeSprite( Knob );
 137                         Knob = img;
 138                         break;
 139
 140                 case IE_GUI_SLIDER_GRABBEDKNOB:
 141                         if (GrabbedKnob && Clear)
 142                                 core->GetVideoDriver()->FreeSprite( GrabbedKnob );
 143                         GrabbedKnob = img;
 144                         break;
 145
 146                 case IE_GUI_SLIDER_BACKGROUND:
 147                         if (BackGround && Clear)
 148                                 core->GetVideoDriver()->FreeSprite( BackGround );
 149                         BackGround = img;
 150                         break;
 151         }
 152         Changed = true;
 153 }
 154
 155 /** Mouse Button Down */
 156 void Slider::OnMouseDown(unsigned short x, unsigned short y, unsigned short /*Button*/,
 157         unsigned short /*Mod*/)
 158 {
 159         Changed = true;
 160         unsigned int oldPos = Pos;
 161         int mx = (KnobXPos + ( Pos * KnobStep ) - Knob->XPos);
 162         int my = (KnobYPos - Knob->YPos);
 163         int Mx = (mx + Knob->Width);
 164         int My = (my + Knob->Height);
 165
 166         if (( x >= mx ) && ( y >= my )) {
 167                 if (( x <= Mx ) && ( y <= My )) {
 168                         State = IE_GUI_SLIDER_GRABBEDKNOB;
 169                 } else {
 170                         int mx = KnobXPos;
 171                         int xmx = x - mx;
 172                         if (x < mx) {
 173                                 SetPosition( 0 );
 174                                 if (oldPos != Pos) {
 175                                         RunEventHandler( SliderOnChange );
 176                                 }
 177                                 return;
 178                         }
 179                         int befst = xmx / KnobStep;
 180                         if (befst >= KnobStepsCount) {
 181                                 SetPosition( KnobStepsCount - 1 );
 182                                 if (oldPos != Pos) {
 183                                         RunEventHandler( SliderOnChange );
 184                                 }
 185                                 return;
 186                         }
 187                         int aftst = befst + KnobStep;
 188                         if (( xmx - ( befst * KnobStep ) ) <
 189                                 ( ( aftst * KnobStep ) - xmx )) {
 190                                 SetPosition( befst );
 191                         } else {
 192                                 SetPosition( aftst );
 193                         }
 194                         if (oldPos != Pos) {
 195                                 RunEventHandler( SliderOnChange );
 196                         }
 197                 }
 198         } else {
 199                 int mx = KnobXPos;
 200                 int xmx = x - mx;
 201                 if (x < mx) {
 202                         SetPosition( 0 );
 203                         if (oldPos != Pos) {
 204                                 RunEventHandler( SliderOnChange );
 205                         }
 206                         return;
 207                 }
 208                 int befst = xmx / KnobStep;
 209                 if (befst >= KnobStepsCount) {
 210                         SetPosition( KnobStepsCount - 1 );
 211                         if (oldPos != Pos) {
 212                                 RunEventHandler( SliderOnChange );
 213                         }
 214                         return;
 215                 }
 216                 int aftst = befst + KnobStep;
 217                 if (( xmx - ( befst * KnobStep ) ) < ( ( aftst * KnobStep ) - xmx )) {
 218                         SetPosition( befst );
 219                 } else {
 220                         SetPosition( aftst );
 221                 }
 222                 if (oldPos != Pos) {
 223                         RunEventHandler( SliderOnChange );
 224                 }
 225         }
 226 }
 227
 228 /** Mouse Button Up */
 229 void Slider::OnMouseUp(unsigned short /*x*/, unsigned short /*y*/, unsigned short /*Button*/,
 230         unsigned short /*Mod*/)
 231 {
 232         if (State != IE_GUI_SLIDER_KNOB) {
 233                 Changed = true;
 234         }
 235         State = IE_GUI_SLIDER_KNOB;
 236 }
 237
 238 /** Mouse Over Event */
 239 void Slider::OnMouseOver(unsigned short x, unsigned short /*y*/)
 240 {
 241         Changed = true;
 242         unsigned int oldPos = Pos;
 243         if (State == IE_GUI_SLIDER_GRABBEDKNOB) {
 244                 int mx = KnobXPos;
 245                 int xmx = x - mx;
 246                 if (x < mx) {
 247                         SetPosition( 0 );
 248                         if (oldPos != Pos) {
 249                                 RunEventHandler( SliderOnChange );
 250                         }
 251                         return;
 252                 }
 253                 int befst = xmx / KnobStep;
 254                 if (befst >= KnobStepsCount) {
 255                         SetPosition( KnobStepsCount - 1 );
 256                         if (oldPos != Pos) {
 257                                 RunEventHandler( SliderOnChange );
 258                         }
 259                         return;
 260                 }
 261                 short aftst = befst + KnobStep;
 262                 if (( xmx - ( befst * KnobStep ) ) < ( ( aftst * KnobStep ) - xmx )) {
 263                         SetPosition( befst );
 264                 } else {
 265                         SetPosition( aftst );
 266                 }
 267                 if (oldPos != Pos) {
 268                         RunEventHandler( SliderOnChange );
 269                 }
 270         }
 271 }
 272
 273 /** Sets the Text of the current control */
 274 int Slider::SetText(const char* /*string*/, int /*pos*/)
 275 {
 276         return 0;
 277 }
 278
 279 /** Sets the slider change event */
 280 bool Slider::SetEvent(int eventType, const char *handler)
 281 {
 282         Changed = true;
 283
 284         switch (eventType) {
 285         case IE_GUI_SLIDER_ON_CHANGE:
 286                 SetEventHandler( SliderOnChange, handler );
 287                 break;
 288         default:
 289                 return false;
 290         }
 291
 292         return true;
 293 }