Esempio n. 1
0
 private void HandleARGBScroll(object sender, ScrollEventArgs e)
 {
     // If the R, G, or B values change, use this
     // code to update the HSV values and invalidate
     // the color wheel (so it updates the pointers).
     // Check the isInUpdate flag to avoid recursive events
     // when you update the NumericUpdownControls.
     changeType = ChangeStyle.ARGB;
     ARGB = new ColorHandler.ARGB(hsbAlpha.Value, hsbRed.Value, hsbGreen.Value, hsbBlue.Value);
     SetAHSV(ColorHandler.ARGBtoAHSV(ARGB));
     SetARGBLabels(ARGB);
     this.Invalidate();
 }
Esempio n. 2
0
        private void CalcCoordsAndUpdate(ColorHandler.AHSV AHSV)
        {
            // Convert color to real-world coordinates and then calculate
              // the various points. AHSV.Hue represents the degrees (0 to 360),
              // AHSV.Saturation represents the radius.
              // This procedure doesn't draw anything--it simply
              // updates class-level variables. The UpdateDisplay
              // procedure uses these values to update the screen.

              // Given the angle (AHSV.Hue), and distance from
              // the center (AHSV.Saturation), and the center,
              // calculate the point corresponding to
              // the selected color, on the color wheel.
              colorPoint = GetPoint((double)AHSV.Hue / 255 * 360,
            (double)AHSV.Saturation / 255 * radius,
            centerPoint);

              // Given the brightness (AHSV.value), calculate the
              // point corresponding to the brightness indicator.
              brightnessPoint = CalcBrightnessPoint(AHSV.Value);

              // Store information about the selected color.
              brightness = AHSV.Value;
              selectedColor = ColorHandler.AHSVtoColor(AHSV);
              ARGB = ColorHandler.AHSVtoARGB(AHSV);

              // The full color is the same as AHSV, except that the
              // brightness is set to full (255). This is the top-most
              // color in the brightness gradient.
              fullColor = ColorHandler.AHSVtoColor(AHSV.Alpha, AHSV.Hue, AHSV.Saturation, 255);

              // Given the brightness (AHSV.value), calculate the
              // point corresponding to the alpha indicator.
              alphaPoint = CalcAlphaPoint(AHSV.Alpha);

              // Store information about the selected color.
              alpha = AHSV.Alpha;
        }
Esempio n. 3
0
 public ColorChangedEventArgs(ColorHandler.ARGB RGB, ColorHandler.AHSV HSV)
 {
     mRGB = RGB;
       mHSV = HSV;
 }
