Beispiel #1
0
 GravatarApp(const WEnvironment& env):
     WApplication(env) {
     GravatarImage* gravatar = new GravatarImage("*****@*****.**", root());
     new WBreak(root());
     WLineEdit* email = new WLineEdit(root());
     email->changed().connect(boost::bind(set_email, gravatar, email));
     email->setText("*****@*****.**");
     new WBreak(root());
     WSlider* size = new WSlider(root());
     size->setRange(1, 512);
     size->setValue(80);
     size->valueChanged().connect(boost::bind(set_size, gravatar, size));
     new WBreak(root());
     WButtonGroup* builtin = new WButtonGroup(this);
     builtin->addButton(new WRadioButton("default", root()),
                        GravatarImage::DEFAULT);
     builtin->addButton(new WRadioButton("404", root()),
                        GravatarImage::RETURN_404);
     builtin->addButton(new WRadioButton("mm", root()),
                        GravatarImage::MM);
     builtin->addButton(new WRadioButton("identicon", root()),
                        GravatarImage::IDENTICON);
     builtin->addButton(new WRadioButton("monsterid", root()),
                        GravatarImage::MONSTERID);
     builtin->addButton(new WRadioButton("wavatar", root()),
                        GravatarImage::WAVATAR);
     builtin->addButton(new WRadioButton("retro", root()),
                        GravatarImage::RETRO);
     builtin->addButton(new WRadioButton("custom url", root()),
                        9000);
     WLineEdit* custom_url = new WLineEdit(root());
     custom_url->setText("https://www.google.com/favicon.ico");
     builtin->setCheckedButton(builtin->button(GravatarImage::DEFAULT));
     builtin->checkedChanged().connect(boost::bind(set_default,
                                       gravatar, builtin, custom_url));
     new WBreak(root());
     WButtonGroup* rating = new WButtonGroup(this);
     rating->addButton(new WRadioButton("G", root()), GravatarImage::G);
     rating->addButton(new WRadioButton("PG", root()), GravatarImage::PG);
     rating->addButton(new WRadioButton("R", root()), GravatarImage::R);
     rating->addButton(new WRadioButton("X", root()), GravatarImage::X);
     rating->setCheckedButton(rating->button(GravatarImage::G));
     rating->checkedChanged().connect(boost::bind(set_rating,
                                      gravatar, rating));
     new WBreak(root());
     WCheckBox* fd = new WCheckBox("Force default", root());
     fd->checked().connect(boost::bind(&GravatarImage::set_force_default,
                                       gravatar, true));
     fd->unChecked().connect(boost::bind(&GravatarImage::set_force_default,
                                         gravatar, false));
     new WBreak(root());
     WCheckBox* sr = new WCheckBox("Use https", root());
     sr->setTristate();
     sr->setCheckState(PartiallyChecked);
     sr->checked().connect(boost::bind(&GravatarImage::set_secure_requests,
                                       gravatar, GravatarImage::ALWAYS));
     sr->unChecked().connect(boost::bind(&GravatarImage::set_secure_requests,
                                         gravatar, GravatarImage::NEVER));
 }
