C++ Color::set_rgb_p方法代码示例

/// Converts a k3d::color to a Gdk::Color
const Gdk::Color convert(const k3d::color& RHS)
{
	Gdk::Color result;
	result.set_rgb_p(RHS.red, RHS.green, RHS.blue);

	return result;
}

void setColorChooserColor(string drawable, OSG::Color3f col) {
    Gdk::Color c;
    c.set_rgb_p(col[0], col[1], col[2]);

    Glib::RefPtr<Gtk::DrawingArea> darea;
    darea = Glib::RefPtr<Gtk::DrawingArea>::cast_static(VRGuiBuilder()->get_object(drawable.c_str()));
    darea->modify_bg(Gtk::STATE_NORMAL, c);
}

static Gdk::Color
color_darken(Gdk::Color x, float amount)
{
	double   red = x.get_red_p()   * amount;
	double green = x.get_green_p() * amount;
	double  blue = x.get_blue_p()  * amount;

	x.set_rgb_p(  red > 1 ? 1 : red,
				green > 1 ? 1 : green,
				 blue > 1 ? 1 : blue);

	return x;
}

void Settings::set_to_gui (Builder &builder)
{
  for (uint i = 0; i < G_N_ELEMENTS (settings); i++) {
    const char *glade_name = settings[i].glade_name;

    if (!glade_name)
      continue;

    set_to_gui (builder, i);
  }
  set_shrink_to_gui (builder);

  for (uint i = 0; i < G_N_ELEMENTS (colour_selectors); i++) {
      const char *glade_name = colour_selectors[i].glade_name;
      vmml::Vector4f *src =
        (vmml::Vector4f *) PTR_OFFSET(this, colour_selectors[i].member_offset);
      Gdk::Color c;
      Gtk::ColorButton *w = NULL;
      builder->get_widget (glade_name, w);
      if (w) {
        w->set_use_alpha(true);
        c.set_rgb_p(src->r, src->g, src->b);
        w->set_color(c);
        w->set_alpha(src->a * 65535.0);
      }
  }

  // Set serial speed. Find the row that holds this value
  Gtk::ComboBoxEntry *portspeed = NULL;
  builder->get_widget ("Hardware.SerialSpeed", portspeed);
  if (portspeed) {
    std::ostringstream ostr;
    ostr << Hardware.SerialSpeed;
    Glib::ustring val(ostr.str());
    portspeed->get_entry()->set_text(val);
  }
}

  bool addWidgets(Gtk::Box* iBox) {
    if (mBox != NULL) return false;

    mBox = Gtk::manage(new Gtk::VBox());

    Gtk::Box* box = Gtk::manage(new Gtk::HBox());

    mToggleButton = Gtk::manage(new Gtk::ToggleButton("                    "));
    Gdk::Color color;
    color.set_rgb_p(mAttributes.mColor[0], mAttributes.mColor[1],
                    mAttributes.mColor[2]);
    mToggleButton->modify_bg(Gtk::STATE_ACTIVE, color);
    color.set_rgb_p((mAttributes.mColor[0]+1)/2, (mAttributes.mColor[1]+1)/2,
                    (mAttributes.mColor[2]+1)/2);
    mToggleButton->modify_bg(Gtk::STATE_PRELIGHT, color); 
    color.set_rgb_p(0.8, 0.8, 0.8);
    mToggleButton->modify_bg(Gtk::STATE_NORMAL, color);
    mToggleButton->signal_toggled().connect
      (sigc::mem_fun(*this, &Helper::onToggleButton));
    mToggleButton->set_active(true);
    box->pack_start(*(mToggleButton), false, false);
    Gtk::Label* label = Gtk::manage(new Gtk::Label(mAttributes.mLabel));
    box->pack_start(*label, false, false);
    if (mViewId != 1) {
      Gtk::Button* cancelButton = Gtk::manage(new Gtk::Button("X"));
      box->pack_start(*cancelButton, false, false);
      cancelButton->signal_clicked().connect
        (sigc::mem_fun(*this, &Helper::onRemoveButton));
    }
    Gtk::Button* button = Gtk::manage(new Gtk::Button("save"));
    button->signal_clicked().connect
      (sigc::mem_fun(*this, &Helper::onSaveButton));
    box->pack_start(*button, false, false);

    mBox->pack_start(*box, false, false);

    box = Gtk::manage(new Gtk::HBox());
    std::vector<int> ids;
    std::vector<std::string> labels;
    ids = { MeshRenderer::ColorModeFlat, MeshRenderer::ColorModeHeight,
            MeshRenderer::ColorModeRange, MeshRenderer::ColorModeNormal,
            MeshRenderer::ColorModeCamera };
    labels = { "Flat", "Height", "Range", "Normal", "Camera" };
    Gtk::ComboBox* combo = 
      gtkmm::RendererBase::createCombo(mAttributes.mColorMode, labels, ids);
    combo->signal_changed().connect([this]{this->mRenderer->requestDraw();});
    box->pack_start(*combo, false, false);

    ids = { MeshRenderer::MeshModePoints, MeshRenderer::MeshModeWireframe,
            MeshRenderer::MeshModeFilled };
    labels = { "Points", "Wireframe", "Filled" };
    combo =
      gtkmm::RendererBase::createCombo(mAttributes.mMeshMode, labels, ids);
    combo->signal_changed().connect([this]{this->mRenderer->requestDraw();});
    box->pack_start(*combo, false, false);
    
    Gtk::HScale* slider =
      gtkmm::RendererBase::createSlider(mAttributes.mPointSize, 0.1, 10, 0.1);
    slider->signal_value_changed().connect([this]{this->mRenderer->requestDraw();});
    box->pack_start(*slider, true, true);

    mBox->pack_start(*box, false, false);

    box = Gtk::manage(new Gtk::HBox());
    label = Gtk::manage(new Gtk::Label("Z Rng"));
    box->pack_start(*label,false,false);
    slider = gtkmm::RendererBase::createSlider(mAttributes.mMinZ, -1, 2, 0.01);
    slider->signal_value_changed().connect([this]{this->mRenderer->requestDraw();});
    box->pack_start(*slider, true, true);
    slider = gtkmm::RendererBase::createSlider(mAttributes.mMaxZ, -1, 2, 0.01);
    slider->signal_value_changed().connect([this]{this->mRenderer->requestDraw();});
    box->pack_start(*slider, true, true);

    mBox->pack_start(*box, false, false);

    mBox->pack_start(*Gtk::manage(new Gtk::HSeparator()));

    mBox->show_all();
    iBox->pack_start(*mBox, false, false);
    return true;
  }

