Initial upload

1 files changed, 557 insertions, 0 deletions

diff --git a/nGenEx/Slider.cpp b/nGenEx/Slider.cpp
new file mode 100644
index 0000000..f39254e
--- /dev/null
+++ b/nGenEx/Slider.cpp
@@ -0,0 +1,557 @@
+/*  Project nGenEx

+    Destroyer Studios LLC

+    Copyright © 1997-2004. All Rights Reserved.

+

+    SUBSYSTEM:    nGenEx.lib

+    FILE:         Slider.cpp

+    AUTHOR:       John DiCamillo

+

+

+    OVERVIEW

+    ========

+    Slider/Gauge ActiveWindow class

+*/

+

+#include "MemDebug.h"

+#include "Slider.h"

+#include "Video.h"

+#include "Font.h"

+

+// +--------------------------------------------------------------------+

+

+Slider::Slider(ActiveWindow* p, int ax, int ay, int aw, int ah, DWORD aid)

+   : ActiveWindow(p->GetScreen(), ax, ay, aw, ah, aid, 0, p)

+{

+   captured       = false;

+   dragging       = false;

+

+   border_color   = Color::Black;

+   fill_color     = Color::DarkBlue;

+   

+   active         = true;

+   border         = true;

+   num_leds       = 1;

+   orientation    = 0;

+

+   range_min      = 0;

+   range_max      = 100;

+   step_size      = 10;

+   show_thumb     = 0;

+   thumb_size     = -1;

+

+   nvalues        = 1;

+   ZeroMemory(value, sizeof(value));

+

+   marker[0]      = -1;

+   marker[1]      = -1;

+

+   char buf[32];

+   sprintf(buf, "Slider %d", id);

+   desc = buf;

+}

+

+Slider::Slider(Screen* s, int ax, int ay, int aw, int ah, DWORD aid)

+   : ActiveWindow(s, ax, ay, aw, ah, aid)

+{

+   captured       = false;

+   dragging       = false;

+

+   border_color   = Color::Black;

+   fill_color     = Color::DarkBlue;

+   

+   active         = true;

+   border         = true;

+   num_leds       = 1;

+   orientation    = 0;

+

+   range_min      = 0;

+   range_max      = 100;

+   step_size      = 10;

+   show_thumb     = 0;

+   thumb_size     = -1;

+

+   nvalues        = 1;

+   ZeroMemory(value, sizeof(value));

+

+   marker[0]      = -1;

+   marker[1]      = -1;

+

+   char buf[32];

+   sprintf(buf, "Slider %d", id);

+   desc = buf;

+}

+

+Slider::~Slider()

+{

+}

+

+// +--------------------------------------------------------------------+

+

+void

+Slider::Draw()