Beispiel #2
0
WWidget *FormWidgets::wCheckBox()
{
  WContainerWidget *result = new WContainerWidget();

  topic("WCheckBox", result);
  addText(tr("formwidgets-WCheckBox"), result);
  WCheckBox *cb = new WCheckBox("Check me!", result);
  cb->setChecked(true);
  ed_->showSignal(cb->checked(), "'Check me!' checked");
  ed_->showSignal(cb->unChecked(), "'Check me!' unchecked");
  new WBreak(result);
  cb = new WCheckBox("Check me too!", result);
  ed_->showSignal(cb->checked(), "'Check me too!' checked");
  new WBreak(result);
  cb = new WCheckBox("Check me, I'm tristate!", result);
  cb->setTristate();
  cb->setCheckState(PartiallyChecked);
  ed_->showSignal(cb->checked(), "'Check me, I'm tristate!' checked");

  return result;
}
Beispiel #3
0
Datei: Tabs.C Projekt: DTidd/wt
ChartSettings::ChartSettings(WCartesian3DChart *chart,
			     WContainerWidget * parent)
  : WContainerWidget(parent),
    chart_(chart)
{
  WTemplate* template_ = new WTemplate(Wt::WString::tr("chartconfig-template"), this);

  WCheckBox *autoRangeX_ = new WCheckBox(this);
  template_->bindWidget("xAuto", autoRangeX_);
  autoRangeX_->setCheckState(Wt::Checked);
  chart_->initLayout();
  WLineEdit *xMin_ = new WLineEdit
    (Wt::asString(chart_->axis(XAxis_3D).minimum()), this);
  template_->bindWidget("xAxisMin", xMin_);
  xMin_->setValidator(new Wt::WDoubleValidator(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max()));
  xMin_->setEnabled(false);
  WLineEdit *xMax_ = new WLineEdit
    (Wt::asString(chart_->axis(XAxis_3D).maximum()), this);
  template_->bindWidget("xAxisMax", xMax_);
  xMax_->setValidator(new Wt::WDoubleValidator(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max()));
  xMax_->setEnabled(false);

  WCheckBox *autoRangeY_ = new WCheckBox(this);
  template_->bindWidget("yAuto", autoRangeY_);
  autoRangeY_->setCheckState(Wt::Checked);
  WLineEdit *yMin_ = new WLineEdit
    (Wt::asString(chart_->axis(YAxis_3D).minimum()), this);
  template_->bindWidget("yAxisMin", yMin_);
  yMin_->setValidator(new Wt::WDoubleValidator(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max()));
  yMin_->setEnabled(false);
  WLineEdit *yMax_ = new WLineEdit
    (Wt::asString(chart_->axis(YAxis_3D).maximum()), this);
  template_->bindWidget("yAxisMax", yMax_);
  yMax_->setValidator(new Wt::WDoubleValidator(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max()));
  yMax_->setEnabled(false);

  WCheckBox *autoRangeZ_ = new WCheckBox(this);
  template_->bindWidget("zAuto", autoRangeZ_);
  autoRangeZ_->setCheckState(Wt::Checked);
  WLineEdit *zMin_ = new WLineEdit
    (Wt::asString(chart_->axis(ZAxis_3D).minimum()), this);
  template_->bindWidget("zAxisMin", zMin_);
  zMin_->setValidator(new Wt::WDoubleValidator(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max()));
  zMin_->setEnabled(false);
  WLineEdit *zMax_ = new WLineEdit
    (Wt::asString(chart_->axis(ZAxis_3D).maximum()), this);
  template_->bindWidget("zAxisMax", zMax_);
  zMax_->setValidator(new Wt::WDoubleValidator(-std::numeric_limits<double>::max(), std::numeric_limits<double>::max()));
  zMax_->setEnabled(false);

  WLineEdit *title = new WLineEdit(this);
  template_->bindWidget("chartTitle", title);
  WCheckBox *enableLegend = new WCheckBox(this);
  template_->bindWidget("chartLegend", enableLegend);
  WComboBox *legendSide = new WComboBox(this);
  legendSide->addItem("Left");
  legendSide->addItem("Right");
  legendSide->addItem("Top");
  legendSide->addItem("Bottom");
  template_->bindWidget("legendside", legendSide);
  switch (chart_->legendSide()) {
  case Left:
    legendSide->setCurrentIndex(0); break;
  case Right:
    legendSide->setCurrentIndex(1); break;
  case Top:
    legendSide->setCurrentIndex(2); break;
  case Bottom:
    legendSide->setCurrentIndex(3); break;
  default:
    break;
  }
  WComboBox *legendAlignment = new WComboBox(this);
  legendAlignment->addItem("Left");
  legendAlignment->addItem("Center");
  legendAlignment->addItem("Right");
  legendAlignment->addItem("Top");
  legendAlignment->addItem("Middle");
  legendAlignment->addItem("Bottom");
  template_->bindWidget("legendalignment", legendAlignment);
  switch (chart_->legendAlignment()) {
  case AlignLeft:
    legendAlignment->setCurrentIndex(0); break;
  case AlignCenter:
    legendAlignment->setCurrentIndex(1); break;
  case AlignRight:
    legendAlignment->setCurrentIndex(2); break;
  case AlignTop:
    legendAlignment->setCurrentIndex(3); break;
  case AlignMiddle:
    legendAlignment->setCurrentIndex(4); break;
  case AlignBottom:
    legendAlignment->setCurrentIndex(5); break;
  default:
    break;
  }
  WCheckBox *enableGridLines = new WCheckBox(this);
  template_->bindWidget("gridlines", enableGridLines);
  WLineEdit *widgetWidth = new WLineEdit(Wt::asString(chart_->width().value()), this);
  widgetWidth->setValidator(new Wt::WIntValidator(1, 2000));
  WLineEdit *widgetHeight = new WLineEdit(Wt::asString(chart_->height().value()), this);
  widgetHeight->setValidator(new Wt::WIntValidator(1, 2000));
  template_->bindWidget("width", widgetWidth);
  template_->bindWidget("height", widgetHeight);

  WLineEdit *xAxisTitle = new WLineEdit(chart_->axis(XAxis_3D).title(), this);
  WLineEdit *yAxisTitle = new WLineEdit(chart_->axis(YAxis_3D).title(), this);
  WLineEdit *zAxisTitle = new WLineEdit(chart_->axis(ZAxis_3D).title(), this);
  template_->bindWidget("xTitle", xAxisTitle);
  template_->bindWidget("yTitle", yAxisTitle);
  template_->bindWidget("zTitle", zAxisTitle);
    

  // hook it up
  autoRangeX_->checked().connect(std::bind([=] () {
	chart_->axis(XAxis_3D).setAutoLimits(Chart::MinimumValue 
					     | Chart::MaximumValue);
	xMin_->setEnabled(false); xMax_->setEnabled(false);
      }));
  autoRangeX_->unChecked().connect(std::bind([=] () {
	xMin_->setEnabled(true); xMax_->setEnabled(true);
	chart_->axis(XAxis_3D).setRange(Wt::asNumber(xMin_->text()),
					Wt::asNumber(xMax_->text()));
      }));
  autoRangeY_->checked().connect(std::bind([=] () {
	chart_->axis(YAxis_3D).setAutoLimits(Chart::MinimumValue 
					     | Chart::MaximumValue);
	yMin_->setEnabled(false); yMax_->setEnabled(false);
      }));
  autoRangeY_->unChecked().connect(std::bind([=] () {
	yMin_->setEnabled(true); yMax_->setEnabled(true);
	chart_->axis(YAxis_3D).setRange(Wt::asNumber(yMin_->text()),
					  Wt::asNumber(yMax_->text()));
      }));
  autoRangeZ_->checked().connect(std::bind([=] () {
	chart_->axis(ZAxis_3D).setAutoLimits(Chart::MinimumValue 
					     | Chart::MaximumValue);
	zMin_->setEnabled(false); zMax_->setEnabled(false);
      }));
  autoRangeZ_->unChecked().connect(std::bind([=] () {
	zMin_->setEnabled(true); zMax_->setEnabled(true);
	chart_->axis(ZAxis_3D).setRange(Wt::asNumber(zMin_->text()),
					Wt::asNumber(zMax_->text()));
      }));

  xMin_->changed().connect(std::bind([=] () {
	chart_->axis(XAxis_3D).setRange(Wt::asNumber(xMin_->text()),
					Wt::asNumber(xMax_->text()));
      }));
  xMax_->changed().connect(std::bind([=] () {
	chart_->axis(XAxis_3D).setRange(Wt::asNumber(xMin_->text()),
					Wt::asNumber(xMax_->text()));
      }));
  yMin_->changed().connect(std::bind([=] () {
	chart_->axis(YAxis_3D).setRange(Wt::asNumber(yMin_->text()),
					  Wt::asNumber(yMax_->text()));
      }));
  yMax_->changed().connect(std::bind([=] () {
	chart_->axis(YAxis_3D).setRange(Wt::asNumber(yMin_->text()),
					  Wt::asNumber(yMax_->text()));
      }));
  zMin_->changed().connect(std::bind([=] () {
	chart_->axis(ZAxis_3D).setRange(Wt::asNumber(zMin_->text()),
					  Wt::asNumber(zMax_->text()));
      }));
  zMax_->changed().connect(std::bind([=] () {
	chart_->axis(ZAxis_3D).setRange(Wt::asNumber(zMin_->text()),
					  Wt::asNumber(zMax_->text()));
      }));

  enableGridLines->checked().connect(std::bind([=]() {
	chart_->setGridEnabled(Wt::Chart::XY_Plane, Wt::Chart::XAxis_3D, true);
	chart_->setGridEnabled(Wt::Chart::XY_Plane, Wt::Chart::YAxis_3D, true);
	chart_->setGridEnabled(Wt::Chart::XZ_Plane, Wt::Chart::XAxis_3D, true);
	chart_->setGridEnabled(Wt::Chart::XZ_Plane, Wt::Chart::ZAxis_3D, true);
	chart_->setGridEnabled(Wt::Chart::YZ_Plane, Wt::Chart::YAxis_3D, true);
	chart_->setGridEnabled(Wt::Chart::YZ_Plane, Wt::Chart::ZAxis_3D, true);
      }));
  enableGridLines->unChecked().connect(std::bind([=]() {
	chart_->setGridEnabled(Wt::Chart::XY_Plane, Wt::Chart::XAxis_3D, false);
	chart_->setGridEnabled(Wt::Chart::XY_Plane, Wt::Chart::YAxis_3D, false);
	chart_->setGridEnabled(Wt::Chart::XZ_Plane, Wt::Chart::XAxis_3D, false);
	chart_->setGridEnabled(Wt::Chart::XZ_Plane, Wt::Chart::ZAxis_3D, false);
	chart_->setGridEnabled(Wt::Chart::YZ_Plane, Wt::Chart::YAxis_3D, false);
	chart_->setGridEnabled(Wt::Chart::YZ_Plane, Wt::Chart::ZAxis_3D, false);
      }));

  enableLegend->checked().connect(std::bind([=]() {
	chart_->setLegendEnabled(true);
      }));
  enableLegend->unChecked().connect(std::bind([=]() {
	chart_->setLegendEnabled(false);
      }));

  legendSide->changed().connect(std::bind([=]() {
	switch (legendSide->currentIndex()) {
	case 0:
	  chart_->setLegendLocation(Left, chart_->legendAlignment()); break;
	case 1:
	  chart_->setLegendLocation(Right, chart_->legendAlignment()); break;
	case 2:
	  chart_->setLegendLocation(Top, chart_->legendAlignment()); break;
	case 3:
	  chart_->setLegendLocation(Bottom, chart_->legendAlignment()); break;
	}
      }));
  legendAlignment->changed().connect(std::bind([=]() {
	switch (legendAlignment->currentIndex()) {
	case 0:
	  chart_->setLegendLocation(chart_->legendSide(), AlignLeft); break;
	case 1:
	  chart_->setLegendLocation(chart_->legendSide(), AlignCenter); break;
	case 2:
	  chart_->setLegendLocation(chart_->legendSide(), AlignRight); break;
	case 3:
	  chart_->setLegendLocation(chart_->legendSide(), AlignTop); break;
	case 4:
	  chart_->setLegendLocation(chart_->legendSide(), AlignMiddle); break;
	case 5:
	  chart_->setLegendLocation(chart_->legendSide(), AlignBottom); break;
	}
      }));

  title->changed().connect(std::bind([=] () {
	chart_->setTitle(Wt::asString(title->text()));
      }));

  widgetWidth->changed().connect(std::bind([=] () {
	chart_->resize(Wt::asNumber(widgetWidth->text()),
		       Wt::asNumber(widgetHeight->text()));
      }));
  widgetHeight->changed().connect(std::bind([=] () {
	chart_->resize(Wt::asNumber(widgetWidth->text()),
		       Wt::asNumber(widgetHeight->text()));
      }));

  xAxisTitle->changed().connect(std::bind([=]() {
	chart_->axis(XAxis_3D).setTitle(xAxisTitle->text());
      }));
  yAxisTitle->changed().connect(std::bind([=]() {
	chart_->axis(YAxis_3D).setTitle(yAxisTitle->text());
      }));
  zAxisTitle->changed().connect(std::bind([=]() {
	chart_->axis(ZAxis_3D).setTitle(zAxisTitle->text());
      }));
  
}