1059 lines
34 KiB
C++
1059 lines
34 KiB
C++
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2008 by Sun Microsystems, Inc.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* $RCSfile: SlideSorterService.hxx,v $
|
|
*
|
|
* $Revision: 1.3 $
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
#include "SlsDebugDialog.hxx"
|
|
#include "view/SlideSorterView.hxx"
|
|
#include "view/SlsTheme.hxx"
|
|
#include "view/SlsPageObjectPainter.hxx"
|
|
#include "view/SlsButtonBar.hxx"
|
|
|
|
#include <vcl/window.hxx>
|
|
#include <vcl/wrkwin.hxx>
|
|
#include <vcl/button.hxx>
|
|
#include <vcl/fixed.hxx>
|
|
#include <vcl/slider.hxx>
|
|
#include <boost/function.hpp>
|
|
#include <boost/bind.hpp>
|
|
|
|
namespace css = ::com::sun::star;
|
|
using namespace ::sd::slidesorter::view;
|
|
|
|
namespace sd { namespace slidesorter {
|
|
|
|
class DebugControl
|
|
{
|
|
public:
|
|
DebugControl (void) {};
|
|
virtual ~DebugControl (void) {}
|
|
virtual sal_Int32 GetHeight (void) = 0;
|
|
};
|
|
|
|
//===== TextButton ============================================================
|
|
|
|
class TextButton : public PushButton, public DebugControl
|
|
{
|
|
public:
|
|
typedef ::boost::function<void(TextButton*)> Action;
|
|
|
|
TextButton (
|
|
::Window* pParent,
|
|
const char* pText,
|
|
const Rectangle& rBoundingBox,
|
|
const Action& rAction)
|
|
: PushButton(pParent),
|
|
maAction(rAction)
|
|
{
|
|
SetText(::rtl::OUString::createFromAscii(pText));
|
|
SetPosSizePixel(
|
|
rBoundingBox.Top(), rBoundingBox.Left(),
|
|
rBoundingBox.GetHeight(), rBoundingBox.GetWidth());
|
|
Show();
|
|
}
|
|
|
|
virtual void Click (void)
|
|
{
|
|
if (maAction)
|
|
maAction(this);
|
|
}
|
|
|
|
virtual sal_Int32 GetHeight (void)
|
|
{
|
|
return GetSizePixel().Height();
|
|
}
|
|
|
|
private:
|
|
Action maAction;
|
|
};
|
|
|
|
|
|
|
|
|
|
//===== ColorControl ==========================================================
|
|
|
|
ColorData RedColorForValue (const int nValue, const Color& rColor) {
|
|
return Color(nValue,rColor.GetGreen(),rColor.GetBlue()).GetColor(); }
|
|
ColorData GreenColorForValue (const int nValue, const Color& rColor) {
|
|
return Color(rColor.GetRed(),nValue,rColor.GetBlue()).GetColor(); }
|
|
ColorData BlueColorForValue (const int nValue, const Color& rColor) {
|
|
return Color(rColor.GetRed(),rColor.GetGreen(),nValue).GetColor(); }
|
|
|
|
ColorData HueColorForValue (const int nValue, const Color&) {
|
|
return Color::HSBtoRGB(nValue,100,100); }
|
|
ColorData SaturationColorForValue (const int nValue, const Color& rColor) {
|
|
USHORT nHue,nSaturation,nBrightness;
|
|
rColor.RGBtoHSB(nHue,nSaturation,nBrightness);
|
|
return Color::HSBtoRGB(nHue,nValue,nBrightness); }
|
|
ColorData BrightnessColorForValue (const int nValue, const Color& rColor) {
|
|
USHORT nHue,nSaturation,nBrightness;
|
|
rColor.RGBtoHSB(nHue,nSaturation,nBrightness);
|
|
return Color::HSBtoRGB(nHue,nSaturation,nValue); }
|
|
|
|
class AdornedSlider : public ::Window
|
|
{
|
|
public:
|
|
AdornedSlider (::Window* pContainer,
|
|
const int nLeft, const int nTop, const int nWidth, const int nHeight,
|
|
const Range& rRange,
|
|
const Link& rSliderUpdateHandler,
|
|
ColorData (*pColorProvider)(const int nValue, const Color& rColor),
|
|
Color& rColor)
|
|
: ::Window(pContainer),
|
|
mpSlider(new Slider(this)),
|
|
mnVisualizationHeight(4),
|
|
mpColorProvider(pColorProvider),
|
|
mrColor(rColor),
|
|
maValueRange(rRange)
|
|
{
|
|
SetPosSizePixel(nLeft,nTop,nWidth,nHeight);
|
|
mpSlider->SetPosSizePixel(0,0,nWidth,nHeight-mnVisualizationHeight-2);
|
|
mpSlider->SetSlideHdl(rSliderUpdateHandler);
|
|
mpSlider->SetRange(rRange);
|
|
mpSlider->Show();
|
|
|
|
Show();
|
|
}
|
|
virtual ~AdornedSlider (void) { delete mpSlider; }
|
|
virtual void Paint(const Rectangle&)
|
|
{
|
|
for (int nX=0,nWidth=GetSizePixel().Width(); nX<nWidth; ++nX)
|
|
{
|
|
const Color aColor (mpColorProvider(
|
|
maValueRange.Min() + nX * maValueRange.Len() / nWidth,
|
|
mrColor));
|
|
for (int nY=GetSizePixel().Height()-mnVisualizationHeight; nY<GetSizePixel().Height(); ++nY)
|
|
DrawPixel(Point(nX,nY),aColor);
|
|
}
|
|
}
|
|
void SetValue (const int nValue) { mpSlider->SetThumbPos(nValue); }
|
|
int GetValue (void) const { return mpSlider->GetThumbPos(); }
|
|
void InvalidateColorArea (void) { Invalidate(Rectangle(
|
|
0,GetSizePixel().Height()-mnVisualizationHeight,
|
|
GetSizePixel().Width(), mnVisualizationHeight)); }
|
|
private:
|
|
Slider* mpSlider;
|
|
const int mnVisualizationHeight;
|
|
ColorData (*mpColorProvider)(const int nValue, const Color& rColor);
|
|
Color& mrColor;
|
|
Range maValueRange;
|
|
};
|
|
|
|
class ColorControl : public DebugControl
|
|
{
|
|
public:
|
|
typedef ::boost::function<ColorData(void)> ColorGetter;
|
|
typedef ::boost::function<void(ColorData)> ColorSetter;
|
|
typedef ::boost::function<void(void)> Updater;
|
|
ColorControl (
|
|
::Window* pParent,
|
|
const char* pTitle,
|
|
const bool bHasBorder,
|
|
const Rectangle& rBoundingBox,
|
|
const ColorGetter& rGetter,
|
|
const ColorSetter& rSetter,
|
|
const Updater& rUpdater)
|
|
: maGetter(rGetter),
|
|
maSetter(rSetter),
|
|
maUpdater(rUpdater),
|
|
mpContainer(new ::Window(pParent, bHasBorder ? WB_BORDER : 0)),
|
|
mpTitle(new FixedText(mpContainer)),
|
|
maCurrentColor(255,255,255),
|
|
mpRedSlider(new AdornedSlider(mpContainer,
|
|
2, 25, rBoundingBox.GetWidth()/2-4, 15,
|
|
Range(0,255),
|
|
LINK(this, ColorControl, UpdateFromRGBColor),
|
|
RedColorForValue,
|
|
maCurrentColor)),
|
|
mpGreenSlider(new AdornedSlider(mpContainer,
|
|
2, 45, rBoundingBox.GetWidth()/2-4, 15,
|
|
Range(0,255),
|
|
LINK(this, ColorControl, UpdateFromRGBColor),
|
|
GreenColorForValue,
|
|
maCurrentColor)),
|
|
mpBlueSlider(new AdornedSlider(mpContainer,
|
|
2, 65, rBoundingBox.GetWidth()/2-4, 15,
|
|
Range(0,255),
|
|
LINK(this, ColorControl, UpdateFromRGBColor),
|
|
BlueColorForValue,
|
|
maCurrentColor)),
|
|
mpHueSlider(new AdornedSlider(mpContainer,
|
|
rBoundingBox.GetWidth()/2+2, 25, rBoundingBox.GetWidth()/2-4, 15,
|
|
Range(0,360),
|
|
LINK(this, ColorControl, UpdateFromHSBColor),
|
|
HueColorForValue,
|
|
maCurrentColor)),
|
|
mpSaturationSlider(new AdornedSlider(mpContainer,
|
|
rBoundingBox.GetWidth()/2+2, 45, rBoundingBox.GetWidth()/2-4, 15,
|
|
Range(0,100),
|
|
LINK(this, ColorControl, UpdateFromHSBColor),
|
|
SaturationColorForValue,
|
|
maCurrentColor)),
|
|
mpBrightnessSlider(new AdornedSlider(mpContainer,
|
|
rBoundingBox.GetWidth()/2+2, 65, rBoundingBox.GetWidth()/2-4, 15,
|
|
Range(0,100),
|
|
LINK(this, ColorControl, UpdateFromHSBColor),
|
|
BrightnessColorForValue,
|
|
maCurrentColor)),
|
|
mpTextValue(new FixedText(mpContainer)),
|
|
mpColorValue(new ::Window(mpContainer))
|
|
{
|
|
const double nWidth (rBoundingBox.GetWidth());
|
|
const double nLeft (0);
|
|
const double nTop (0);
|
|
const ColorData aStartColor (rGetter ? rGetter() : 0);
|
|
|
|
mpContainer->SetPosSizePixel(rBoundingBox.TopLeft(), rBoundingBox.GetSize());
|
|
mpContainer->Show();
|
|
|
|
mpTitle->SetText(::rtl::OUString::createFromAscii(pTitle));
|
|
mpTitle->SetPosSizePixel(nLeft, nTop, nWidth,20);
|
|
mpTitle->Show();
|
|
|
|
SetRgbColor(aStartColor);
|
|
SetHsbColor(aStartColor);
|
|
|
|
mpTextValue->SetText(::rtl::OUString::createFromAscii("x000000"));
|
|
mpTextValue->SetPosSizePixel(nLeft, nTop+85, 150, 20);
|
|
mpTextValue->Show();
|
|
|
|
mpColorValue->SetPosSizePixel(nLeft + 150, nTop+85, nWidth - 150, 20);
|
|
mpColorValue->SetBackground(Wallpaper(Color(aStartColor)));
|
|
mpColorValue->Show();
|
|
|
|
UpdateDisplay(aStartColor);
|
|
}
|
|
|
|
virtual ~ColorControl (void)
|
|
{
|
|
delete mpTitle;
|
|
delete mpRedSlider;
|
|
delete mpGreenSlider;
|
|
delete mpBlueSlider;
|
|
delete mpHueSlider;
|
|
delete mpSaturationSlider;
|
|
delete mpBrightnessSlider;
|
|
delete mpTextValue;
|
|
delete mpColorValue;
|
|
|
|
delete mpContainer;
|
|
}
|
|
|
|
void SetRgbColor (const ColorData aColorData)
|
|
{
|
|
maCurrentColor = Color(aColorData);
|
|
|
|
mpRedSlider->SetValue(maCurrentColor.GetRed());
|
|
mpGreenSlider->SetValue(maCurrentColor.GetGreen());
|
|
mpBlueSlider->SetValue(maCurrentColor.GetBlue());
|
|
|
|
UpdateDisplay(maCurrentColor);
|
|
}
|
|
void SetHsbColor (const ColorData aColorData)
|
|
{
|
|
maCurrentColor = Color(aColorData);
|
|
|
|
USHORT nHue, nSaturation, nBrightness;
|
|
maCurrentColor.RGBtoHSB(nHue, nSaturation, nBrightness);
|
|
mpHueSlider->SetValue(nHue);
|
|
mpSaturationSlider->SetValue(nSaturation);
|
|
mpBrightnessSlider->SetValue(nBrightness);
|
|
|
|
UpdateDisplay(maCurrentColor);
|
|
}
|
|
|
|
ColorData GetRGBColor (void) const
|
|
{
|
|
return Color(
|
|
mpRedSlider->GetValue(),
|
|
mpGreenSlider->GetValue(),
|
|
mpBlueSlider->GetValue()).GetColor();
|
|
}
|
|
|
|
ColorData GetHSBColor (void) const
|
|
{
|
|
return Color::HSBtoRGB(
|
|
mpHueSlider->GetValue(),
|
|
mpSaturationSlider->GetValue(),
|
|
mpBrightnessSlider->GetValue());
|
|
}
|
|
|
|
virtual sal_Int32 GetHeight (void)
|
|
{
|
|
return mpContainer->GetSizePixel().Height();
|
|
}
|
|
|
|
DECL_LINK(UpdateFromRGBColor, void*);
|
|
DECL_LINK(UpdateFromHSBColor, void*);
|
|
|
|
private:
|
|
ColorGetter maGetter;
|
|
ColorSetter maSetter;
|
|
Updater maUpdater;
|
|
::Window* mpContainer;
|
|
FixedText* mpTitle;
|
|
Color maCurrentColor;
|
|
AdornedSlider* mpRedSlider;
|
|
AdornedSlider* mpGreenSlider;
|
|
AdornedSlider* mpBlueSlider;
|
|
AdornedSlider* mpHueSlider;
|
|
AdornedSlider* mpSaturationSlider;
|
|
AdornedSlider* mpBrightnessSlider;
|
|
FixedText* mpTextValue;
|
|
::Window* mpColorValue;
|
|
|
|
void UpdateDisplay (const Color aColor)
|
|
{
|
|
const int nRed (aColor.GetRed());
|
|
const int nGreen (aColor.GetGreen());
|
|
const int nBlue (aColor.GetBlue());
|
|
|
|
mpColorValue->SetBackground(Wallpaper(aColor));
|
|
mpColorValue->Invalidate();
|
|
|
|
mpRedSlider->Invalidate();
|
|
mpGreenSlider->Invalidate();
|
|
mpBlueSlider->Invalidate();
|
|
mpSaturationSlider->Invalidate();
|
|
mpBrightnessSlider->Invalidate();
|
|
|
|
const int nMaxLength(30);
|
|
char aBuffer[nMaxLength];
|
|
USHORT nHue (0);
|
|
USHORT nSaturation (0);
|
|
USHORT nBrightness (0);
|
|
aColor.RGBtoHSB(nHue, nSaturation, nBrightness);
|
|
snprintf(aBuffer, nMaxLength, "r%02Xg%02Xb%02X h%ds%db%d",
|
|
nRed,nGreen,nBlue, nHue,nSaturation,nBrightness);
|
|
mpTextValue->SetText(::rtl::OUString::createFromAscii(aBuffer));
|
|
}
|
|
|
|
};
|
|
|
|
IMPL_LINK(ColorControl, UpdateFromRGBColor, void*, EMPTYARG)
|
|
{
|
|
const ColorData aColor (GetRGBColor());
|
|
SetHsbColor(aColor);
|
|
UpdateDisplay(Color(aColor));
|
|
if (maSetter)
|
|
{
|
|
maSetter(aColor);
|
|
if (maUpdater)
|
|
maUpdater();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
IMPL_LINK(ColorControl, UpdateFromHSBColor, void*, EMPTYARG)
|
|
{
|
|
const ColorData aColor (GetHSBColor());
|
|
SetRgbColor(aColor);
|
|
UpdateDisplay(Color(aColor));
|
|
if (maSetter)
|
|
{
|
|
maSetter(aColor);
|
|
if (maUpdater)
|
|
maUpdater();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
//===== GradientControl =======================================================
|
|
|
|
class GradientControl : public DebugControl
|
|
{
|
|
public:
|
|
typedef ::boost::function<void(void)> Updater;
|
|
|
|
GradientControl (
|
|
::Window* pParent,
|
|
const char* pTitle,
|
|
const bool bHasBorder,
|
|
const Theme::GradientColorType eType,
|
|
const Rectangle& rBoundingBox,
|
|
SlideSorter& rSlideSorter,
|
|
const Updater& rUpdater = Updater())
|
|
: mpTheme(rSlideSorter.GetTheme()),
|
|
mrSlideSorter(rSlideSorter),
|
|
maUpdater(rUpdater),
|
|
meType(eType),
|
|
mpContainer(new ::Window(pParent, bHasBorder ? WB_BORDER : 0)),
|
|
mpColorControl(new ColorControl(mpContainer, pTitle, false,
|
|
Rectangle(0,0, rBoundingBox.GetWidth()-4, 115),
|
|
::boost::bind(&Theme::GetGradientColor, mpTheme,
|
|
::boost::bind(&GradientControl::GetType, this), Theme::Base),
|
|
::boost::bind(&GradientControl::SetBaseColor, this, _1),
|
|
::boost::bind(&GradientControl::Update, this, (void*)0))),
|
|
mpSaturationSlider(new Slider(mpContainer)),
|
|
mpSaturationText(new FixedText(mpContainer)),
|
|
mpBrightnessSlider(new Slider(mpContainer)),
|
|
mpBrightnessText(new FixedText(mpContainer)),
|
|
mpHGBColor(new ::Window(mpContainer)),
|
|
mpFillOffset1Slider(new Slider(mpContainer)),
|
|
mpFillOffset1Text(new FixedText(mpContainer)),
|
|
mpFillOffset1Color(new ::Window(mpContainer)),
|
|
mpFillOffset2Slider(new Slider(mpContainer)),
|
|
mpFillOffset2Text(new FixedText(mpContainer)),
|
|
mpFillOffset2Color(new ::Window(mpContainer)),
|
|
mpBorderOffset1Slider(new Slider(mpContainer)),
|
|
mpBorderOffset1Text(new FixedText(mpContainer)),
|
|
mpBorderOffset1Color(new ::Window(mpContainer)),
|
|
mpBorderOffset2Slider(new Slider(mpContainer)),
|
|
mpBorderOffset2Text(new FixedText(mpContainer)),
|
|
mpBorderOffset2Color(new ::Window(mpContainer))
|
|
{
|
|
const double nWidth (rBoundingBox.GetWidth());
|
|
::boost::shared_ptr<Theme> pTheme (mrSlideSorter.GetTheme());
|
|
|
|
mpContainer->SetPosSizePixel(rBoundingBox.TopLeft(), rBoundingBox.GetSize());
|
|
mpContainer->Show();
|
|
|
|
mpSaturationSlider->SetPosSizePixel(10,115,nWidth/2,10);
|
|
mpSaturationSlider->SetRange(Range(0,+100));
|
|
mpSaturationSlider->SetThumbPos(mpTheme->GetGradientSaturationOverride(eType));
|
|
mpSaturationSlider->SetSlideHdl(LINK(this, GradientControl, SaturationSliderUpdate));
|
|
mpSaturationSlider->Show();
|
|
mpSaturationText->SetPosSizePixel(nWidth/2+15,115,nWidth/2,15);
|
|
mpSaturationText->Show();
|
|
|
|
mpBrightnessSlider->SetPosSizePixel(10,130,nWidth/2,10);
|
|
mpBrightnessSlider->SetRange(Range(0,+100));
|
|
mpBrightnessSlider->SetThumbPos(mpTheme->GetGradientBrightnessOverride(eType));
|
|
mpBrightnessSlider->SetSlideHdl(LINK(this, GradientControl, BrightnessSliderUpdate));
|
|
mpBrightnessSlider->Show();
|
|
mpBrightnessText->SetPosSizePixel(nWidth/2+15,130,nWidth/2,15);
|
|
mpBrightnessText->Show();
|
|
|
|
mpHGBColor->SetPosSizePixel(nWidth*3/4, 120, nWidth/4,20);
|
|
mpHGBColor->Show();
|
|
|
|
Initialize(mpFillOffset1Slider, mpFillOffset1Text, mpFillOffset1Color,
|
|
mpTheme->GetGradientOffset(eType, Theme::Fill1), 145, nWidth);
|
|
Initialize(mpFillOffset2Slider, mpFillOffset2Text, mpFillOffset2Color,
|
|
mpTheme->GetGradientOffset(eType, Theme::Fill2), 165, nWidth);
|
|
Initialize(mpBorderOffset1Slider, mpBorderOffset1Text, mpBorderOffset1Color,
|
|
mpTheme->GetGradientOffset(eType, Theme::Border1), 185, nWidth);
|
|
Initialize(mpBorderOffset2Slider, mpBorderOffset2Text, mpBorderOffset2Color,
|
|
mpTheme->GetGradientOffset(eType, Theme::Border2), 205, nWidth);
|
|
|
|
Update(0);
|
|
}
|
|
|
|
virtual ~GradientControl (void)
|
|
{
|
|
delete mpColorControl;
|
|
delete mpFillOffset1Slider;
|
|
delete mpFillOffset1Text;
|
|
delete mpFillOffset1Color;
|
|
delete mpFillOffset2Slider;
|
|
delete mpFillOffset2Text;
|
|
delete mpFillOffset2Color;
|
|
delete mpBorderOffset1Slider;
|
|
delete mpBorderOffset1Text;
|
|
delete mpBorderOffset1Color;
|
|
delete mpBorderOffset2Slider;
|
|
delete mpBorderOffset2Text;
|
|
delete mpBorderOffset2Color;
|
|
|
|
delete mpSaturationSlider;
|
|
delete mpSaturationText;
|
|
delete mpBrightnessSlider;
|
|
delete mpBrightnessText;
|
|
delete mpHGBColor;
|
|
|
|
delete mpContainer;
|
|
}
|
|
|
|
void Initialize (
|
|
Slider* pSlider,
|
|
FixedText* pText,
|
|
::Window* pWindow,
|
|
const sal_Int32 nOffset,
|
|
const sal_Int32 nY,
|
|
const sal_Int32 nWidth)
|
|
{
|
|
pSlider->SetPosSizePixel(10,nY,nWidth/2,15);
|
|
pSlider->Show();
|
|
pSlider->SetRange(Range(-100,+100));
|
|
pSlider->SetThumbPos(nOffset);
|
|
pSlider->SetSlideHdl(LINK(this, GradientControl, Update));
|
|
|
|
pText->SetPosSizePixel(nWidth/2+15, nY, nWidth/2-60, 15);
|
|
pText->Show();
|
|
|
|
pWindow->SetPosSizePixel(nWidth-40, nY, 40, 15);
|
|
pWindow->Show();
|
|
}
|
|
|
|
void SetBaseColor (const ColorData)
|
|
{
|
|
// mpColorControl->SetRgbColor(aColor);
|
|
// mpColorControl->SetHsbColor(aColor);
|
|
}
|
|
|
|
::Window* GetContainer (void)
|
|
{
|
|
return mpContainer;
|
|
}
|
|
|
|
Theme::GradientColorType GetType (void) const
|
|
{
|
|
return meType;
|
|
}
|
|
|
|
void SetType (const Theme::GradientColorType eType)
|
|
{
|
|
meType = eType;
|
|
mpColorControl->SetRgbColor(mpTheme->GetGradientColor(meType, Theme::Base));
|
|
mpColorControl->SetHsbColor(mpTheme->GetGradientColor(meType, Theme::Base));
|
|
mpFillOffset1Slider->SetThumbPos(mpTheme->GetGradientOffset(meType, Theme::Fill1));
|
|
mpFillOffset2Slider->SetThumbPos(mpTheme->GetGradientOffset(meType, Theme::Fill2));
|
|
mpBorderOffset1Slider->SetThumbPos(mpTheme->GetGradientOffset(meType, Theme::Border1));
|
|
mpBorderOffset2Slider->SetThumbPos(mpTheme->GetGradientOffset(meType, Theme::Border2));
|
|
UpdateDisplay();
|
|
}
|
|
|
|
virtual sal_Int32 GetHeight (void)
|
|
{
|
|
return mpContainer->GetSizePixel().Height();
|
|
}
|
|
|
|
private:
|
|
::boost::shared_ptr<view::Theme> mpTheme;
|
|
SlideSorter& mrSlideSorter;
|
|
Updater maUpdater;
|
|
Theme::GradientColorType meType;
|
|
::Window* mpContainer;
|
|
ColorControl* mpColorControl;
|
|
Slider* mpSaturationSlider;
|
|
FixedText* mpSaturationText;
|
|
Slider* mpBrightnessSlider;
|
|
FixedText* mpBrightnessText;
|
|
::Window* mpHGBColor;
|
|
Slider* mpFillOffset1Slider;
|
|
FixedText* mpFillOffset1Text;
|
|
::Window* mpFillOffset1Color;
|
|
sal_Int32 mnFillOffset1;
|
|
Slider* mpFillOffset2Slider;
|
|
FixedText* mpFillOffset2Text;
|
|
::Window* mpFillOffset2Color;
|
|
sal_Int32 mnFillOffset2;
|
|
Slider* mpBorderOffset1Slider;
|
|
FixedText* mpBorderOffset1Text;
|
|
::Window* mpBorderOffset1Color;
|
|
sal_Int32 mnBorderOffset1;
|
|
Slider* mpBorderOffset2Slider;
|
|
FixedText* mpBorderOffset2Text;
|
|
::Window* mpBorderOffset2Color;
|
|
sal_Int32 mnBorderOffset2;
|
|
|
|
DECL_LINK(Update, void*);
|
|
DECL_LINK(SaturationSliderUpdate, void*);
|
|
DECL_LINK(BrightnessSliderUpdate, void*);
|
|
|
|
void UpdateDisplay (void)
|
|
{
|
|
const sal_Int32 nFillOffset1 (mpFillOffset1Slider->GetThumbPos());
|
|
const sal_Int32 nFillOffset2 (mpFillOffset2Slider->GetThumbPos());
|
|
const sal_Int32 nBorderOffset1 (mpBorderOffset1Slider->GetThumbPos());
|
|
const sal_Int32 nBorderOffset2 (mpBorderOffset2Slider->GetThumbPos());
|
|
|
|
mpSaturationText->SetText(
|
|
::rtl::OUString::createFromAscii("S=")
|
|
+::rtl::OUString::valueOf(mpSaturationSlider->GetThumbPos()));
|
|
mpBrightnessText->SetText(
|
|
::rtl::OUString::createFromAscii("B=")
|
|
+::rtl::OUString::valueOf(mpBrightnessSlider->GetThumbPos()));
|
|
|
|
Color aColor (mpTheme->GetGradientColor(meType, Theme::Base));
|
|
USHORT nHue (0);
|
|
USHORT nSaturation (0);
|
|
USHORT nBrightness (0);
|
|
aColor.RGBtoHSB(nHue,nSaturation,nBrightness);
|
|
nSaturation = mpTheme->GetGradientSaturationOverride(meType);
|
|
nBrightness = mpTheme->GetGradientBrightnessOverride(meType);
|
|
mpHGBColor->SetBackground(Wallpaper(Color(Color::HSBtoRGB(nHue,nSaturation,nBrightness))));
|
|
mpHGBColor->Invalidate();
|
|
|
|
mpFillOffset1Text->SetText(::rtl::OUString::valueOf(nFillOffset1));
|
|
mpFillOffset1Color->SetBackground(Wallpaper(
|
|
mpTheme->GetGradientColor(meType, Theme::Fill1)));
|
|
mpFillOffset1Color->Invalidate();
|
|
|
|
mpFillOffset2Text->SetText(::rtl::OUString::valueOf(nFillOffset2));
|
|
mpFillOffset2Color->SetBackground(Wallpaper(
|
|
mpTheme->GetGradientColor(meType, Theme::Fill2)));
|
|
mpFillOffset2Color->Invalidate();
|
|
|
|
mpBorderOffset1Text->SetText(::rtl::OUString::valueOf(nBorderOffset1));
|
|
mpBorderOffset1Color->SetBackground(Wallpaper(
|
|
mpTheme->GetGradientColor(meType, Theme::Border1)));
|
|
mpBorderOffset1Color->Invalidate();
|
|
|
|
mpBorderOffset2Text->SetText(::rtl::OUString::valueOf(nBorderOffset2));
|
|
mpBorderOffset2Color->SetBackground(Wallpaper(
|
|
mpTheme->GetGradientColor(meType, Theme::Border2)));
|
|
mpBorderOffset2Color->Invalidate();
|
|
|
|
mrSlideSorter.GetView().GetPageObjectPainter()->NotifyResize(true);
|
|
mrSlideSorter.GetView().RequestRepaint();
|
|
}
|
|
};
|
|
|
|
|
|
IMPL_LINK(GradientControl, Update, void*, EMPTYARG)
|
|
{
|
|
mpTheme->SetGradient(meType,
|
|
mpColorControl->GetRGBColor(),
|
|
mpSaturationSlider->GetThumbPos(),
|
|
mpBrightnessSlider->GetThumbPos(),
|
|
mpFillOffset1Slider->GetThumbPos(),
|
|
mpFillOffset2Slider->GetThumbPos(),
|
|
mpBorderOffset1Slider->GetThumbPos(),
|
|
mpBorderOffset2Slider->GetThumbPos());
|
|
if (maUpdater)
|
|
maUpdater();
|
|
UpdateDisplay();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
IMPL_LINK(GradientControl, SaturationSliderUpdate, void*, EMPTYARG)
|
|
{
|
|
mpTheme->SetGradientSaturationOverride(meType, mpSaturationSlider->GetThumbPos());
|
|
UpdateDisplay();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
IMPL_LINK(GradientControl, BrightnessSliderUpdate, void*, EMPTYARG)
|
|
{
|
|
mpTheme->SetGradientBrightnessOverride(meType, mpBrightnessSlider->GetThumbPos());
|
|
UpdateDisplay();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
//===== SliderControl =========================================================
|
|
|
|
class SliderControl : public DebugControl
|
|
{
|
|
public:
|
|
typedef ::boost::function<sal_Int32(void)> ValueGetter;
|
|
typedef ::boost::function<void(sal_Int32)> ValueSetter;
|
|
typedef ::boost::function<void(void)> Updater;
|
|
SliderControl (
|
|
::Window* pParent,
|
|
const char* pTitle,
|
|
const Rectangle& rBoundingBox,
|
|
const Range aRange,
|
|
const ValueGetter& rGetter,
|
|
const ValueSetter& rSetter,
|
|
const Updater& rUpdater)
|
|
: maGetter(rGetter),
|
|
maSetter(rSetter),
|
|
maUpdater(rUpdater),
|
|
mpContainer(new ::Window(pParent, WB_BORDER)),
|
|
mpTitle(new FixedText(mpContainer)),
|
|
mpSlider(new Slider(mpContainer)),
|
|
mpTextValue(new FixedText(mpContainer))
|
|
{
|
|
const double nWidth (rBoundingBox.GetWidth());
|
|
const double nLeft (0);
|
|
const double nTop (0);
|
|
const sal_Int32 nStartValue (maGetter ? maGetter() : 0);
|
|
|
|
mpContainer->SetPosSizePixel(rBoundingBox.TopLeft(), rBoundingBox.GetSize());
|
|
mpContainer->Show();
|
|
|
|
mpTitle->SetText(::rtl::OUString::createFromAscii(pTitle));
|
|
mpTitle->SetPosSizePixel(nLeft, nTop, nWidth,20);
|
|
mpTitle->Show();
|
|
|
|
mpSlider->SetPosSizePixel(nLeft, nTop+25, nWidth, 10);
|
|
mpSlider->SetRange(aRange);
|
|
mpSlider->SetSlideHdl(LINK(this, SliderControl, UpdateValue));
|
|
mpSlider->SetThumbPos(nStartValue);
|
|
mpSlider->Show();
|
|
|
|
mpTextValue->SetText(::rtl::OUString::valueOf(nStartValue));
|
|
mpTextValue->SetPosSizePixel(nLeft, nTop+40, 150, 20);
|
|
mpTextValue->Show();
|
|
|
|
UpdateValue(0);
|
|
}
|
|
|
|
virtual ~SliderControl (void)
|
|
{
|
|
delete mpTitle;
|
|
delete mpSlider;
|
|
delete mpTextValue;
|
|
delete mpContainer;
|
|
}
|
|
|
|
virtual sal_Int32 GetHeight (void)
|
|
{
|
|
return mpContainer->GetSizePixel().Height();
|
|
}
|
|
|
|
private:
|
|
ValueGetter maGetter;
|
|
ValueSetter maSetter;
|
|
Updater maUpdater;
|
|
::Window* mpContainer;
|
|
FixedText* mpTitle;
|
|
Slider* mpSlider;
|
|
FixedText* mpTextValue;
|
|
|
|
DECL_LINK(UpdateValue, void*);
|
|
};
|
|
|
|
IMPL_LINK(SliderControl, UpdateValue, void*, EMPTYARG)
|
|
{
|
|
const sal_Int32 nValue (mpSlider->GetThumbPos());
|
|
|
|
const sal_Int32 nMaxLength (30);
|
|
char aBuffer[nMaxLength];
|
|
snprintf(aBuffer, nMaxLength, "%ld %f", nValue, nValue/255.0);
|
|
mpTextValue->SetText(::rtl::OUString::createFromAscii(aBuffer));
|
|
|
|
if (maSetter)
|
|
{
|
|
maSetter(nValue);
|
|
if (maUpdater)
|
|
maUpdater();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
//===== ChoiceControl =========================================================
|
|
|
|
class ChoiceControl : public DebugControl
|
|
{
|
|
public:
|
|
typedef ::boost::function<Theme::GradientColorType(void)> ValueGetter;
|
|
typedef ::boost::function<void(Theme::GradientColorType)> ValueSetter;
|
|
ChoiceControl (
|
|
::Window* pParent,
|
|
const Rectangle& rBoundingBox,
|
|
const char** aValues,
|
|
const int nValueCount,
|
|
GradientControl* pSubControl,
|
|
const ValueGetter& rGetter,
|
|
const ValueSetter& rSetter)
|
|
: maValues(),
|
|
maGetter(rGetter),
|
|
maSetter(rSetter),
|
|
mpContainer(new ::Window(pParent, WB_BORDER)),
|
|
mpComboBox(new ComboBox(mpContainer, WB_DROPDOWN)),
|
|
mpSubControl(pSubControl)
|
|
{
|
|
const double nWidth (rBoundingBox.GetWidth());
|
|
const double nLeft (0);
|
|
const double nTop (0);
|
|
|
|
mpContainer->SetPosSizePixel(rBoundingBox.TopLeft(), rBoundingBox.GetSize());
|
|
mpContainer->Show();
|
|
|
|
mpComboBox->SetPosSizePixel(nLeft, nTop, nWidth-5, 25);
|
|
mpComboBox->ToggleDropDown();
|
|
mpComboBox->SetSelectHdl(LINK(this, ChoiceControl, UpdateValue));
|
|
mpComboBox->SetDoubleClickHdl(LINK(this, ChoiceControl, UpdateValue));
|
|
mpComboBox->SetDropDownLineCount(6);
|
|
for (int nIndex=0; nIndex<nValueCount; ++nIndex)
|
|
{
|
|
const USHORT nId (
|
|
mpComboBox->InsertEntry(::rtl::OUString::createFromAscii(aValues[nIndex])));
|
|
maValues[nId] = nIndex;
|
|
}
|
|
mpComboBox->SelectEntryPos(1);
|
|
mpComboBox->Show();
|
|
|
|
mpSubControl->GetContainer()->SetParent(mpContainer);
|
|
mpSubControl->GetContainer()->SetPosSizePixel(
|
|
nLeft, nTop+25, nWidth, rBoundingBox.GetHeight()-25);
|
|
|
|
UpdateValue(0);
|
|
}
|
|
|
|
virtual ~ChoiceControl (void)
|
|
{
|
|
delete mpComboBox;
|
|
delete mpSubControl;
|
|
delete mpContainer;
|
|
}
|
|
|
|
virtual sal_Int32 GetHeight (void)
|
|
{
|
|
return mpContainer->GetSizePixel().Height();
|
|
}
|
|
|
|
private:
|
|
::std::map<USHORT, int> maValues;
|
|
ValueGetter maGetter;
|
|
ValueSetter maSetter;
|
|
::Window* mpContainer;
|
|
ComboBox* mpComboBox;
|
|
GradientControl* mpSubControl;
|
|
|
|
DECL_LINK(UpdateValue, void*);
|
|
};
|
|
|
|
IMPL_LINK(ChoiceControl, UpdateValue, void*, EMPTYARG)
|
|
{
|
|
USHORT nId (mpComboBox->GetSelectEntryPos());
|
|
const sal_Int32 nIndex (maValues[nId]);
|
|
const Theme::GradientColorType nValue ((Theme::GradientColorType)nIndex);
|
|
|
|
if (maSetter)
|
|
maSetter(nValue);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
//===== BoolControl ===========================================================
|
|
|
|
class BoolControl : public DebugControl
|
|
{
|
|
public:
|
|
typedef ::boost::function<sal_Int32(void)> ValueGetter;
|
|
typedef ::boost::function<void(sal_Int32)> ValueSetter;
|
|
typedef ::boost::function<void(void)> Updater;
|
|
BoolControl (
|
|
::Window* pParent,
|
|
const char* pTitle,
|
|
const Rectangle& rBoundingBox,
|
|
const sal_Int32 nOnValue,
|
|
const sal_Int32 nOffValue,
|
|
const ValueGetter& rGetter,
|
|
const ValueSetter& rSetter,
|
|
const Updater& rUpdater)
|
|
: maGetter(rGetter),
|
|
maSetter(rSetter),
|
|
maUpdater(rUpdater),
|
|
mpContainer(new ::Window(pParent, WB_BORDER)),
|
|
mpButton(new CheckBox(mpContainer)),
|
|
mnOnValue(nOnValue),
|
|
mnOffValue(nOffValue)
|
|
{
|
|
const double nWidth (rBoundingBox.GetWidth());
|
|
const double nLeft (0);
|
|
const double nTop (0);
|
|
|
|
mpContainer->SetPosSizePixel(rBoundingBox.TopLeft(), rBoundingBox.GetSize());
|
|
mpContainer->Show();
|
|
|
|
mpButton->SetText(::rtl::OUString::createFromAscii(pTitle));
|
|
mpButton->SetPosSizePixel(nLeft, nTop, nWidth,20);
|
|
mpButton->Check(maGetter() == mnOnValue ? TRUE : FALSE);
|
|
mpButton->SetToggleHdl(LINK(this, BoolControl, UpdateValue));
|
|
mpButton->Show();
|
|
}
|
|
|
|
virtual ~BoolControl (void)
|
|
{
|
|
delete mpButton;
|
|
delete mpContainer;
|
|
}
|
|
|
|
virtual sal_Int32 GetHeight (void)
|
|
{
|
|
return mpContainer->GetSizePixel().Height();
|
|
}
|
|
|
|
private:
|
|
ValueGetter maGetter;
|
|
ValueSetter maSetter;
|
|
Updater maUpdater;
|
|
::Window* mpContainer;
|
|
CheckBox* mpButton;
|
|
const sal_Int32 mnOnValue;
|
|
const sal_Int32 mnOffValue;
|
|
|
|
DECL_LINK(UpdateValue, void*);
|
|
};
|
|
|
|
IMPL_LINK(BoolControl, UpdateValue, void*, EMPTYARG)
|
|
{
|
|
const bool bValue (mpButton->IsChecked());
|
|
|
|
if (maSetter)
|
|
{
|
|
maSetter(bValue ? mnOnValue : mnOffValue);
|
|
if (maUpdater)
|
|
maUpdater();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
//===== SlideSorterDebugDialog ================================================
|
|
|
|
SlideSorterDebugDialog* SlideSorterDebugDialog::CreateDebugDialog (SlideSorter& rSlideSorter)
|
|
{
|
|
static const char* pText = getenv("SD_SHOW_DEBUG_DIALOG");
|
|
if (pText!=NULL && pText[0]!='0')
|
|
return new SlideSorterDebugDialog(rSlideSorter);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
|
|
SlideSorterDebugDialog::SlideSorterDebugDialog (SlideSorter& rSlideSorter)
|
|
: mpTopLevelWindow(new WorkWindow(NULL, WB_STDWORK)),
|
|
maControls()
|
|
{
|
|
::boost::shared_ptr<view::Theme> pTheme(rSlideSorter.GetTheme());
|
|
|
|
const sal_Int32 nGap (10);
|
|
const sal_Int32 nWidth (400);
|
|
sal_Int32 nY (nGap);
|
|
|
|
maControls.push_back(new SliderControl(
|
|
mpTopLevelWindow,
|
|
"Button Fade In Delay (ms)",
|
|
Rectangle(10,nY,nWidth,nY+60),
|
|
Range(0,1000),
|
|
::boost::bind(&view::Theme::GetIntegerValue, pTheme, view::Theme::Integer_ButtonFadeInDelay),
|
|
::boost::bind(&view::Theme::SetIntegerValue, pTheme, view::Theme::Integer_ButtonFadeInDelay,_1),
|
|
SliderControl::Updater()));
|
|
nY += maControls.back()->GetHeight() + nGap;
|
|
|
|
maControls.push_back(new SliderControl(
|
|
mpTopLevelWindow,
|
|
"Button Fade In Duration (ms)",
|
|
Rectangle(10,nY,nWidth,nY+60),
|
|
Range(0,2000),
|
|
::boost::bind(&view::Theme::GetIntegerValue, pTheme, view::Theme::Integer_ButtonFadeInDuration),
|
|
::boost::bind(&view::Theme::SetIntegerValue, pTheme, view::Theme::Integer_ButtonFadeInDuration, _1),
|
|
SliderControl::Updater()));
|
|
nY += maControls.back()->GetHeight() + nGap;
|
|
|
|
maControls.push_back(new SliderControl(
|
|
mpTopLevelWindow,
|
|
"Button Fade Out Delay (ms)",
|
|
Rectangle(10,nY,nWidth,nY+60),
|
|
Range(0,1000),
|
|
::boost::bind(&view::Theme::GetIntegerValue, pTheme, view::Theme::Integer_ButtonFadeOutDelay),
|
|
::boost::bind(&view::Theme::SetIntegerValue, pTheme, view::Theme::Integer_ButtonFadeOutDelay,_1),
|
|
SliderControl::Updater()));
|
|
nY += maControls.back()->GetHeight() + nGap;
|
|
|
|
maControls.push_back(new SliderControl(
|
|
mpTopLevelWindow,
|
|
"Button Fade Out Duration (ms)",
|
|
Rectangle(10,nY,nWidth,nY+60),
|
|
Range(0,2000),
|
|
::boost::bind(&view::Theme::GetIntegerValue, pTheme, view::Theme::Integer_ButtonFadeOutDuration),
|
|
::boost::bind(&view::Theme::SetIntegerValue, pTheme, view::Theme::Integer_ButtonFadeOutDuration, _1),
|
|
SliderControl::Updater()));
|
|
nY += maControls.back()->GetHeight() + nGap;
|
|
|
|
GradientControl* pControl = new GradientControl(
|
|
mpTopLevelWindow,
|
|
"Base Color:",
|
|
false,
|
|
Theme::Gradient_SelectedPage,
|
|
Rectangle(10,nY,nWidth-6,520),
|
|
rSlideSorter);
|
|
const char* aValues[] = {
|
|
"Normal",
|
|
"Selected",
|
|
"Selected & Focused",
|
|
"MouseOver",
|
|
"MouseOver & Selected & FocusedPage",
|
|
"FocusedPage"
|
|
};
|
|
maControls.push_back(new ChoiceControl(
|
|
mpTopLevelWindow,
|
|
Rectangle(10,nY,nWidth,nY+250),
|
|
aValues,
|
|
6,
|
|
pControl,
|
|
::boost::bind(&GradientControl::GetType, pControl),
|
|
::boost::bind(&GradientControl::SetType, pControl, _1)));
|
|
nY += maControls.back()->GetHeight() + nGap;
|
|
|
|
maControls.push_back(new TextButton(
|
|
mpTopLevelWindow,
|
|
"Close",
|
|
Rectangle(195,nY,100,nY+25),
|
|
::boost::bind(&WorkWindow::Close, mpTopLevelWindow)));
|
|
nY += maControls.back()->GetHeight() + nGap;
|
|
|
|
mpTopLevelWindow->SetSizePixel(Size(nWidth+10,nY));
|
|
mpTopLevelWindow->Show(true);
|
|
}
|
|
|
|
|
|
|
|
|
|
SlideSorterDebugDialog::~SlideSorterDebugDialog (void)
|
|
{
|
|
for (::std::vector<DebugControl*>::const_iterator
|
|
iControl(maControls.begin()),
|
|
iEnd(maControls.end());
|
|
iControl!=iEnd;
|
|
++iControl)
|
|
{
|
|
delete *iControl;
|
|
}
|
|
delete mpTopLevelWindow;
|
|
}
|
|
|
|
|
|
|
|
|
|
} } // end of namespace ::sd::slidesorter
|