jvfullcolorcircleform.pas

East make Tray Icon in delphi

  EnabledA := coCommon in Options;

  if not EnabledA then
    RadioButtonAxisSettings.Checked := True;

  RadioButtonCommonSettings.Enabled := EnabledA;
  EnabledA := EnabledA and RadioButtonCommonSettings.Checked;
  PanelCommonSettings.Enabled := EnabledA;

  if EnabledA then
    LColor := clWindow
  else
    LColor := clBtnFace;
  for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
  begin
    FSpinEditComAxes[I].Enabled := EnabledA;
    FSpinEditComAxes[I].Color := LColor;
    FCheckBoxCom[I].Enabled := EnabledA;
    FLabelComAxes[I].Enabled := EnabledA;
  end;
  LabelCommon.Enabled := EnabledA;
  JvFullColorTrackBarCommon.Visible := EnabledA;
  if EnabledA then
    JvColorCircle.Styles := JvColorCircle.Styles + [csShowCommon]
  else
    JvColorCircle.Styles := JvColorCircle.Styles - [csShowCommon];

  EnabledA := (coRed in Options) or (coBlue in Options) or (coGreen in Options);

  if not EnabledA then
    RadioButtonCommonSettings.Checked := True;

  RadioButtonAxisSettings.Enabled := EnabledA;
  EnabledA := EnabledA and RadioButtonAxisSettings.Checked;
  PanelAxisSettings.Enabled := EnabledA;
  for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
    FLabelAxes[I].Enabled := EnabledA;

  EnabledB := EnabledA and (coRed in Options);
  if EnabledB then
    LColor := clWindow
  else
    LColor := clBtnFace;
  LabelRed.Enabled := EnabledB;
  for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
  begin
    FSpinEditRedAxes[I].Enabled := EnabledB;
    FSpinEditRedAxes[I].Color := LColor;
    FCheckBoxRed[I].Enabled := EnabledB;
  end;
  JvFullColorTrackBarRed.Visible := EnabledB;

  EnabledB := EnabledA and (coGreen in Options);
  if EnabledB then
    LColor := clWindow
  else
    LColor := clBtnFace;
  LabelGreen.Enabled := EnabledB;
  for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
  begin
    FSpinEditGreenAxes[I].Enabled := EnabledB;
    FSpinEditGreenAxes[I].Color := LColor;
    FCheckBoxGreen[I].Enabled := EnabledB;
  end;
  JvFullColorTrackBarGreen.Visible := EnabledB;

  EnabledB := EnabledA and (coBlue in Options);
  if EnabledB then
    LColor := clWindow
  else
    LColor := clBtnFace;
  LabelBlue.Enabled := EnabledB;
  for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
  begin
    FSpinEditBlueAxes[I].Enabled := EnabledB;
    FSpinEditBlueAxes[I].Color := LColor;
    FCheckBoxBlue[I].Enabled := EnabledB;
  end;
  JvFullColorTrackBarBlue.Visible := EnabledB;
end;

procedure TJvFullColorCircleFrm.CheckBoxSettingsClick(Sender: TObject);
var
  Idx: TJvAxisIndex;
  AxisDelta: TJvAxisDelta;
  SaturationMethod: TJvSaturationMethod;
begin
  if FUpdating then
    Exit;

  FUpdating := True;

  with Sender as TCheckBox do
  begin
    if Checked then
      SaturationMethod := smLoop
    else
      SaturationMethod := smRange;

    Idx := AxisIndexFromTag(Tag);
    case Tag and $30 of
      $00:
        begin
          AxisDelta := RedDelta;
          AxisDelta[Idx].SaturationMethod := SaturationMethod;
          RedDelta := AxisDelta;
        end;
      $10:
        begin
          AxisDelta := GreenDelta;
          AxisDelta[Idx].SaturationMethod := SaturationMethod;
          GreenDelta := AxisDelta;
        end;
      $20:
        begin
          AxisDelta := BlueDelta;
          AxisDelta[Idx].SaturationMethod := SaturationMethod;
          BlueDelta := AxisDelta;
        end;
      $30:
        begin
          AxisDelta := RedDelta;
          AxisDelta[Idx].SaturationMethod := SaturationMethod;
          RedDelta := AxisDelta;

          AxisDelta := GreenDelta;
          AxisDelta[Idx].SaturationMethod := SaturationMethod;
          GreenDelta := AxisDelta;

          AxisDelta := BlueDelta;
          AxisDelta[Idx].SaturationMethod := SaturationMethod;
          BlueDelta := AxisDelta;
        end;
    end;
  end;

  FUpdating := False;

  UpdateCheckBoxStates;