+{

+   int x = 0;

+   int y = 0;

+   int w = rect.w;

+   int h = rect.h;

+

+   if (w < 1 || h < 1 || !shown)

+      return;

+

+   Rect  ctrl_rect(x,y,w,h);

+

+   // draw the border:

+   if (border) {

+      Color oc = ShadeColor(border_color, 1);

+      DrawRect(0,0,w-1,h-1,oc);

+      DrawRect(1,1,w-2,h-2,oc);

+

+      ctrl_rect.Deflate(2,2);

+   }

+

+   // draw the bevel:

+   FillRect(ctrl_rect, back_color);

+   DrawStyleRect(ctrl_rect, WIN_SUNK_FRAME);

+   

+   // HORIZONTAL

+   if (orientation == 0) {

+      // draw the leds:

+      int led_width  = ((w - 6) / (num_leds)) - 1;

+      int led_height = ((h - 5) / (nvalues))  - 1;

+

+      if (nvalues < 2) {

+         int fill_width  = (int) ((double)(w-4) * FractionalValue());

+         int num_lit     = fill_width / (led_width+1);

+

+         Color fc = ShadeColor(fill_color, 1);

+

+         if (num_leds == 1) {

+            FillRect(2,2,2+fill_width,h-3,fc);

+         }

+         else {

+            int x0 = 2;

+

+            for (int i = 0; i < num_lit; i++) {

+               FillRect(x0,2,x0+led_width,h-3,fc);

+               x0 += led_width + 1;

+            }

+         }

+

+         // draw the thumb:

+         if (thumb_size) {

+            if (thumb_size < 0) thumb_size = h;

+

+            thumb_pos = 2+fill_width;

+

+            Rect thumb_rect(thumb_pos-thumb_size/2, 0, thumb_size, h);

+

+            if (thumb_rect.x < 0)

+               thumb_rect.x = 0;

+

+            else if (thumb_rect.x > w-thumb_size)

+               thumb_rect.x = w-thumb_size;

+

+            if (show_thumb) {

+               FillRect(thumb_rect, back_color);

+               DrawStyleRect(thumb_rect, WIN_RAISED_FRAME);

+            }

+         }

+      }

+

+      else {

+         Color fc = ShadeColor(fill_color, 1);

+

+         int y0 = 3;

+

+         for (int i = 0; i < nvalues; i++) {

+            int fill_width  = (int) ((double)(w-6) * FractionalValue(i));

+            FillRect(3,y0,3+fill_width,y0+led_height,fc);

+

+            y0 += led_height+1;

+         }

+      }

+

+      // draw the markers:

+      if (marker[0] >= 0) {

+         int   m = marker[0];

+         Color c = ShadeColor(base_color, 1.6);    // full highlight

+         DrawLine(m-3, 1, m+4,  1, c);

+         c = ShadeColor(base_color, 1.3);          // soft highlight

+         DrawLine(m-3, 2, m-3,  4, c);

+         DrawLine(m-2, 4, m-2,  6, c);

+         DrawLine(m-1, 6, m-1,  8, c);

+         DrawLine(m  , 8, m  , 10, c);

+         c = base_color;                           // body

+         DrawLine(m-2, 2, m-2,  4, c);

+         DrawLine(m-1, 2, m-1,  6, c);

+         DrawLine(m  , 2, m  ,  8, c);

+         DrawLine(m+1, 2, m+1,  6, c);

+         DrawLine(m+2, 2, m+2,  4, c);

+         c = ShadeColor(base_color, 0.5);          // shadow

+         DrawLine(m+1, 6, m+1,  8, c);

+         DrawLine(m+2, 4, m+2,  6, c);

+         DrawLine(m+3, 2, m+3,  4, c);

+      }

+

+      if (marker[1] >= 0) {

+         int   m = marker[0];

+         Color c = ShadeColor(base_color, 0.5);    // shadow

+         DrawLine(m-3, h-2, m+4, h-2, c);

+         DrawLine(m+1, h-6, m+1, h-8, c);

+         DrawLine(m+2, h-4, m+2, h-6, c);

+         DrawLine(m+3, h-2, m+3, h-4, c);

+         c = ShadeColor(base_color, 1.3);          // soft highlight

+         DrawLine(m-3, h-2, m-3, h-4, c);

+         DrawLine(m-2, h-4, m-2, h-6, c);

+         DrawLine(m-1, h-6, m-1, h-8, c);

+         DrawLine(m  , h-8, m  , h-10, c);

+         c = base_color;                           // body

+         DrawLine(m-2, h-2, m-2, h-4, c);

+         DrawLine(m-1, h-2, m-1, h-6, c);

+         DrawLine(m  , h-2, m  , h-8, c);

+         DrawLine(m+1, h-2, m+1, h-6, c);

+         DrawLine(m+2, h-2, m+2, h-4, c);

+      }

+   }

+

+   // VERTICAL

+   else {

+      // draw the leds:

+      int led_width  = ((w - 5) / (nvalues))  - 1;

+

+      if (num_leds > 1) {

+      }

+      else {

+         if (nvalues < 2) {

+            int led_width  = w - 4;

+            int led_height = (int) ((double)(h-4) * FractionalValue());

+

+            Color fc = ShadeColor(fill_color, 1);

+            FillRect(2, h-2-led_height, 2+led_width, h-2, fc);

+

+            // draw the thumb:

+            if (thumb_size) {

+               if (thumb_size < 0) thumb_size = w;

+

+               thumb_pos = h-2-led_height;

+

+               Rect thumb_rect(0, thumb_pos-(thumb_size/2), w, thumb_size);

+

+               if (thumb_rect.y < 0)

+                  thumb_rect.y = 0;

+

+               else if (thumb_rect.y > h-thumb_size)

+                  thumb_rect.y = h-thumb_size;

+

+               if (show_thumb) {

+                  FillRect(thumb_rect, back_color);

+                  DrawStyleRect(thumb_rect, WIN_RAISED_FRAME);

+               }

+            }

+         }

+

+         else {

+            Color fc = ShadeColor(fill_color, 1);

+

+            int x0 = 3;

+

+            for (int i = 0; i < nvalues; i++) {

+               int led_height = (int) ((double)(h-6) * FractionalValue(i));

+               FillRect(x0,h-3-led_height,x0+led_width,h-3,fc);

+

+               x0 += led_width+1;

+            }

+         }

+      }

+   }

+}

