static void
gtk_radio_tool_button_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkRadioToolButton *button;
button = GTK_RADIO_TOOL_BUTTON (object);
switch (prop_id)
{
case PROP_GROUP:
{
GtkRadioToolButton *arg;
GSList *slist = NULL;
if (G_VALUE_HOLDS_OBJECT (value))
{
arg = GTK_RADIO_TOOL_BUTTON (g_value_get_object (value));
if (arg)
slist = gtk_radio_tool_button_get_group (arg);
gtk_radio_tool_button_set_group (button, slist);
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_radio_tool_button_get_properties (GtkWidget *widget, GbWidgetGetArgData * data)
{
GladeFindGroupData find_data;
gb_tool_button_get_standard_properties (widget, data,
StockButton, Label, Icon,
VisibleHorz, VisibleVert,
IsImportant);
gb_widget_output_bool (data, Active,
data->widget_data->flags & GLADE_ACTIVE);
/* If we're showing we need to display the list of groups to choose from.
We walk the tree of widgets in this component, and if a widget is
a radio button, we see if it has a group and if it is already in the
list and if not we add it. */
if (data->action == GB_SHOWING)
{
GladeFindGroupsData find_groups_data;
find_groups_data.groups_found = NULL;
find_groups_data.group_names = NULL;
gb_widget_children_foreach (widget->parent,
(GtkCallback) get_radio_button_groups,
&find_groups_data);
find_groups_data.group_names = g_list_prepend (find_groups_data.group_names,
_("New Group"));
property_set_combo_strings (Group, find_groups_data.group_names);
g_list_free (find_groups_data.groups_found);
g_list_free (find_groups_data.group_names);
}
find_data.group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (widget));
find_data.found_widget = NULL;
gb_widget_children_foreach (widget->parent,
(GtkCallback) find_radio_group,
&find_data);
if (find_data.found_widget)
{
/* If we are saving, we don't output the group if this widget is the
first widget in the group. */
if (data->action == GB_SHOWING || find_data.found_widget != widget)
{
const char *name;
name = gtk_widget_get_name (find_data.found_widget);
gb_widget_output_combo (data, Group, name);
}
}
else
{
g_warning ("Radiotoolbutton has no group");
gb_widget_output_combo (data, Group, "");
}
}
static void
find_parents_group (GtkWidget * widget, GSList ** group)
{
/* If a group has already been found, return. */
if (*group)
return;
if (GTK_IS_RADIO_TOOL_BUTTON (widget))
*group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (widget));
}
/**
* gtk_radio_tool_button_new_from_widget: (constructor)
* @group: (allow-none): An existing #GtkRadioToolButton, or %NULL
*
* Creates a new #GtkRadioToolButton adding it to the same group as @gruup
*
* Returns: (transfer none): The new #GtkRadioToolButton
*
* Since: 2.4
**/
GtkToolItem *
gtk_radio_tool_button_new_from_widget (GtkRadioToolButton *group)
{
GSList *list = NULL;
g_return_val_if_fail (group == NULL || GTK_IS_RADIO_TOOL_BUTTON (group), NULL);
if (group != NULL)
list = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (group));
return gtk_radio_tool_button_new (list);
}
static inline GtkToolItem *_add_category_button (GtkWidget *pToolBar, const gchar *cLabel, const gchar *cIconName, int pos, GtkToolItem *group)
{
GtkToolItem *pCategoryButton;
if (group)
pCategoryButton= gtk_radio_tool_button_new_from_widget (GTK_RADIO_TOOL_BUTTON (group));
else
pCategoryButton = gtk_radio_tool_button_new (NULL);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (pCategoryButton), cLabel);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (pCategoryButton), cIconName);
g_signal_connect (G_OBJECT (pCategoryButton), "toggled", G_CALLBACK(on_click_category_button), GINT_TO_POINTER (pos));
gtk_toolbar_insert (GTK_TOOLBAR (pToolBar) , pCategoryButton, -1);
return pCategoryButton;
}
static void
find_radio_group (GtkWidget *widget, GladeFindGroupData *find_data)
{
if (find_data->found_widget)
return;
if (GTK_IS_RADIO_TOOL_BUTTON (widget) && GB_IS_GB_WIDGET (widget))
{
if (gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (widget)) == find_data->group)
{
find_data->found_widget = widget;
}
}
}
/* Note that this must walk the widget tree in exactly the same way that we
save the widgets, so we know which widget in the group will be the first
output. */
static void
get_radio_button_groups (GtkWidget * widget, GladeFindGroupsData *find_data)
{
if (GTK_IS_RADIO_TOOL_BUTTON (widget) && GB_IS_GB_WIDGET (widget))
{
GSList *group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (widget));
/* See if we've already found a widget in this group. */
if (!g_list_find (find_data->groups_found, group))
{
const char *name = gtk_widget_get_name (GTK_WIDGET (widget));
/* Remember that we've already seen this group. */
find_data->groups_found = g_list_prepend (find_data->groups_found,
group);
/* Add the widget's name to the list. */
find_data->group_names = g_list_insert_sorted (find_data->group_names, (char*)name, (GCompareFunc) g_utf8_collate);
}
}
}
static void
load_toggle_items (GtkToolPalette *palette)
{
GSList *toggle_group = NULL;
GtkToolItem *item;
GtkWidget *group;
char *label;
int i;
group = gtk_tool_item_group_new ("Radio Item");
gtk_container_add (GTK_CONTAINER (palette), group);
for (i = 1; i <= 10; ++i)
{
label = g_strdup_printf ("#%d", i);
item = gtk_radio_tool_button_new (toggle_group);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), label);
g_free (label);
gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
toggle_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
}
}
GtkRadioToolButton* cast_GtkRadioToolButton(GtkWidget* widget) {
return GTK_RADIO_TOOL_BUTTON(widget);
}
GTKGeomWindow::GTKGeomWindow( class GTKPlotter &plotter,
const Geometry &geom,
const EpotField *epot,
const EpotEfield *efield,
const MeshScalarField *scharge,
const MeshScalarField *tdens,
const VectorField *bfield,
const ParticleDataBase *pdb )
: GTKFrameWindow(plotter), _geomplot(_frame,geom),
_geom(geom), _epot(epot), _efield(efield), _scharge(scharge), _tdens(tdens),
_bfield(bfield), _pdb(pdb), _tool(TOOL_UNKNOWN), _prefdata(NULL)
{
//std::cout << "GTKGeomWindow constructor\n";
// Setup GeomPlot
_geomplot.set_epot( epot );
_geomplot.set_scharge( scharge );
_geomplot.set_trajdens( tdens );
_geomplot.set_bfield( bfield );
_geomplot.set_efield( efield );
_geomplot.set_particle_database( pdb );
// Set window title
gtk_window_set_title( GTK_WINDOW(_window), "Simulation geometry" );
// Adding geometry window specific tools to toolbar
// Creating separator
GtkToolItem *toolitem = gtk_separator_tool_item_new();
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
// Creating "Particle diagnostics" button
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_inline( -1, icon_particle_diag_inline, FALSE, NULL );
GtkWidget *icon = gtk_image_new_from_pixbuf( pixbuf );
toolitem = gtk_radio_tool_button_new_from_widget( GTK_RADIO_TOOL_BUTTON(_radioitem) );
gtk_tool_button_set_label( GTK_TOOL_BUTTON(toolitem), "Particle diagnostics" );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Particle diagnostics" );
#endif
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(toolitem), icon );
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
g_signal_connect( G_OBJECT(toolitem), "toggled",
G_CALLBACK(menuitem_tool_change_signal),
(gpointer)this );
// Creating "Field diagnostics" button
pixbuf = gdk_pixbuf_new_from_inline( -1, icon_field_diag_inline, FALSE, NULL );
icon = gtk_image_new_from_pixbuf( pixbuf );
toolitem = gtk_radio_tool_button_new_from_widget( GTK_RADIO_TOOL_BUTTON(_radioitem) );
gtk_tool_button_set_label( GTK_TOOL_BUTTON(toolitem), "Field diagnostics" );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Field diagnostics" );
#endif
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(toolitem), icon );
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
g_signal_connect( G_OBJECT(toolitem), "toggled",
G_CALLBACK(menuitem_tool_change_signal),
(gpointer)this );
// Creating "Geom 3D" button
pixbuf = gdk_pixbuf_new_from_inline( -1, icon_geom3d_inline, FALSE, NULL );
icon = gtk_image_new_from_pixbuf( pixbuf );
toolitem = gtk_tool_button_new( icon, "3D geometry view" );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "3D geometry view" );
#endif
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
if( _geom.geom_mode() != MODE_3D || !_geom.surface_built() )
gtk_widget_set_sensitive( GTK_WIDGET(toolitem), FALSE );
g_signal_connect( G_OBJECT(toolitem), "clicked",
G_CALLBACK(menuitem_geom3d_signal),
(gpointer)this );
// Creating separator
toolitem = gtk_separator_tool_item_new();
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
// Creating view combobox and level spinbutton
//_combobox = gtk_combo_box_new_text();
_combobox = gtk_combo_box_text_new();
if( geom.geom_mode() == MODE_3D ) {
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "XY" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "XZ" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "YX" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "YZ" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "ZX" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "ZY" );
/*
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "XY" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "XZ" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "YX" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "YZ" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "ZX" );
gtk_combo_box_append_text( GTK_COMBO_BOX(_combobox), "ZY" );
*/
gtk_combo_box_set_active( GTK_COMBO_BOX(_combobox), 0 );
_spinbutton = gtk_spin_button_new_with_range( 0, geom.size(2)-1, 1 );
gtk_spin_button_set_value( GTK_SPIN_BUTTON(_spinbutton), geom.size(2)/2 );
_geomplot.set_view( VIEW_XY, geom.size(2)/2 );
} else {
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "XY" );
gtk_combo_box_text_append( GTK_COMBO_BOX_TEXT(_combobox), NULL, "YX" );
gtk_combo_box_set_active( GTK_COMBO_BOX(_combobox), 0 );
_spinbutton = gtk_spin_button_new_with_range( 0, 0, 1 );
gtk_spin_button_set_value( GTK_SPIN_BUTTON(_spinbutton), 0 );
}
toolitem = gtk_tool_item_new();
gtk_container_add( GTK_CONTAINER(toolitem), _combobox );
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Select view direction" );
#endif
gtk_spin_button_set_digits( GTK_SPIN_BUTTON(_spinbutton), 0 );
toolitem = gtk_tool_item_new();
gtk_container_add( GTK_CONTAINER(toolitem), _spinbutton );
gtk_toolbar_insert( GTK_TOOLBAR(_toolbar), toolitem, -1 );
#if GTK_CHECK_VERSION(2,12,0)
gtk_widget_set_tooltip_text( GTK_WIDGET(toolitem), "Select view level" );
#endif
g_signal_connect( G_OBJECT(_combobox), "changed",
G_CALLBACK(combobox_signal),
(gpointer)this );
g_signal_connect( G_OBJECT(_spinbutton), "value-changed",
G_CALLBACK(spinbutton_signal),
(gpointer)this );
// Drawing area signals
g_signal_connect( G_OBJECT(_darea), "button_press_event",
G_CALLBACK(darea_button_signal2),
(gpointer)this );
g_signal_connect( G_OBJECT(_darea), "button_release_event",
G_CALLBACK(darea_button_signal2),
(gpointer)this );
g_signal_connect( G_OBJECT(_darea), "motion_notify_event",
G_CALLBACK(darea_motion_signal2),
(gpointer)this );
update_view();
show();
}
CVoxelView::CVoxelView(CVoxelDisplay& rVoxelDisplay) :
m_rVoxelDisplay(rVoxelDisplay),
m_pBuilderInterface(NULL),
m_pCubeButton(NULL),
m_pSphereButton(NULL),
m_pMinScaleFactorSpinButton(NULL),
m_pMaxScaleFactorSpinButton(NULL),
m_f64MinScaleFactor(1),
m_f64MaxScaleFactor(2),
m_pThresholdRangeAndOrLabel(NULL),
m_pMinDisplayThresholdBoundaryButton(NULL),
m_pMaxDisplayThresholdBoundaryButton(NULL),
m_pMinDisplayThresholdScale(NULL),
m_pMaxDisplayThresholdScale(NULL),
m_f64MinDisplayThreshold(0.25),
m_f64MaxDisplayThreshold(0.75)
{
//load the gtk builder interface
m_pBuilderInterface=gtk_builder_new(); // glade_xml_new(OpenViBE::Directories::getDataDir() + "/openvibe-plugins/simple-visualisation/openvibe-simple-visualisation-VoxelDisplay.ui", NULL, NULL);
gtk_builder_add_from_file(m_pBuilderInterface, OpenViBE::Directories::getDataDir() + "/openvibe-plugins/simple-visualisation/openvibe-simple-visualisation-VoxelDisplay.ui", NULL);
if(!m_pBuilderInterface)
{
g_warning("Couldn't load the interface!");
return;
}
gtk_builder_connect_signals(m_pBuilderInterface, NULL);
//toolbar
//-------
//voxel object buttons
m_pCubeButton = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "CubeButton"));
m_pSphereButton = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "SphereButton"));
g_signal_connect(G_OBJECT(m_pCubeButton), "toggled", G_CALLBACK(setVoxelObjectCallback), this);
g_signal_connect(G_OBJECT(m_pSphereButton), "toggled", G_CALLBACK(setVoxelObjectCallback), this);
g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "ModifyColorToolButton")), "toggled", G_CALLBACK(toggleColorModificationCallback), this);
g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "ModifyTransparencyToolButton")), "toggled", G_CALLBACK(toggleTransparencyModificationCallback), this);
g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "ModifySizeToolButton")), "toggled", G_CALLBACK(toggleSizeModificationCallback), this);
//min voxel scale factor
m_pMinScaleFactorSpinButton = GTK_SPIN_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MinScaleFactorSpinButton"));
m_rVoxelDisplay.setMinScaleFactor(m_f64MinScaleFactor);
gtk_spin_button_configure(
m_pMinScaleFactorSpinButton,
GTK_ADJUSTMENT(gtk_adjustment_new(
m_f64MinScaleFactor, //initial value
0, //lower
5, //upper
0.1, //step increment
0.5, //page increment
0)), //page size - deprecated
0.1, //climb rate
1); //digits
g_signal_connect(G_OBJECT(m_pMinScaleFactorSpinButton), "value-changed", G_CALLBACK(setMinScaleFactorCallback), this);
//max voxel scale factor
m_pMaxScaleFactorSpinButton = GTK_SPIN_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MaxScaleFactorSpinButton"));
m_rVoxelDisplay.setMaxScaleFactor(m_f64MaxScaleFactor);
gtk_spin_button_configure(
m_pMaxScaleFactorSpinButton,
GTK_ADJUSTMENT(gtk_adjustment_new(
m_f64MaxScaleFactor, //initial value
0, //lower
5, //upper
0.1, //step increment
0.5, //page increment
0)), //page size - deprecated
0.1, //climb rate
1); //digits
g_signal_connect(G_OBJECT(m_pMaxScaleFactorSpinButton), "value-changed", G_CALLBACK(setMaxScaleFactorCallback), this);
boolean l_bInclusiveDisplayThresholdBoundary = true;
m_rVoxelDisplay.setDisplayThresholdBoundaryType(l_bInclusiveDisplayThresholdBoundary);
//AND/OR label
m_pThresholdRangeAndOrLabel = GTK_LABEL(gtk_builder_get_object(m_pBuilderInterface, "ThresholdRangeAndOrLabel"));
gtk_label_set_label(m_pThresholdRangeAndOrLabel, l_bInclusiveDisplayThresholdBoundary? "AND" : "OR");
//min display threshold boundary type
m_pMinDisplayThresholdBoundaryButton = GTK_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MinDisplayThresholdBoundaryButton"));
gtk_button_set_label(m_pMinDisplayThresholdBoundaryButton, l_bInclusiveDisplayThresholdBoundary ? ">" : "<");
g_signal_connect(G_OBJECT(m_pMinDisplayThresholdBoundaryButton), "clicked", G_CALLBACK(setMinDisplayThresholdBoundaryTypeCallback), this);
//max display threshold boundary type
m_pMaxDisplayThresholdBoundaryButton = GTK_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MaxDisplayThresholdBoundaryButton"));
gtk_button_set_label(m_pMaxDisplayThresholdBoundaryButton, l_bInclusiveDisplayThresholdBoundary ? "<" : ">");
g_signal_connect(G_OBJECT(m_pMaxDisplayThresholdBoundaryButton), "clicked", G_CALLBACK(setMaxDisplayThresholdBoundaryTypeCallback), this);
//min display threshold slider
m_pMinDisplayThresholdScale = GTK_SCALE(gtk_hscale_new_with_range(0.0, 1.0, 0.01));
m_rVoxelDisplay.setMinDisplayThreshold(m_f64MinDisplayThreshold);
gtk_range_set_value(GTK_RANGE(m_pMinDisplayThresholdScale), m_f64MinDisplayThreshold);
gtk_scale_set_value_pos(m_pMinDisplayThresholdScale, GTK_POS_TOP);
gtk_range_set_update_policy(GTK_RANGE(m_pMinDisplayThresholdScale), GTK_UPDATE_CONTINUOUS);
gtk_widget_set_size_request(GTK_WIDGET(m_pMinDisplayThresholdScale), 100, -1);
gtk_widget_show_all(GTK_WIDGET(m_pMinDisplayThresholdScale));
g_signal_connect(G_OBJECT(m_pMinDisplayThresholdScale), "value_changed", G_CALLBACK(setMinDisplayThresholdCallback), this);
//replace existing scale (which somehow can't be used) with the newly created one
GtkWidget* l_pOldMinScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "MinDisplayThresholdScale"));
GtkWidget* l_pMinScaleParent = gtk_widget_get_parent(l_pOldMinScale);
if(l_pMinScaleParent != NULL && GTK_IS_CONTAINER(l_pMinScaleParent))
{
gtk_container_remove(GTK_CONTAINER(l_pMinScaleParent), l_pOldMinScale);
if(GTK_IS_BOX(l_pMinScaleParent))
{
gtk_box_pack_start(GTK_BOX(l_pMinScaleParent), GTK_WIDGET(m_pMinDisplayThresholdScale), TRUE, TRUE, 0);
gtk_box_reorder_child(GTK_BOX(l_pMinScaleParent), GTK_WIDGET(m_pMinDisplayThresholdScale), 1);
}
}
//max display threshold slider
m_pMaxDisplayThresholdScale = GTK_SCALE(gtk_hscale_new_with_range(0.0, 1.0, 0.01));
m_rVoxelDisplay.setMaxDisplayThreshold(m_f64MaxDisplayThreshold);
gtk_range_set_value(GTK_RANGE(m_pMaxDisplayThresholdScale), m_f64MaxDisplayThreshold);
gtk_scale_set_value_pos(m_pMaxDisplayThresholdScale, GTK_POS_TOP);
gtk_range_set_update_policy(GTK_RANGE(m_pMaxDisplayThresholdScale), GTK_UPDATE_CONTINUOUS);
gtk_widget_set_size_request(GTK_WIDGET(m_pMaxDisplayThresholdScale), 100, -1);
gtk_widget_show_all(GTK_WIDGET(m_pMaxDisplayThresholdScale));
g_signal_connect(G_OBJECT(m_pMaxDisplayThresholdScale), "value_changed", G_CALLBACK(setMaxDisplayThresholdCallback), this);
//replace existing scale (which somehow can't be used) with the newly created one
GtkWidget* l_pOldMaxScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "MaxDisplayThresholdScale"));
GtkWidget* l_pMaxScaleParent = gtk_widget_get_parent(l_pOldMaxScale);
if(l_pMaxScaleParent != NULL && GTK_IS_CONTAINER(l_pMaxScaleParent))
{
gtk_container_remove(GTK_CONTAINER(l_pMaxScaleParent), l_pOldMaxScale);
if(GTK_IS_BOX(l_pMaxScaleParent))
{
gtk_box_pack_start(GTK_BOX(l_pMaxScaleParent), GTK_WIDGET(m_pMaxDisplayThresholdScale), TRUE, TRUE, 0);
gtk_box_reorder_child(GTK_BOX(l_pMaxScaleParent), GTK_WIDGET(m_pMaxDisplayThresholdScale), 1);
}
}
//skull opacity slider
GtkWidget* l_pSkullOpacityScale = gtk_hscale_new_with_range(0.0, 1.0, 0.05);
float64 l_f64SkullOpacity = 0.07;
gtk_range_set_value(GTK_RANGE(l_pSkullOpacityScale), l_f64SkullOpacity);
m_rVoxelDisplay.setSkullOpacity(l_f64SkullOpacity);
gtk_scale_set_value_pos(GTK_SCALE(l_pSkullOpacityScale), GTK_POS_TOP);
gtk_range_set_update_policy(GTK_RANGE(l_pSkullOpacityScale), GTK_UPDATE_CONTINUOUS);
gtk_widget_set_size_request(l_pSkullOpacityScale, 100, -1);
gtk_widget_show_all(l_pSkullOpacityScale);
g_signal_connect(G_OBJECT(l_pSkullOpacityScale), "value_changed", G_CALLBACK(setSkullOpacityCallback), this);
//replace existing scale (which somehow can't be used) with the newly created one
GtkWidget* l_pOldScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "SkullOpacityScale"));
GtkWidget* l_pScaleParent = gtk_widget_get_parent(l_pOldScale);
if(l_pScaleParent != NULL && GTK_IS_CONTAINER(l_pScaleParent))
{
gtk_container_remove(GTK_CONTAINER(l_pScaleParent), l_pOldScale);
if(GTK_IS_BOX(l_pScaleParent))
{
gtk_box_pack_start(GTK_BOX(l_pScaleParent), l_pSkullOpacityScale, TRUE, TRUE, 0);
gtk_box_reorder_child(GTK_BOX(l_pScaleParent), l_pSkullOpacityScale, 0);
}
}
//camera animation button
GtkToggleToolButton* l_pAnimateCameraButton = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "AnimateCameraButton"));
g_signal_connect(G_OBJECT(l_pAnimateCameraButton), "toggled", G_CALLBACK(toggleAnimateCameraCallback), this);
//reposition camera
g_signal_connect(G_OBJECT(gtk_builder_get_object(m_pBuilderInterface, "RepositionCamera")), "clicked", G_CALLBACK(repositionCameraCallback), this);
this->toggleColorModificationCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ModifyColorToolButton")))?true:false);
this->toggleTransparencyModificationCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ModifyTransparencyToolButton")))?true:false);
this->toggleSizeModificationCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ModifySizeToolButton")))?true:false);
this->enableAutoCameraMovementCB(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "AnimateCameraButton")))?true:false);
}
CTopographicMap3DView::CTopographicMap3DView(CTopographicMap3DDisplay& rTopographicMap3DDisplay,
CTopographicMapDatabase& rTopographicMapDatabase, uint64 ui64DefaultInterpolation, float64 f64Delay) :
m_rTopographicMap3DDisplay(rTopographicMap3DDisplay),
m_rTopographicMapDatabase(rTopographicMapDatabase),
m_f64MaxDelay(2.0), //maximum delay : 2s
m_pBuilderInterface(NULL),
m_ui64CurrentInterpolation(ui64DefaultInterpolation),
m_pMapPotentials(NULL),
m_pMapCurrents(NULL),
m_pElectrodesToggleButton(NULL),
m_bElectrodesToggledOn(false)//,
//m_pSamplingPointsToggleButton(NULL),
//m_bSamplingPointsToggledOn(false)
{
//load the gtk builder interface
m_pBuilderInterface=gtk_builder_new(); // glade_xml_new(OpenViBE::Directories::getDataDir() + "/openvibe-plugins/simple-visualisation/openvibe-simple-visualisation-TopographicMap3D.ui", NULL, NULL);
gtk_builder_add_from_file(m_pBuilderInterface, OpenViBE::Directories::getDataDir() + "/openvibe-plugins/simple-visualisation/openvibe-simple-visualisation-TopographicMap3D.ui", NULL);
if(!m_pBuilderInterface)
{
g_warning("Couldn't load the interface!");
return;
}
gtk_builder_connect_signals(m_pBuilderInterface, NULL);
//toolbar
//-------
//get pointers to interpolation type buttons
m_pMapPotentials = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MapPotentials"));
m_pMapCurrents = GTK_RADIO_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "MapCurrents"));
g_signal_connect(G_OBJECT(m_pMapPotentials), "toggled", G_CALLBACK (setInterpolationCallback), this);
g_signal_connect(G_OBJECT(m_pMapCurrents), "toggled", G_CALLBACK (setInterpolationCallback), this);
//get pointer to electrodes toggle button
m_pElectrodesToggleButton = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ToggleElectrodes"));
//disable electrodes by default
m_bElectrodesToggledOn = false;
gtk_toggle_tool_button_set_active(m_pElectrodesToggleButton, m_bElectrodesToggledOn);
//connect callback
g_signal_connect(G_OBJECT(m_pElectrodesToggleButton), "toggled", G_CALLBACK(toggleElectrodesCallback), this);
//get pointer to sampling points toggle button
//m_pSamplingPointsToggleButton = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(m_pBuilderInterface, "ToggleSamplingPoints"));
//disable sampling points by default
//m_bSamplingPointsToggledOn = false;
//gtk_toggle_tool_button_set_active(m_pSamplingPointsToggleButton, m_bSamplingPointsToggledOn);
//connect callback
//g_signal_connect(G_OBJECT(m_pSamplingPointsToggleButton), "toggled", G_CALLBACK(toggleSamplingPointsCallback), this);
//tell database about maximum delay
m_rTopographicMapDatabase.adjustNumberOfDisplayedBuffers(m_f64MaxDelay);
//ensure default delay lies in [0, m_f64MaxDelay]
if(f64Delay > m_f64MaxDelay)
{
f64Delay = m_f64MaxDelay;
}
//set default delay
setDelayCB(f64Delay);
//configure delay slider
GtkWidget* l_pDelayScale = gtk_hscale_new_with_range(0.0, m_f64MaxDelay, 0.1);
gtk_range_set_value(GTK_RANGE(l_pDelayScale), f64Delay);
gtk_scale_set_value_pos(GTK_SCALE(l_pDelayScale), GTK_POS_TOP);
gtk_range_set_update_policy(GTK_RANGE(l_pDelayScale), GTK_UPDATE_CONTINUOUS);
gtk_widget_set_size_request(l_pDelayScale, 100, -1);
gtk_widget_show_all(l_pDelayScale);
g_signal_connect(G_OBJECT(l_pDelayScale), "value_changed", G_CALLBACK(setDelayCallback), this);
//replace existing scale (which somehow can't be used) with the newly created one
GtkWidget* l_pOldScale = GTK_WIDGET(gtk_builder_get_object(m_pBuilderInterface, "DelayScale"));
GtkWidget* l_pScaleParent = gtk_widget_get_parent(l_pOldScale);
if(l_pScaleParent != NULL && GTK_IS_CONTAINER(l_pScaleParent))
{
gtk_container_remove(GTK_CONTAINER(l_pScaleParent), l_pOldScale);
if(GTK_IS_BOX(l_pScaleParent))
{
gtk_box_pack_start(GTK_BOX(l_pScaleParent), l_pDelayScale, TRUE, TRUE, 0);
gtk_box_reorder_child(GTK_BOX(l_pScaleParent), l_pDelayScale, 0);
}
}
}
/*
* Writes the source code needed to create this widget.
* You have to output everything necessary to create the widget here, though
* there are some convenience functions to help.
*/
static void
gb_radio_tool_button_write_source (GtkWidget * widget, GbWidgetWriteSourceData * data)
{
GladeFindGroupData find_data;
GtkWidget *group_widget;
gchar *stock_id, *label, *icon_name;
gchar buffer[256], *group_name;
gboolean translatable, context;
gchar *comments;
stock_id = gtk_object_get_data (GTK_OBJECT (widget),
GladeToolButtonStockIDKey);
icon_name = gtk_object_get_data (GTK_OBJECT (widget),
GladeToolButtonIconKey);
label = (gchar*) gtk_tool_button_get_label (GTK_TOOL_BUTTON (widget));
glade_util_get_translation_properties (widget, Label, &translatable,
&comments, &context);
find_data.group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (widget));
find_data.found_widget = NULL;
gb_widget_children_foreach (widget->parent,
(GtkCallback) find_radio_group,
&find_data);
group_widget = find_data.found_widget;
if (!group_widget)
{
g_warning ("Radiotoolbutton has no group");
group_widget = widget;
}
group_name = (char*) gtk_widget_get_name (group_widget);
group_name = source_create_valid_identifier (group_name);
sprintf (buffer, " GSList *%s_group = NULL;\n", group_name);
source_ensure_decl (data, buffer);
if (data->create_widget)
{
if (stock_id)
{
/* Stock Button */
source_add (data,
" %s = (GtkWidget*) gtk_radio_tool_button_new_from_stock (NULL, %s);\n",
data->wname, source_make_string (stock_id, FALSE));
}
else if (icon_name)
{
/* Icon and Label */
source_add (data,
" %s = (GtkWidget*) gtk_radio_tool_button_new (NULL);\n",
data->wname);
source_add_translator_comments (data, translatable, comments);
source_add (data,
" gtk_tool_button_set_label (GTK_TOOL_BUTTON (%s), %s);\n",
data->wname,
label ? source_make_string_full (label, data->use_gettext && translatable, context) : "NULL");
source_ensure_decl (data, " GtkWidget *tmp_image;\n");
if (glade_util_check_is_stock_id (icon_name))
{
source_add (data,
" tmp_image = gtk_image_new_from_stock (\"%s\", tmp_toolbar_icon_size);\n",
icon_name);
}
else
{
source_create_pixmap (data, "tmp_image", icon_name);
}
source_add (data, " gtk_widget_show (tmp_image);\n");
source_add (data,
" gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (%s), tmp_image);\n",
data->wname);
}
else
{
/* Just a Label */
source_add (data,
" %s = (GtkWidget*) gtk_radio_tool_button_new (NULL);\n",
data->wname);
source_add_translator_comments (data, translatable, comments);
source_add (data,
" gtk_tool_button_set_label (GTK_TOOL_BUTTON (%s), %s);\n",
data->wname,
label ? source_make_string_full (label, data->use_gettext && translatable, context) : "NULL");
}
}
gb_widget_write_standard_source (widget, data);
source_add (data,
" gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (%s), %s_group);\n",
data->wname, group_name);
source_add (data,
" %s_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (%s));\n",
group_name, data->wname);
if (data->widget_data->flags & GLADE_ACTIVE)
{
source_add (data,
" gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (%s), TRUE);\n",
data->wname);
}
if (gtk_object_get_data (GTK_OBJECT (widget), VisibleHorz) != NULL)
{
source_add (data,
" gtk_tool_item_set_visible_horizontal (GTK_TOOL_ITEM (%s), FALSE);\n",
data->wname);
}
if (gtk_object_get_data (GTK_OBJECT (widget), VisibleVert) != NULL)
{
source_add (data,
" gtk_tool_item_set_visible_vertical (GTK_TOOL_ITEM (%s), FALSE);\n",
data->wname);
}
if (gtk_tool_item_get_is_important (GTK_TOOL_ITEM (widget)))
{
source_add (data,
" gtk_tool_item_set_is_important (GTK_TOOL_ITEM (%s), TRUE);\n",
data->wname);
}
g_free (group_name);
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_radio_tool_button_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gboolean active;
gchar *group_name;
gb_tool_button_set_standard_properties (widget, data,
StockButton, Label, Icon,
VisibleHorz, VisibleVert,
IsImportant);
active = gb_widget_input_bool (data, Active);
if (data->apply)
{
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (widget),
active);
if (active)
data->widget_data->flags |= GLADE_ACTIVE;
else
data->widget_data->flags &= ~GLADE_ACTIVE;
}
/* Find any widgets in given group and set this widgets group.
If group is NULL try to find radiobuttons with same parent and use
their group. If these don't succeed, set group to NULL. */
group_name = gb_widget_input_combo (data, Group);
if (data->apply)
{
GSList *old_group, *new_group = NULL;
old_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (widget));
if (group_name && (group_name[0] == '\0'
|| !strcmp (group_name, _("New Group"))))
group_name = NULL;
if (group_name)
{
GladeFindGroupWidgetData find_data;
find_data.name = group_name;
find_data.found_widget = NULL;
gb_widget_children_foreach (widget->parent,
(GtkCallback) find_group_widget,
&find_data);
if (find_data.found_widget)
new_group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (find_data.found_widget));
else if (data->action == GB_LOADING)
g_warning ("Invalid radio group: %s\n (Note that forward references are not allowed in Glade files)", group_name);
}
#if 0
g_print ("New Group: %p Old Group: %p\n", new_group, old_group);
#endif
if (new_group != old_group)
{
#if 0
g_print ("##### setting radio group: %s\n",
group_name ? group_name : "NULL");
#endif
gtk_radio_tool_button_set_group (GTK_RADIO_TOOL_BUTTON (widget),
new_group);
}
}
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window, *toolbar, *grid, *treeview, *scrolled_window;
GtkWidget *hbox, *hbox1, *hbox2, *checkbox, *option_menu, *menu;
gint i;
static const gchar *toolbar_styles[] = { "icons", "text", "both (vertical)",
"both (horizontal)" };
GtkToolItem *item;
GtkListStore *store;
GtkWidget *image;
GtkWidget *menuitem;
GtkWidget *button;
GtkWidget *label;
GIcon *gicon;
GSList *group;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
toolbar = gtk_toolbar_new ();
gtk_widget_set_vexpand (toolbar, TRUE);
gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 0, 2, 1);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
gtk_container_set_border_width (GTK_CONTAINER (hbox1), 5);
gtk_widget_set_vexpand (hbox1, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox1, 1, 1, 1, 1);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_container_set_border_width (GTK_CONTAINER (hbox2), 5);
gtk_widget_set_vexpand (hbox2, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox2, 1, 2, 1, 1);
checkbox = gtk_check_button_new_with_mnemonic("_Vertical");
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_orientation), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Show Arrow");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
g_signal_connect (checkbox, "toggled",
G_CALLBACK (change_show_arrow), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Toolbar Style:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_toolbar_style_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox1), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
gtk_widget_set_sensitive (option_menu, FALSE);
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
for (i = 0; i < G_N_ELEMENTS (toolbar_styles); i++)
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), toolbar_styles[i]);
gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu),
gtk_toolbar_get_style (GTK_TOOLBAR (toolbar)));
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (change_toolbar_style), toolbar);
checkbox = gtk_check_button_new_with_mnemonic("_Set Icon Size:");
g_signal_connect (checkbox, "toggled", G_CALLBACK (set_icon_size_toggled), toolbar);
gtk_box_pack_start (GTK_BOX (hbox2), checkbox, FALSE, FALSE, 0);
option_menu = gtk_combo_box_text_new ();
g_object_set_data (G_OBJECT (checkbox), "option-menu", option_menu);
gtk_widget_set_sensitive (option_menu, FALSE);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "small toolbar");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (option_menu), "large toolbar");
gtk_box_pack_start (GTK_BOX (hbox2), option_menu, FALSE, FALSE, 0);
g_signal_connect (option_menu, "changed",
G_CALLBACK (icon_size_history_changed), toolbar);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_hexpand (scrolled_window, TRUE);
gtk_widget_set_vexpand (scrolled_window, TRUE);
gtk_grid_attach (GTK_GRID (grid), scrolled_window, 1, 3, 1, 1);
store = create_items_list (&treeview);
gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-new");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Custom label");
add_item_to_list (store, item, "New");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb, item);
gtk_tool_item_set_expand (item, TRUE);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("Menuitem %d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Open");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "Open");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gdk_threads_add_timeout (3000, (GSourceFunc) timeout_cb1, item);
menu = gtk_menu_new ();
for (i = 0; i < 20; i++)
{
char *text;
text = g_strdup_printf ("A%d", i);
menuitem = gtk_menu_item_new_with_label (text);
g_free (text);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
}
item = gtk_menu_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
gtk_menu_tool_button_set_menu (GTK_MENU_TOOL_BUTTON (item), menu);
add_item_to_list (store, item, "BackWithHistory");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("dialog-warning", GTK_ICON_SIZE_DIALOG);
item = gtk_tool_item_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (item), image);
add_item_to_list (store, item, "(Custom Item)");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Back");
add_item_to_list (store, item, "Back");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next");
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), "Forward");
add_item_to_list (store, item, "Forward");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-text-bold");
g_signal_connect (item, "toggled", G_CALLBACK (bold_toggled), NULL);
add_item_to_list (store, item, "Bold");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
item = gtk_separator_tool_item_new ();
add_item_to_list (store, item, "-----");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_item_set_expand (item, TRUE);
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
g_assert (gtk_toolbar_get_nth_item (GTK_TOOLBAR (toolbar), 0) != 0);
item = gtk_radio_tool_button_new (NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-left");
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Left");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-center");
make_prop_editor (G_OBJECT (item));
group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (item));
add_item_to_list (store, item, "Center");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_radio_tool_button_new (group);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "format-justify-right");
add_item_to_list (store, item, "Right");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (gtk_image_new_from_file ("apple-red.png"), "_Apple");
add_item_to_list (store, item, "Apple");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (item), TRUE);
gicon = g_content_type_get_icon ("video/ogg");
image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_LARGE_TOOLBAR);
g_object_unref (gicon);
item = gtk_tool_button_new (image, "Video");
add_item_to_list (store, item, "Video");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_image_new_from_icon_name ("utilities-terminal", GTK_ICON_SIZE_LARGE_TOOLBAR);
item = gtk_tool_button_new (image, "Terminal");
add_item_to_list (store, item, "Terminal");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
image = gtk_spinner_new ();
gtk_spinner_start (GTK_SPINNER (image));
item = gtk_tool_button_new (image, "Spinner");
add_item_to_list (store, item, "Spinner");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_widget_set_hexpand (hbox, TRUE);
gtk_grid_attach (GTK_GRID (grid), hbox, 1, 4, 1, 1);
button = gtk_button_new_with_label ("Drag me to the toolbar");
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
label = gtk_label_new ("Drop index:");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new ("");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
checkbox = gtk_check_button_new_with_mnemonic("_Right to left");
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), TRUE);
else
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbox), FALSE);
g_signal_connect (checkbox, "toggled", G_CALLBACK (rtl_toggled), NULL);
gtk_box_pack_end (GTK_BOX (hbox), checkbox, FALSE, FALSE, 0);
gtk_drag_source_set (button, GDK_BUTTON1_MASK,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
gtk_drag_dest_set (toolbar, GTK_DEST_DEFAULT_DROP,
target_table, G_N_ELEMENTS (target_table),
GDK_ACTION_MOVE);
g_signal_connect (toolbar, "drag_motion",
G_CALLBACK (toolbar_drag_motion), NULL);
g_signal_connect (toolbar, "drag_leave",
G_CALLBACK (toolbar_drag_leave), NULL);
g_signal_connect (toolbar, "drag_drop",
G_CALLBACK (toolbar_drag_drop), label);
gtk_widget_show_all (window);
make_prop_editor (G_OBJECT (toolbar));
g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (toolbar, "popup_context_menu", G_CALLBACK (popup_context_menu), NULL);
gtk_main ();
return 0;
}
GtkWidget* ptk_toolbar_add_items_from_data( GtkWidget* toolbar,
PtkToolItemEntry* entries,
gpointer cb_data,
GtkTooltips* tooltips )
{
GtkWidget* btn;
PtkToolItemEntry* ent;
GtkWidget* image;
GtkWidget* menu;
GtkIconSize icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
GSList* radio_group = NULL;
for( ent = entries; ; ++ent )
{
/* Normal tool item */
if( G_LIKELY( ent->stock_icon || ent->tooltip || ent->label ) )
{
/* Stock item */
if( G_LIKELY(ent->stock_icon) )
image = gtk_image_new_from_stock( ent->stock_icon, icon_size );
else
image = NULL;
if( G_LIKELY( ! ent->menu ) ) { /* Normal button */
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_tool_button_new_from_stock ( ent->label ));
else
btn = GTK_WIDGET(gtk_tool_button_new ( image, _(ent->label) ));
}
else if( G_UNLIKELY( PTK_IS_CHECK_TOOL_ITEM(ent) ) ) {
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_toggle_tool_button_new_from_stock(ent->label));
else {
btn = GTK_WIDGET(gtk_toggle_tool_button_new ());
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(btn), image );
gtk_tool_button_set_label(GTK_TOOL_BUTTON(btn), _(ent->label));
}
}
else if( G_UNLIKELY( PTK_IS_RADIO_TOOL_ITEM(ent) ) ) {
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_radio_tool_button_new_from_stock( radio_group, ent->label ));
else {
btn = GTK_WIDGET(gtk_radio_tool_button_new( radio_group ));
if( G_LIKELY( PTK_IS_RADIO_TOOL_ITEM( (ent + 1) ) ) )
radio_group = gtk_radio_tool_button_get_group( GTK_RADIO_TOOL_BUTTON(btn) );
else
radio_group = NULL;
gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(btn), image );
gtk_tool_button_set_label(GTK_TOOL_BUTTON(btn), _(ent->label));
}
}
else if( ent->menu ) {
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) )
btn = GTK_WIDGET(gtk_menu_tool_button_new_from_stock ( ent->label ));
else {
btn = GTK_WIDGET(gtk_menu_tool_button_new ( image, _(ent->label) ));
if( G_LIKELY( 3 < (int)ent->menu ) ) { /* Sub menu */
menu = ptk_menu_new_from_data( ent->menu, cb_data, NULL );
gtk_menu_tool_button_set_menu( GTK_MENU_TOOL_BUTTON(btn), menu );
}
}
}
if( G_LIKELY(ent->callback) ) { /* Callback */
if( G_LIKELY( ent->menu == NULL || ent->menu == PTK_EMPTY_MENU) )
g_signal_connect( btn, "clicked", ent->callback, cb_data);
else
g_signal_connect( btn, "toggled", ent->callback, cb_data);
}
if( G_LIKELY(ent->tooltip) )
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (btn), tooltips, _(ent->tooltip), NULL);
}
else
{
if( ! PTK_IS_SEPARATOR_TOOL_ITEM(ent) ) /* End of menu */
break;
btn = (GtkWidget*)gtk_separator_tool_item_new ();
}
gtk_toolbar_insert ( GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(btn), -1 );
if( G_UNLIKELY(ent->ret) ) {/* Return */
*ent->ret = btn;
ent->ret = NULL;
}
}
return NULL;
}