end;

procedure TJvFullColorCircleFrm.UpdateCheckBoxStates;
var
  I: TJvAxisIndex;

  procedure UpdateCheckBox(ACheckBox: TCheckBox);
  var
    Idx: TJvAxisIndex;
    SaturationMethod: TJvSaturationMethod;
  begin
    SaturationMethod := smRange;

    Idx := AxisIndexFromTag(ACheckBox.Tag);
    case ACheckBox.Tag and $30 of
      $00:
        SaturationMethod := RedDelta[Idx].SaturationMethod;
      $10:
        SaturationMethod := GreenDelta[Idx].SaturationMethod;
      $20:
        SaturationMethod := BlueDelta[Idx].SaturationMethod;
      $30:
        if (RedDelta[Idx].SaturationMethod = smLoop) and
          (GreenDelta[Idx].SaturationMethod = smLoop) and
          (BlueDelta[Idx].SaturationMethod = smLoop) then
          SaturationMethod := smLoop
        else
          SaturationMethod := smRange;
    end;

    if SaturationMethod = smLoop then
    begin
      ACheckBox.Caption := GlobalLoop;
      ACheckBox.Checked := True;
    end
    else
    begin
      ACheckBox.Caption := GlobalRange;
      ACheckBox.Checked := False;
    end;
  end;

begin
  if FUpdating then
    Exit;
  FillInternalArrays;

  FUpdating := True;
  for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
  begin
    UpdateCheckBox(FCheckBoxCom[I]);
    UpdateCheckBox(FCheckBoxRed[I]);
    UpdateCheckBox(FCheckBoxGreen[I]);
    UpdateCheckBox(FCheckBoxBlue[I]);
  end;
  FUpdating := False;
end;

procedure TJvFullColorCircleFrm.ButtonGraphicsClick(Sender: TObject);
begin
  if Expanded then
    Collapse
  else
    Expand;
end;

procedure TJvFullColorCircleFrm.ButtonApplyClick(Sender: TObject);
begin
  if Assigned(OnApply) then
    OnApply(Self);
end;

procedure TJvFullColorCircleFrm.JvColorSpaceComboChange(Sender: TObject);
begin
  if not FUpdating then
    UpdateColorSpace;
end;

procedure TJvFullColorCircleFrm.SetBlueDelta(const Value: TJvAxisDelta);
begin
  FDelta.AxisBlue.Assign(Value);
  if not FUpdating then
  begin
    UpdateDeltaValue;
    UpdateCheckBoxStates;
  end;
end;

procedure TJvFullColorCircleFrm.SetDelta(const Value: TJvColorDelta);
var
  ChangeColorSpace:Boolean;
begin
  ChangeColorSpace := Value.ColorID <> Delta.ColorID;
  FDelta.Assign(Value);
  if not FUpdating then
  begin
    if ChangeColorSpace then
    begin
      JvColorSpaceCombo.ColorSpaceID := Value.ColorID;
      UpdateColorSpace;
    end;
    UpdateDeltaValue;
    UpdateCheckBoxStates;
  end;
end;

procedure TJvFullColorCircleFrm.SetGreenDelta(const Value: TJvAxisDelta);
begin
  FDelta.AxisGreen.Assign(Value);
  if not FUpdating then
  begin
    UpdateDeltaValue;
    UpdateCheckBoxStates;
  end;
end;