Esempio n. 4
0
        public void Draw(Graphics g, Point mousePoint)
        {
            // You've moved the mouse.
              // Now update the screen to match.

              double distance;
              int degrees;
              Point delta;
              Point newColorPoint;
              Point newBrightnessPoint;
              Point newAlphaPoint;
              Point newPoint;

              // Keep track of the previous color pointer point,
              // so you can put the mouse there in case the
              // user has clicked outside the circle.
              newColorPoint = colorPoint;
              newBrightnessPoint = brightnessPoint;
              newAlphaPoint = alphaPoint;

              // Store this away for later use.
              this.g = g;

              if (currentState == MouseState.MouseUp)
              {
            if (!mousePoint.IsEmpty)
            {
              if (colorRegion.IsVisible(mousePoint))
              {
            // Is the mouse point within the color circle?
            // If so, you just clicked on the color wheel.
            currentState = MouseState.ClickOnColor;
              }
              else if (brightnessRegion.IsVisible(mousePoint))
              {
            // Is the mouse point within the brightness area?
            // You clicked on the brightness area.
            currentState = MouseState.ClickOnBrightness;
              }
              else if (alphaRegion.IsVisible(mousePoint))
              {
            // Is the mouse point within the alpha area?
            // You clicked on the alpha area.
            currentState = MouseState.ClickOnAlpha;
              }
              else
              {
            // Clicked outside the color, brightness and alpha
            // regions. In that case, just put the
            // pointers back where they were.
            currentState = MouseState.ClickOutsideRegion;
              }
            }
              }

              switch (currentState)
              {
            case MouseState.ClickOnBrightness:
            case MouseState.DragInBrightness:
              // Calculate new color information
              // based on the brightness, which may have changed.
              newPoint = mousePoint;
              if (newPoint.Y < brightnessMin)
              {
            newPoint.Y = brightnessMin;
              }
              else if (newPoint.Y > brightnessMax)
              {
            newPoint.Y = brightnessMax;
              }
              newBrightnessPoint = new Point(brightnessX, newPoint.Y);
              brightness = (int)((brightnessMax - newPoint.Y) * brightnessScaling);
              AHSV.Value = brightness;
              ARGB = ColorHandler.AHSVtoARGB(AHSV);
              break;

            case MouseState.ClickOnAlpha:
            case MouseState.DragInAlpha:
              // Calculate new color information
              // based on the alpha, which may have changed.
              newPoint = mousePoint;
              if (newPoint.Y < alphaMin)
              {
            newPoint.Y = alphaMin;
              }
              else if (newPoint.Y > alphaMax)
              {
            newPoint.Y = alphaMax;
              }
              newAlphaPoint = new Point(alphaX, newPoint.Y);
              alpha = (int)((alphaMax - newPoint.Y) * alphaScaling);
              AHSV.Alpha = alpha;
              ARGB = ColorHandler.AHSVtoARGB(AHSV);
              break;

            case MouseState.ClickOnColor:
            case MouseState.DragInColor:
              // Calculate new color information
              // based on selected color, which may have changed.
              newColorPoint = mousePoint;

              // Calculate x and y distance from the center,
              // and then calculate the angle corresponding to the
              // new location.
              delta = new Point(
            mousePoint.X - centerPoint.X, mousePoint.Y - centerPoint.Y);
              degrees = CalcDegrees(delta);

              // Calculate distance from the center to the new point
              // as a fraction of the radius. Use your old friend,
              // the Pythagorean theorem, to calculate this value.
              distance = Math.Sqrt(delta.X * delta.X + delta.Y * delta.Y) / radius;

              if (currentState == MouseState.DragInColor)
              {
            if (distance > 1)
            {
              // Mouse is down, and outside the circle, but you
              // were previously dragging in the color circle.
              // What to do?
              // In that case, move the point to the edge of the
              // circle at the correct angle.
              distance = 1;
              newColorPoint = GetPoint(degrees, radius, centerPoint);
            }
              }

              // Calculate the new AHSV and RGB values.
              AHSV.Hue = (int)(degrees * 255 / 360);
              AHSV.Saturation = (int)(distance * 255);
              AHSV.Value = brightness;
              ARGB = ColorHandler.AHSVtoARGB(AHSV);
              fullColor = ColorHandler.AHSVtoColor(AHSV.Alpha, AHSV.Hue, AHSV.Saturation, 255);
              break;
              }
              selectedColor = ColorHandler.AHSVtoColor(AHSV);

              // Raise an event back to the parent form,
              // so the form can update any UI it's using
              // to display selected color values.
              OnColorChanged(ARGB, AHSV);

              // On the way out, set the new state.
              switch (currentState)
              {
            case MouseState.ClickOnBrightness:
              currentState = MouseState.DragInBrightness;
              break;
            case MouseState.ClickOnAlpha:
              currentState = MouseState.DragInAlpha;
              break;
            case MouseState.ClickOnColor:
              currentState = MouseState.DragInColor;
              break;
            case MouseState.ClickOutsideRegion:
              currentState = MouseState.DragOutsideRegion;
              break;
              }

              // Store away the current points for next time.
              colorPoint = newColorPoint;
              brightnessPoint = newBrightnessPoint;
              alphaPoint = newAlphaPoint;

              // Draw the gradients and points.
              UpdateDisplay();
        }