void
HybrisMonitorGtkWindow::on_planner_status_cb()
{
  continual_planning_msgs::ContinualPlanningStatus status;

  {
    boost::mutex::scoped_lock lock(msgmtx_planner_status_);
    if (msgq_planner_status_.empty()) {
      return;
    }
    status = msgq_planner_status_.front();
    msgq_planner_status_.pop();
  }

  // Some weird convention to keep the "before" state
  if (status.description == "-")  return;

  switch(status.component) {
  case continual_planning_msgs::ContinualPlanningStatus::PLANNING:
    {
      std::vector<std::string> strs, tmp;
      boost::split(tmp, status.description, boost::is_any_of("\n"));
      for (size_t i = 0; i < tmp.size(); ++i) {
	if (tmp[i] != "") {
	  strs.push_back(tmp[i]);
	}
      }
      plan_list_->clear();
      for (size_t i = 0; i < strs.size(); ++i) {
	Gtk::TreeModel::Row row;
	row = *(plan_list_->append());
	row[plan_record_.step] = strs[i];
      }

      if (strs.empty()) {
	      lab_plan_status_->set_text("");
      } else {
	      std::string status_string = "Plan size: " + std::to_string(strs.size());
	      lab_plan_status_->set_text(status_string);
      }
    }
    break;

  case continual_planning_msgs::ContinualPlanningStatus::CURRENT_PLAN:
    {
      std::vector<std::string> strs, tmp;
      boost::split(tmp, status.description, boost::is_any_of("\n"));
      for (size_t i = 0; i < tmp.size(); ++i) {
        if (tmp[i] != "") {
          strs.push_back(tmp[i]);
        }
      }
      Gtk::TreeModel::Children children = plan_list_->children();

      ssize_t active = -1;
      if (children.size() >= strs.size()) {
	active = children.size() - strs.size();
      }

      ssize_t i = 0;
      for (Gtk::TreeModel::Children::iterator c = children.begin(); c != children.end(); ++c) {
	Gdk::Color color;
	if (i == active) {
	  //trv_plan_->set_cursor(plan_list_->get_path(c));
	  color.set_rgb_p(0.8, 0.8, 1.0);
	} else {
	  color.set_rgb_p(1.0, 1.0, 1.0);
	}
	(*c)[plan_record_.background] = color;
	++i;
      }
    }
    break;

      /*
  case continual_planning_msgs::ContinualPlanningStatus::EXECUTION:
    {
      std::string active_action = get_action_description(status.description);

      Gtk::TreeModel::Children children = plan_list_->children();
      for (Gtk::TreeModel::Children::iterator c = children.begin(); c != children.end(); ++c) {
	Gdk::Color color;
	if (get_action_description((Glib::ustring)(*c)[plan_record_.step]) == active_action) {
	  //trv_plan_->set_cursor(plan_list_->get_path(c));
	  color.set_rgb_p(0.8, 0.8, 1.0);
	} else {
	  color.set_rgb_p(1.0, 1.0, 1.0);
	}
	(*c)[plan_record_.background] = color;
      }
    }
    break;
      */

  default: // ignored
    break;
  } 

  Glib::RefPtr<Gtk::Adjustment> adjustment = window_plan_->get_vadjustment();
  adjustment->set_value(adjustment->get_upper());
//.........这里部分代码省略.........