procedure TJvFullColorCircleFrm.SetColorID(
  const Value: TJvFullColorSpaceID);
begin
  FDelta.ColorID := Value;
  if not FUpdating then
  begin
    JvColorSpaceCombo.ColorSpaceID := Value;
    UpdateColorSpace;
    UpdateDeltaValue;
    UpdateCheckBoxStates;
  end;
end;

procedure TJvFullColorCircleFrm.SetRedDelta(const Value: TJvAxisDelta);
begin
  FDelta.AxisRed.Assign(Value);
  if not FUpdating then
  begin
    UpdateDeltaValue;
    UpdateCheckBoxStates;
  end;
end;

procedure TJvFullColorCircleFrm.CalcDeltaValue(ARotateColor: TJvRotateColor);
var
  I: TJvAxisIndex;
  AxisDelta: TJvAxisDelta;

  function GetDelta(OldValue: Integer; ColorAxisValue: Integer;
    InitAxisValue, AxisMin, AxisMax: Byte): Integer;
  var
    AxisLength: Integer;
    Offset1, Offset2, Offset3: Integer;
  begin
    AxisLength := AxisMax - AxisMin + 1;
    Offset1 := Abs(ColorAxisValue - AxisLength - OldValue - InitAxisValue);
    Offset2 := Abs(ColorAxisValue - OldValue - InitAxisValue);
    Offset3 := Abs(ColorAxisValue + AxisLength - OldValue - InitAxisValue);
    if (Offset1 < Offset2) and (Offset1 < Offset3) then
      Result := (ColorAxisValue - AxisLength) - InitAxisValue
    else
    if Offset2 < Offset3 then
      Result := ColorAxisValue - InitAxisValue
    else
      Result := (ColorAxisValue + AxisLength) - InitAxisValue;

    Result := EnsureRange(Result, -AxisLength, AxisLength);
  end;

begin
  if FUpdating then
    Exit;

  FUpdating := True;
  AxisDelta := TJvAxisDelta.Create;
  try
    if ARotateColor = rcCommon then
    begin
      for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
      begin
        AxisDelta[I].Value := GetDelta(RedDelta[I].Value, GetAxisValue(JvColorCircle.FullColor, I),
          FComAxis[I], FAxisMin[I], FAxisMax[I]);
        AxisDelta[I].SaturationMethod := RedDelta[I].SaturationMethod;
      end;
      RedDelta.Assign(AxisDelta);
      GreenDelta.Assign(RedDelta);
      BlueDelta.Assign(RedDelta);
    end
    else
    begin
      if ARotateColor = rcRed then
      begin
        //RedDelta := GetDelta(RedDelta, JvColorCircle.RedColor, FRedAxis0, FRedAxis1, FRedAxis2);
        for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
        begin
          AxisDelta[I].Value := GetDelta(RedDelta[I].Value, GetAxisValue(JvColorCircle.RedColor, I),
            FRedAxis[I], FAxisMin[I], FAxisMax[I]);
          AxisDelta[I].SaturationMethod := RedDelta[I].SaturationMethod;
        end;
        RedDelta.Assign(AxisDelta);
      end;

      if ARotateColor = rcGreen then
      begin
        //GreenDelta := GetDelta(GreenDelta, JvColorCircle.GreenColor, FGreenAxis0, FGreenAxis1, FGreenAxis2);
        for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
        begin
          AxisDelta[I].Value := GetDelta(GreenDelta[I].Value, GetAxisValue(JvColorCircle.GreenColor, I),
            FGreenAxis[I], FAxisMin[I], FAxisMax[I]);
          AxisDelta[I].SaturationMethod := GreenDelta[I].SaturationMethod;
        end;
        GreenDelta.Assign(AxisDelta);
      end;

      if ARotateColor = rcBlue then
      begin
        //BlueDelta := GetDelta(BlueDelta, JvColorCircle.BlueColor, FBlueAxis0, FBlueAxis1, FBlueAxis2);
        for I := Low(TJvAxisIndex) to High(TJvAxisIndex) do
        begin
          AxisDelta[I].Value := GetDelta(BlueDelta[I].Value, GetAxisValue(JvColorCircle.BlueColor, I),
            FBlueAxis[I], FAxisMin[I], FAxisMax[I]);
          AxisDelta[I].SaturationMethod := BlueDelta[I].SaturationMethod;
        end;
        BlueDelta.Assign(AxisDelta);
      end;
    end;
  finally
    FUpdating := False;
    AxisDelta.Free;
  end;

  UpdateDeltaValue;
