bool NotebooksTreeView::on_drag_motion(const Glib::RefPtr<Gdk::DragContext> &,
int x, int y, guint )
{
Gtk::TreePath treepath;
Gtk::TreeViewDropPosition pos;
if (get_dest_row_at_pos (x, y, treepath,pos) == false) {
gtk_tree_view_set_drag_dest_row (gobj(), NULL, GTK_TREE_VIEW_DROP_INTO_OR_AFTER);
return false;
}
Gtk::TreeIter iter = get_model()->get_iter (treepath);
if (!iter) {
gtk_tree_view_set_drag_dest_row (gobj(), NULL, GTK_TREE_VIEW_DROP_INTO_OR_AFTER);
return false;
}
Notebook::Ptr destNotebook;
iter->get_value(0, destNotebook);
if(std::dynamic_pointer_cast<AllNotesNotebook>(destNotebook)) {
gtk_tree_view_set_drag_dest_row (gobj(), NULL, GTK_TREE_VIEW_DROP_INTO_OR_AFTER);
return true;
}
set_drag_dest_row (treepath , Gtk::TREE_VIEW_DROP_INTO_OR_AFTER);
return true;
}
void TcpClient::read_data()
{
const int max_size = 1024;
char buffer[max_size];
char *m_buff = buffer;
auto input_stream = connection->get_input_stream();
while (connected)
{
int size = gst_debugger_protocol_utils_read_header(input_stream->gobj(), cancel->gobj());
if (size < 0)
break;
if (size > max_size)
{
m_buff = new char[size];
}
else
{
m_buff = buffer;
}
gst_debugger_protocol_utils_read_requested_size(input_stream->gobj(), size, m_buff, cancel->gobj());
GstDebugger::GStreamerData data;
data.ParseFromArray(m_buff, size);
if (m_buff != buffer)
{
delete m_buff;
}
signal_frame_received(data);
}
connected = false;
signal_status_changed(false);
}
Dialog::Dialog(Behavior::BehaviorFactory behavior_factory, const char *prefs_path, int verb_num,
Glib::ustring const &apply_label)
: _hiddenF12 (false),
_prefs_path (prefs_path),
_verb_num(verb_num),
_apply_label (apply_label)
{
gchar title[500];
if (verb_num)
sp_ui_dialog_title_string (Inkscape::Verb::get(verb_num), title);
_title = title;
_behavior = behavior_factory(*this);
if (Inkscape::NSApplication::Application::getNewGui()) {
_desktop_activated_connection = Inkscape::NSApplication::Editor::connectDesktopActivated (sigc::mem_fun (*this, &Dialog::onDesktopActivated));
_dialogs_hidden_connection = Inkscape::NSApplication::Editor::connectDialogsHidden (sigc::mem_fun (*this, &Dialog::onHideF12));
_dialogs_unhidden_connection = Inkscape::NSApplication::Editor::connectDialogsUnhidden (sigc::mem_fun (*this, &Dialog::onShowF12));
_shutdown_connection = Inkscape::NSApplication::Editor::connectShutdown (sigc::mem_fun (*this, &Dialog::onShutdown));
} else {
g_signal_connect(G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK(sp_retransientize), (void *)this);
g_signal_connect(G_OBJECT(INKSCAPE), "dialogs_hide", G_CALLBACK(hideCallback), (void *)this);
g_signal_connect(G_OBJECT(INKSCAPE), "dialogs_unhide", G_CALLBACK(unhideCallback), (void *)this);
g_signal_connect(G_OBJECT(INKSCAPE), "shut_down", G_CALLBACK(sp_dialog_shutdown), (void *)this);
}
Glib::wrap(gobj())->signal_event().connect(sigc::mem_fun(*this, &Dialog::_onEvent));
Glib::wrap(gobj())->signal_key_press_event().connect(sigc::mem_fun(*this, &Dialog::_onKeyPress));
read_geometry();
}
Dialog::Dialog(Behavior::BehaviorFactory behavior_factory, const char *prefs_path, int verb_num,
Glib::ustring const &apply_label)
: _user_hidden(false),
_hiddenF12(false),
retransientize_suppress(false),
_prefs_path(prefs_path),
_verb_num(verb_num),
_title(),
_apply_label(apply_label),
_desktop(NULL),
_is_active_desktop(true),
_behavior(0)
{
gchar title[500];
if (verb_num) {
sp_ui_dialog_title_string (Inkscape::Verb::get(verb_num), title);
}
_title = title;
_behavior = behavior_factory(*this);
_desktop = SP_ACTIVE_DESKTOP;
g_signal_connect(G_OBJECT(INKSCAPE), "activate_desktop", G_CALLBACK(sp_retransientize), (void *)this);
g_signal_connect(G_OBJECT(INKSCAPE), "dialogs_hide", G_CALLBACK(hideCallback), (void *)this);
g_signal_connect(G_OBJECT(INKSCAPE), "dialogs_unhide", G_CALLBACK(unhideCallback), (void *)this);
g_signal_connect(G_OBJECT(INKSCAPE), "shut_down", G_CALLBACK(sp_dialog_shutdown), (void *)this);
Glib::wrap(gobj())->signal_event().connect(sigc::mem_fun(*this, &Dialog::_onEvent));
Glib::wrap(gobj())->signal_key_press_event().connect(sigc::mem_fun(*this, &Dialog::_onKeyPress));
read_geometry();
}
void TableofcontentsNoteAddin::get_toc_popover_items(std::vector<Gtk::Widget*> & items) const
{
std::vector<TocItem> toc_items;
get_toc_items(toc_items);
if(toc_items.size()) {
auto item = dynamic_cast<Gtk::ModelButton*>(gnote::utils::create_popover_button("win.tableofcontents-goto-heading", ""));
Gtk::Label *label = (Gtk::Label*)item->get_child();
label->set_markup("<b>" + get_note()->get_title() + "</b>");
gtk_actionable_set_action_target_value(GTK_ACTIONABLE(item->gobj()), g_variant_new_int32(0));
item->property_role() = Gtk::BUTTON_ROLE_NORMAL;
item->property_inverted() = true;
item->property_centered() = false;
items.push_back(item);
}
for(auto & toc_item : toc_items) {
if(toc_item.heading_level == Heading::Level_2) {
toc_item.heading = "→ " + toc_item.heading;
}
auto item = dynamic_cast<Gtk::ModelButton*>(gnote::utils::create_popover_button("win.tableofcontents-goto-heading", toc_item.heading));
if(toc_item.heading_level == Heading::Level_1) {
item->set_image(*manage(new Gtk::Image(Gtk::Stock::GO_FORWARD, Gtk::ICON_SIZE_MENU)));
}
gtk_actionable_set_action_target_value(GTK_ACTIONABLE(item->gobj()), g_variant_new_int32(toc_item.heading_position));
item->property_role() = Gtk::BUTTON_ROLE_NORMAL;
item->property_inverted() = true;
item->property_centered() = false;
items.push_back(item);
}
}
/**
* Constructor
*/
AboutBox::AboutBox() : Gtk::Dialog(_("About Inkscape")) {
// call this first
initStrings();
Gtk::Notebook *tabs=new Gtk::Notebook();
tabs->set_scrollable();
Gtk::Widget *splash=build_splash_widget();
if (splash) {
tabs->append_page(*manage(splash), _("_Splash"), true);
}
tabs->append_page(*manage(
make_scrolled_text(authors_text)), _("_Authors"), true);
tabs->append_page(*manage(
make_scrolled_text(translators_text)), _("_Translators"), true);
tabs->append_page(*manage(
make_scrolled_text(license_text)), _("_License"), true);
#if WITH_GTKMM_3_0
get_content_area()->pack_end(*manage(tabs), true, true);
#else
get_vbox()->pack_end(*manage(tabs), true, true);
#endif
tabs->show_all();
add_button(Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE);
set_default_response(Gtk::RESPONSE_CLOSE);
Gtk::Label *label=new Gtk::Label();
gchar *label_text =
g_strdup_printf("<small>Inkscape %s</small>",
Inkscape::version_string);
label->set_markup(label_text);
label->set_alignment(Gtk::ALIGN_END, Gtk::ALIGN_CENTER);
label->set_padding(5,0);
g_free(label_text);
label->set_selectable(true);
label->show();
#if WITH_GTKMM_3_0
get_content_area()->pack_start(*manage(label), false, false);
#else
get_vbox()->pack_start(*manage(label), false, false);
#endif
Gtk::Requisition requisition;
#if GTK_CHECK_VERSION(3,0,0)
gtk_widget_get_preferred_size(reinterpret_cast<GtkWidget*>(gobj()), &requisition, NULL);
#else
gtk_widget_size_request (reinterpret_cast<GtkWidget*>(gobj()), &requisition);
#endif
// allow window to shrink
set_size_request(0, 0);
set_default_size(requisition.width, requisition.height);
}
const std::string ThreadSummary::get_hash() const {
std::stringstream s;
s << "{FAKEHASH}"
<< horizon_thread_summary_get_board(gobj())
<< "-" << horizon_thread_summary_get_id(gobj())
<< "-" << horizon_thread_summary_get_unix_date(gobj());
return s.str();
}
void CGLDrawingArea::GTK_EndGL()
/***************************************/
{
GtkWidget* widget = reinterpret_cast<GtkWidget*>(gobj());
GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable (widget);
gdk_gl_drawable_gl_end (gldrawable);
}
void
cb_cpu_color_changed (GsmColorButton *cp, gpointer data)
{
guint cpu_i = GPOINTER_TO_UINT (data);
auto settings = Gio::Settings::create (GSM_GSETTINGS_SCHEMA);
/* Get current values */
GVariant *cpu_colors_var = g_settings_get_value (settings->gobj(), GSM_SETTING_CPU_COLORS);
gsize children_n = g_variant_n_children(cpu_colors_var);
/* Create builder to contruct new setting with updated value for cpu i */
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
for (guint i = 0; i < children_n; i++) {
if(cpu_i == i) {
gchar *color;
GdkRGBA button_color;
gsm_color_button_get_color(cp, &button_color);
color = gdk_rgba_to_string (&button_color);
g_variant_builder_add(&builder, "(us)", i, color);
g_free (color);
} else {
g_variant_builder_add_value(&builder,
g_variant_get_child_value(cpu_colors_var, i));
}
}
/* Just set the value and let the changed::cpu-colors signal callback do the rest. */
settings->set_value (GSM_SETTING_CPU_COLORS, Glib::wrap (g_variant_builder_end(&builder)));
}
void CGLDrawingArea::RegisterSignalHandlers()
/***************************************/
{
//TODO: There's probably a better way to do this with gtkmm, but I don't really want to figure it out.
//I have the C-style handler functions turn around and call the C++ virtual methods.
GtkWidget* drawing_area = reinterpret_cast<GtkWidget*>(gobj());
g_signal_connect_after (G_OBJECT (drawing_area), "realize",
G_CALLBACK (realize), this);
g_signal_connect (G_OBJECT (drawing_area), "configure_event",
G_CALLBACK (configure_event), this);
g_signal_connect (G_OBJECT (drawing_area), "expose_event",
G_CALLBACK (expose_event), this);
g_signal_connect (G_OBJECT (drawing_area), "unrealize",
G_CALLBACK (unrealize), this);
g_signal_connect (G_OBJECT (drawing_area), "map_event",
G_CALLBACK (map_event), this);
g_signal_connect (G_OBJECT (drawing_area), "unmap_event",
G_CALLBACK (unmap_event), this);
g_signal_connect (G_OBJECT (drawing_area), "visibility_notify_event",
G_CALLBACK (visibility_notify_event), this);
//Here are the ones for mouse+keyboard
add_events((Gdk::EventMask)(Gdk::BUTTON_PRESS_MASK | Gdk::POINTER_MOTION_MASK | Gdk::BUTTON_RELEASE_MASK | Gdk::KEY_PRESS_MASK | Gdk::KEY_RELEASE_MASK));
}
/*
* http://web.mit.edu/ghudson/dev/nokrb/third/libwnck/libwnck/test-wnck.c
* constructor
* set the window transparence
*/
AppWindow::AppWindow()
{
add_events(Gdk::BUTTON_PRESS_MASK);
set_app_paintable(true);
GdkScreen *screen;
GdkVisual *visual;
gtk_widget_set_app_paintable(GTK_WIDGET(gobj()), TRUE);
screen = gdk_screen_get_default();
visual = gdk_screen_get_rgba_visual(screen);
if (visual != NULL && gdk_screen_is_composited(screen)) {
gtk_widget_set_visual(GTK_WIDGET(gobj()), visual);
}
}
void
RenderArea::deactivateGLContext() {
DB(cerr << "RenderArea::deactivateGLContext()" << endl);
if (--_myContextRefCount == 0) {
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (GTK_WIDGET(gobj()));
gdk_gl_drawable_gl_end (gldrawable);
}
}
const std::string ThreadSummary::get_url() const {
const gchar *url = horizon_thread_summary_get_url(gobj());
std::stringstream s;
if (url)
s << static_cast<const char *>(url);
return s.str();
}
Glib::RefPtr<Horizon::Post> ThreadSummary::get_proxy_post() const {
HorizonPost *cpost = HORIZON_POST(g_object_new(horizon_post_get_type(),
"md5",
get_hash().c_str(),
NULL));
horizon_post_set_thumb_url(cpost, horizon_thread_summary_get_thumb_url(gobj()));
auto post = Glib::wrap(cpost);
return post;
}
//virtual
void
RenderArea::swapBuffers() {
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (GTK_WIDGET(gobj()));
if (gdk_gl_drawable_is_double_buffered (gldrawable)) {
gdk_gl_drawable_swap_buffers (gldrawable);
} else {
glFlush ();
}
}
void
RenderArea::activateGLContext() {
DB(cerr << "RenderArea::activateGLContext()" << endl);
if (_myContextRefCount++ == 0) {
GdkGLContext *glcontext = gtk_widget_get_gl_context (GTK_WIDGET(gobj()));
GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (GTK_WIDGET(gobj()));
gdk_gl_drawable_gl_begin (gldrawable, glcontext);
// init glew
unsigned int myGlewError = glewInit();
if (GLEW_OK != myGlewError) {
throw RendererException(std::string("Glew Initialization Error: ") +
std::string(reinterpret_cast<const char*>(glewGetErrorString(myGlewError))),
PLUS_FILE_LINE);
}
GLResourceManager::get().initCaps();
}
}
ZoomStatus::ZoomStatus()
: _adj(0.0, -1.0, 1.0, 0.1, 0.1)
{
_dt = 0;
_upd_f = false;
property_numeric() = false;
property_update_policy() = Gtk::UPDATE_ALWAYS;
sp_set_font_size_smaller(static_cast<GtkWidget*>((void*)gobj()));
}
void CGLDrawingArea::MakeDrawingAreaAnOpenGLContext()
/***************************************/
{
GtkWidget* widget = reinterpret_cast<GtkWidget*>(gobj());
gtk_widget_set_gl_capability(widget,
GLConfig(),
NULL,
TRUE,
GDK_GL_RGBA_TYPE);
}
void CGLDrawingArea::GTK_FlushBufferGL()
/***************************************/
{
GtkWidget* widget = reinterpret_cast<GtkWidget*>(gobj());
GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable (widget);
if (gdk_gl_drawable_is_double_buffered (gldrawable))
gdk_gl_drawable_swap_buffers (gldrawable);
else
glFlush();
}
void CGLDrawingArea::GTK_BeginGL()
/***************************************/
{
GtkWidget* widget = reinterpret_cast<GtkWidget*>(gobj());
GdkGLContext* glcontext = gtk_widget_get_gl_context (widget);
GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable (widget);
/*** OpenGL BEGIN ***/
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
throw(CGLException());
}
void Gobby::CloseButton::on_style_changed(
const Glib::RefPtr<Gtk::Style>& previous_style)
#endif
{
int width;
int height;
gtk_icon_size_lookup_for_settings(
gtk_widget_get_settings(GTK_WIDGET(gobj())),
GTK_ICON_SIZE_MENU, &width, &height);
set_size_request(width + 2, height + 2);
}
MyWidget::MyWidget() :
//The GType name will actually be gtkmm__CustomObject_mywidget
Glib::ObjectBase("mywidget"),
Gtk::Widget(),
m_scale(1000)
{
set_has_window(true);
//This shows the GType name, which must be used in the CSS file.
std::cout << "GType name: " << G_OBJECT_TYPE_NAME(gobj()) << std::endl;
//This shows that the GType still derives from GtkWidget:
//std::cout << "Gtype is a GtkWidget?:" << GTK_IS_WIDGET(gobj()) << std::endl;
//Install a style so that an aspect of this widget may be themed via a CSS
//style sheet file:
gtk_widget_class_install_style_property(GTK_WIDGET_CLASS(
G_OBJECT_GET_CLASS(gobj())),
g_param_spec_int("example_scale",
"Scale of Example Drawing",
"The scale to use when drawing. This is just a silly example.",
G_MININT,
G_MAXINT,
500,
G_PARAM_READABLE) );
m_refStyleProvider = Gtk::CssProvider::create();
Glib::RefPtr<Gtk::StyleContext> refStyleContext = get_style_context();
refStyleContext->add_provider(m_refStyleProvider,
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
try
{
m_refStyleProvider->load_from_path("custom_gtk.css");
}
catch(const Glib::Error& ex)
{
std::cerr << "Gtk::CssProvider::load_from_path() failed: " << ex.what() << std::endl;
}
}
GxSplashBox::GxSplashBox()
: Gtk::Window(Gtk::WINDOW_POPUP) {
set_redraw_on_allocate(true);
set_app_paintable();
signal_expose_event().connect(
sigc::group(&gx_cairo::splash_expose, GTK_WIDGET(gobj()),
sigc::_1, (void*)0), false);
set_decorated(false);
set_type_hint(Gdk::WINDOW_TYPE_HINT_SPLASHSCREEN);
set_position(Gtk::WIN_POS_CENTER );
set_default_size(280,80);
show_all();
}
RenderArea::RenderArea(RenderAreaPtr theContext) : AbstractRenderWindow(jslib::JSApp::ShellErrorReporter),
_myContextRefCount(0),
_isFirstFrame(true)
{
GdkGLConfig * myGLConfig = gdk_gl_config_new_by_mode(
GdkGLConfigMode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE | GDK_GL_MODE_ALPHA));
if (myGLConfig == 0) {
throw asl::Exception("can't init GL",PLUS_FILE_LINE);
}
// If another render area is supplied as constructor paramter, this render area is uses as
// source for a shared y60-gl-context and gdk-gl-context.
GdkGLContext * myGdkGLContext = 0;
if (theContext) {
myGdkGLContext = theContext->getGdkGlContext();
if (!myGdkGLContext) {
throw asl::Exception("RenderArea: Failed to get gdk GL context from shared render area.", PLUS_FILE_LINE);
}
setGLContext(theContext->getGLContext());
} else {
setGLContext(GLContextPtr(new GLContext()));
}
/* Set OpenGL-capability to the widget. */
DB(cerr << "RenderArea::RenderArea() sharing with " << myGdkGLContext << endl);
if (!gtk_widget_set_gl_capability (GTK_WIDGET(gobj()),
myGLConfig,
myGdkGLContext,
true,
GDK_GL_RGBA_TYPE))
{
throw asl::Exception("RenderArea: could not create GL context!", PLUS_FILE_LINE);
}
// enable mouse events
Gdk::EventMask flags = get_events();
flags |= Gdk::BUTTON_PRESS_MASK;
flags |= Gdk::POINTER_MOTION_MASK;
flags |= Gdk::BUTTON_RELEASE_MASK;
flags |= Gdk::SCROLL_MASK;
flags |= Gdk::ENTER_NOTIFY_MASK;
flags |= Gdk::LEAVE_NOTIFY_MASK;
set_events(flags);
y60::EventDispatcher::get().addSource(&_myEventAdapter);
y60::EventDispatcher::get().addSink(this);
// TODO: createRenderer(theOtherRenderer);
ShaderLibrary::setGLisReadyFlag(true);
}
// Activate parent if necessary
void PersistentTransientWindow::activateParent()
{
// Only activate if this window is active already
if (gobj()->is_active)
{
Gtk::Container* toplevel = get_toplevel();
if (toplevel != NULL && toplevel->is_toplevel() &&
toplevel->is_visible() && dynamic_cast<Gtk::Window*>(toplevel) != NULL)
{
static_cast<Gtk::Window*>(toplevel)->present();
}
}
}
Gobby::ChatSessionView::ChatSessionView(InfChatSession* session,
const Glib::ustring& title,
const Glib::ustring& path,
const Glib::ustring& hostname,
Preferences& preferences):
SessionView(INF_SESSION(session), title, path, hostname),
m_preferences(preferences), m_chat(INF_GTK_CHAT(inf_gtk_chat_new()))
{
inf_gtk_chat_set_session(m_chat, session);
gtk_widget_show(GTK_WIDGET(m_chat));
gtk_box_pack_start(GTK_BOX(gobj()), GTK_WIDGET(m_chat),
TRUE, TRUE, 0);
}
bool
RenderArea::on_expose_event (GdkEventExpose *event) {
try {
/*GdkGLDrawable *gldrawable =*/ gtk_widget_get_gl_drawable (GTK_WIDGET(gobj()));
ScopedGLContext myContext(this);
if (_myRenderer && _myScene) {
if (_isFirstFrame) {
_myRenderer->getCurrentScene()->updateAllModified();
_isFirstFrame = false;
}
STOP_TIMER(frames);
asl::getDashboard().cycle();
START_TIMER(frames);
onFrame();
//START_TIMER(dispatchEvents);
//y60::EventDispatcher::get().dispatch();
//STOP_TIMER(dispatchEvents);
START_TIMER(handleRequests);
_myRequestManager.handleRequests();
STOP_TIMER(handleRequests);
renderFrame();
swapBuffers();
/** done rendering **/
} else {
// nothing to render... just clear the buffer to avoid pixel garbage
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
swapBuffers();
}
if (_myJSContext) {
MAKE_SCOPE_TIMER(gc);
JS_GC(_myJSContext);
}
} catch (const asl::Exception & ex) {
AC_FATAL << "Exception caught: " << ex;
} catch (const exception & ex) {
AC_FATAL << "Exception caught: " << ex.what();
} catch (...) {
AC_FATAL << "Unknown exception";
}
return true;
}
PageFlipPanel::PageFlipPanel()
: up_button("U"), down_button("D")
{
int width = 50;
up_button.signal_clicked().connect(
sigc::mem_fun(*this, &PageFlipPanel::up_button_pressed));
down_button.signal_clicked().connect(
sigc::mem_fun(*this, &PageFlipPanel::down_button_pressed));
vbox.pack_start(up_button, Gtk::PACK_EXPAND_WIDGET);
vbox.pack_start(down_button);
add(vbox);
up_button.show();
down_button.show();
vbox.show();
set_default_size(width, Gdk::screen_height());
move(Gdk::screen_width()-width, 0);
set_type_hint(Gdk::WINDOW_TYPE_HINT_DOCK);
show();
gulong val[12];
val[0] = 0;
val[1] = width;
val[2] = 0;
val[3] = 0;
val[4] = 0;
val[5] = 0;
val[6] = 0;
val[7] = 200;
val[8] = 0;
val[9] = 0;
val[10] = 0;
val[11] = 0;
GtkWindow* gtkWindow = gobj();
gdk_property_change(
GTK_WIDGET(gtkWindow)->window,
gdk_atom_intern("_NET_WM_STRUT_PARTIAL", FALSE),
gdk_atom_intern ("CARDINAL", FALSE),
32,
GDK_PROP_MODE_REPLACE,
(unsigned char *)val, 12);
}
/* Construct a Port on an existing module. */
Port::Port(Module& module,
const std::string& name,
bool is_input,
uint32_t color)
: Box(module.canvas(),
GANV_BOX(
ganv_port_new(module.gobj(), is_input,
"fill-color", color,
"border-color", highlight_color(color, 0x20),
"label", name.c_str(),
NULL)))
{
g_signal_connect(gobj(), "value-changed",
G_CALLBACK(on_value_changed), this);
}
Gobby::CloseButton::CloseButton()
{
set_relief(Gtk::RELIEF_NONE);
set_focus_on_click(false);
//set_flags(get_flags() & ~Gtk::CAN_FOCUS);
GtkRcStyle* rc_style = gtk_rc_style_new();
rc_style->xthickness = 0;
rc_style->ythickness = 0;
gtk_widget_modify_style(GTK_WIDGET(gobj()), rc_style);
g_object_unref(rc_style);
Gtk::Image* button_image = Gtk::manage(
new Gtk::Image(Gtk::Stock::CLOSE, Gtk::ICON_SIZE_MENU));
add(*button_image);
button_image->show();
}