+

+// +--------------------------------------------------------------------+

+

+bool Slider::GetActive()

+{

+   return active;

+}

+

+void  Slider::SetActive(bool bNewValue)

+{

+   active = bNewValue;

+}

+

+bool  Slider::GetBorder()

+{

+   return border;

+}

+

+void  Slider::SetBorder(bool bNewValue)

+{

+   border = bNewValue;

+}

+

+Color  Slider::GetBorderColor()

+{

+   return border_color;

+}

+

+void  Slider::SetBorderColor(Color newValue)

+{

+   border_color = newValue;

+}

+

+Color Slider::GetFillColor()

+{

+   return fill_color;

+}

+

+void  Slider::SetFillColor(Color cNewValue)

+{

+   fill_color = cNewValue;

+}

+

+int   Slider::GetNumLeds()

+{

+   return num_leds;

+}

+

+void  Slider::SetNumLeds(int nNewValue)

+{

+   if (nNewValue >= 0) {

+      num_leds = nNewValue;

+   }

+}

+

+int   Slider::GetOrientation()

+{

+   return orientation;

+}

+

+void  Slider::SetOrientation(int nNewValue)

+{

+   if (nNewValue == 0 || nNewValue == 1) {

+      orientation = nNewValue;

+   }

+}

+

+int   Slider::GetRangeMin()

+{

+   return range_min;

+}

+

+void  Slider::SetRangeMin(int nNewValue)

+{

+   range_min = nNewValue;

+}

+

+int   Slider::GetRangeMax()

+{

+   return range_max;

+}

+

+void  Slider::SetRangeMax(int nNewValue)

+{

+   range_max = nNewValue;

+}

+

+int   Slider::GetStepSize()

+{

+   return step_size;

+}

+

+void  Slider::SetStepSize(int nNewValue)

+{

+   if (nNewValue < range_max - range_min)

+      step_size = nNewValue;

+}

+

+bool  Slider::GetShowThumb()

+{

+   return show_thumb?true:false;

+}

+

+void  Slider::SetShowThumb(bool bNewValue)

+{

+   show_thumb = bNewValue;

+}

+

+int   Slider::GetThumbSize()

+{

+   return thumb_size;

+}

+

+void  Slider::SetThumbSize(int nNewValue)

+{

+   if (nNewValue < range_max - range_min)

+      thumb_size = nNewValue;

+}

+

+int   Slider::NumValues()

+{

+   return nvalues;

+}

+