end;

procedure TJvFullColorCircleFrm.JvColorCircleBlueColorChange(Sender: TObject);
begin
  if not FUpdating then
    CalcDeltaValue(rcBlue);
end;

procedure TJvFullColorCircleFrm.JvColorCircleColorChange(Sender: TObject);
begin
  if not FUpdating then
    CalcDeltaValue(rcCommon);
end;

procedure TJvFullColorCircleFrm.JvColorCircleGreenColorChange(Sender: TObject);
begin
  if not FUpdating then
    CalcDeltaValue(rcGreen);
end;

procedure TJvFullColorCircleFrm.JvColorCircleRedColorChange(Sender: TObject);
begin
  if not FUpdating then
    CalcDeltaValue(rcRed);
end;

procedure TJvFullColorCircleFrm.JvColorAxisConfigComboChange(Sender: TObject);
begin
  if not FUpdating then
  begin
    FUpdating := True;
    JvColorCircle.AxisConfig := (Sender as TJvFullColorAxisCombo).Selected;
    FUpdating := False;
  end;
end;

procedure TJvFullColorCircleFrm.JvColorCircleColorSpaceChange(Sender: TObject);
begin
  CalcDeltaValue(rcRed);
  CalcDeltaValue(rcGreen);
  CalcDeltaValue(rcBlue);
end;

procedure TJvFullColorCircleFrm.SpinEditSettingsValueChange(Sender: TObject);
var
  Idx: TJvAxisIndex;
  AxisDelta: TJvAxisDelta;
  IntValue:Integer;
  TagValue:Integer;
begin
  if FUpdating then
    Exit;

  with Sender as TJvSpinEdit do
  begin
    if not TryStrToInt(Text,IntValue) then
      Exit;
    TagValue := Tag;
    Idx := AxisIndexFromTag(TagValue);
  end;

  FUpdating := True;

  case TagValue and $30 of
    $00:
      begin
        AxisDelta := RedDelta;
        AxisDelta[Idx].Value := IntValue;
        RedDelta := AxisDelta;
      end;
    $10:
      begin
        AxisDelta := GreenDelta;
        AxisDelta[Idx].Value := IntValue;
        GreenDelta := AxisDelta;
      end;
    $20:
      begin
        AxisDelta := BlueDelta;
        AxisDelta[Idx].Value := IntValue;
        BlueDelta := AxisDelta;
      end;
    $30:
      begin
        AxisDelta := RedDelta;
        AxisDelta[Idx].Value := IntValue;
        RedDelta := AxisDelta;
        GreenDelta := AxisDelta;
        BlueDelta := AxisDelta;
      end;
  end;

  FUpdating := False;

  UpdateDeltaValue;
end;

procedure InitializeStrings;
var
  LTypInfo: PTypeInfo;
  LString: string;
begin
  LTypInfo := TypeInfo(TJvSaturationMethod);
  LString := GetEnumName(LTypInfo, Integer(smLoop));
  GlobalLoop := Copy(LString, 3, Length(LString) - 2);
  LString := GetEnumName(LTypInfo, Integer(smRange));
  GlobalRange := Copy(LString, 3, Length(LString) - 2);
end;

initialization
  {$IFDEF UNITVERSIONING}
  RegisterUnitVersion(HInstance, UnitVersioning);
  {$ENDIF UNITVERSIONING}
  InitializeStrings;

{$IFDEF UNITVERSIONING}
finalization
  UnregisterUnitVersion(HInstance);
{$ENDIF UNITVERSIONING}

end.