+int   Slider::GetValue(int index)

+{

+   if (index >= 0 && index < nvalues)

+      return value[index];

+

+   return 0;

+}

+

+void  Slider::SetValue(int nNewValue, int index)

+{

+   if (index >= 0 && index < MAX_VAL) {

+      value[index] = nNewValue;

+      

+      if (index >= nvalues)

+         nvalues = index+1;

+   }

+}

+

+void  Slider::SetMarker(int nNewValue, int index)

+{

+   if (index >= 0 && index < 2) {

+      marker[index] = nNewValue;

+   }

+}

+

+double Slider::FractionalValue(int index)

+{

+   if (index >= 0 && index < nvalues)

+      return ((double) (value[index]-range_min)) / ((double) (range_max-range_min));

+

+   return 0;

+}

+

+// +--------------------------------------------------------------------+

+

+void  Slider::StepUp(int index)

+{

+   if (index >= 0 && index < nvalues) {

+      value[index] += step_size;

+

+      if (value[index] > range_max)

+         value[index] = range_max;

+   }

+}

+

+void  Slider::StepDown(int index)

+{

+   if (index >= 0 && index < nvalues) {

+      value[index] -= step_size;

+

+      if (value[index] < range_min)

+         value[index] = range_min;

+   }

+}

+

+// +--------------------------------------------------------------------+

+

+int Slider::OnMouseMove(int x, int y)

+{

+   bool dirty = false;

+

+   if (captured)

+   {

+      ActiveWindow* test = GetCapture();

+

+      if (test != this)

+      {

+         captured = false;

+         dirty = true;

+      }

+

+      else if (dragging)

+      {

+         mouse_x = x - rect.x;

+         if (mouse_x < 0) mouse_x = 0;

+         else if (mouse_x > rect.w) mouse_x = rect.w;

+

+         mouse_y = rect.h - (y - rect.y);

+         if (mouse_y < 0) mouse_y = 0;

+         else if (mouse_y > rect.h) mouse_y = rect.h;

+

+         // HORIZONTAL

+         if (orientation == 0) {

+            SetValue((int) ((double) mouse_x/rect.w * (range_max-range_min) + range_min));

+         }

+

+         // VERTICAL

+         else {

+            SetValue((int) ((double) mouse_y/rect.h * (range_max-range_min) + range_min));

+         }

+

+         dirty = true;

+      }

+   }

+

+   if (dirty)

+      OnClick();

+

+   return ActiveWindow::OnMouseMove(x,y);

+}

+

+int Slider::OnLButtonDown(int x, int y)

+{

+   if (!active)

+      return 0;

+

+   if (!captured)

+      captured = SetCapture();

+

+   mouse_x = x - rect.x;

+   mouse_y = y - rect.y;

+

+   // HORIZONTAL

+   if (orientation == 0) {

+      if (mouse_x < thumb_pos-thumb_size/2) {

+         StepDown();

+      }

+

+      else if (mouse_x > thumb_pos+thumb_size/2) {

+         StepUp();

+      }

+

+      else {

+         dragging = true;

+      }

+   }

+

+   // VERTICAL

+   else {

+      if (mouse_y < thumb_pos-thumb_size/2) {

+         StepUp();

+      }

+

+      else if (mouse_y > thumb_pos+thumb_size/2) {

+         StepDown();

+      }

+

+      else {

+         dragging = true;

+      }

+   }

+

+   if (!dragging)

+      OnClick();

+

+   return ActiveWindow::OnLButtonDown(x,y);

+}

+

+int Slider::OnLButtonUp(int x, int y)

+{

+   if (!active)

+      return 0;

+

+   if (captured) {

+      ReleaseCapture();

+      captured = 0;

+      dragging = false;

+   }

+

+   return ActiveWindow::OnLButtonUp(x,y);

+}

+

+int Slider::OnClick()

+{

+   return ActiveWindow::OnClick();

+}