static void save_widgets_to_ini(FILE *f)
{
char buf[0x1000];
snprintf(buf, sizeof(buf), "load_fir_filter_file = %s\n"
"dds_mode_tx1 = %i\n"
"dds_mode_tx2 = %i\n"
"dac_buf_filename = %s\n"
"tx_channel_0 = %i\n"
"tx_channel_1 = %i\n"
"tx_channel_2 = %i\n"
"tx_channel_3 = %i\n"
"global_settings_show = %i\n"
"tx_show = %i\n"
"rx_show = %i\n"
"fpga_show = %i\n",
last_fir_filter,
dac_data_manager_get_dds_mode(dac_tx_manager, DDS_DEVICE, 1),
dac_data_manager_get_dds_mode(dac_tx_manager, DDS_DEVICE, 2),
dac_data_manager_get_buffer_chooser_filename(dac_tx_manager),
dac_data_manager_get_tx_channel_state(dac_tx_manager, 0),
dac_data_manager_get_tx_channel_state(dac_tx_manager, 1),
dac_data_manager_get_tx_channel_state(dac_tx_manager, 2),
dac_data_manager_get_tx_channel_state(dac_tx_manager, 3),
!!gtk_toggle_tool_button_get_active(section_toggle[SECTION_GLOBAL]),
!!gtk_toggle_tool_button_get_active(section_toggle[SECTION_TX]),
!!gtk_toggle_tool_button_get_active(section_toggle[SECTION_RX]),
!!gtk_toggle_tool_button_get_active(section_toggle[SECTION_FPGA]));
fwrite(buf, 1, strlen(buf), f);
}
/* Callback on dice press */
gint
modify_dice (GtkWidget * widget, gpointer data)
{
DiceInfo *tmp = (DiceInfo *) data;
GtkToggleToolButton *button = GTK_TOGGLE_TOOL_BUTTON (widget);
/* Don't modify dice if player is marked finished or computer is playing */
if (players[CurrentPlayer].finished || players[CurrentPlayer].comp) {
if (gtk_toggle_tool_button_get_active (button))
gtk_toggle_tool_button_set_active (button, FALSE);
return TRUE;
}
if (NumberOfRolls >= NUM_ROLLS) {
say (_("You are only allowed three rolls. Choose a score slot."));
gtk_toggle_tool_button_set_active (button, FALSE);
return TRUE;
}
tmp->sel = gtk_toggle_tool_button_get_active (button);
UpdateAllDicePixmaps ();
update_roll_button_sensitivity ();
return TRUE;
}
void CMatchingDlg::OnButtonClicked(GtkWidget *pBtn)
{
if (!m_Updating) {
m_Updating = true;
if (pBtn==m_FrameBtn) {
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_FrameBtn))) {
SetSelectMode(REFERENCE_FRAME);
UpdatePreview(true);
UpdateControls();
}
} else if (pBtn==m_CatalogBtn) {
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_CatalogBtn))) {
SetSelectMode(CATALOG_FILE);
UpdatePreview(true);
UpdateControls();
}
} else if (pBtn==GTK_WIDGET(m_ShowChart)) {
if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowChart))) {
SetDisplayMode(DISPLAY_CHART);
UpdatePreview(true);
UpdateControls();
}
} else if (pBtn==GTK_WIDGET(m_ShowImage)) {
if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowImage))) {
SetDisplayMode(DISPLAY_IMAGE);
UpdatePreview(true);
UpdateControls();
}
} else if (pBtn==m_PathBtn)
ChangeCatalogPath();
else if (pBtn==m_OptionsBtn)
EditPreferences();
m_Updating = false;
}
}
void
ghb_preview_set_visible(signal_user_data_t *ud)
{
gint title_id, titleindex;
const hb_title_t *title;
GtkToggleToolButton *button;
GtkWidget *widget;
gboolean active;
button = GTK_TOGGLE_TOOL_BUTTON(GHB_WIDGET(ud->builder, "show_preview"));
active = gtk_toggle_tool_button_get_active(button);
title_id = ghb_dict_get_int(ud->settings, "title");
title = ghb_lookup_title(title_id, &titleindex);
active &= title != NULL;
widget = GHB_WIDGET(ud->builder, "preview_window");
gtk_widget_set_visible(widget, active);
if (active)
{
gint x, y;
x = ghb_dict_get_int(ud->prefs, "preview_x");
y = ghb_dict_get_int(ud->prefs, "preview_y");
if (x >= 0 && y >= 0)
gtk_window_move(GTK_WINDOW(widget), x, y);
}
}
/*#
@method get_active GtkToggleToolButton
@brief Queries a GtkToggleToolButton and returns its current state.
@return TRUE if the toggle tool button is pressed in, FALSE if not
Returns TRUE if the toggle button is pressed in and FALSE if it is raised.
*/
FALCON_FUNC ToggleToolButton::get_active( VMARG )
{
NO_ARGS
MYSELF;
GET_OBJ( self );
vm->retval( (bool) gtk_toggle_tool_button_get_active( (GtkToggleToolButton*)_obj ) );
}
void AbstractToolItem::toolButtonCallback(GtkToolButton* toolbutton, AbstractToolItem* item)
{
XOJ_CHECK_TYPE_OBJ(item, AbstractToolItem);
if (toolbutton && GTK_IS_TOGGLE_TOOL_BUTTON(toolbutton))
{
bool selected = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toolbutton));
// ignore this event... GTK Broadcast to much events, e.g. if you call set_active
if (item->toolToggleButtonActive == selected)
{
return;
}
// don't allow deselect this button
if (item->toolToggleOnlyEnable && selected == false)
{
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolbutton), true);
return;
}
item->toolToggleButtonActive = selected;
}
item->activated(NULL, NULL, toolbutton);
}
JNIEXPORT jboolean JNICALL
Java_org_gnome_gtk_GtkToggleToolButton_gtk_1toggle_1tool_1button_1get_1active
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
gboolean result;
jboolean _result;
GtkToggleToolButton* self;
// convert parameter self
self = (GtkToggleToolButton*) _self;
// call function
result = gtk_toggle_tool_button_get_active(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jboolean) result;
// and finally
return _result;
}
extern gboolean show_hide(GtkWidget *widget, GtkCheckButton* button)
{
gboolean flag = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(button));
(flag ? gtk_widget_show : gtk_widget_hide)(widget);
return FALSE;
}
void
on_fill_mode_radiotoolbutton_toggled (GtkToggleToolButton * toggletoolbutton,
gpointer user_data)
{
if (gtk_toggle_tool_button_get_active (toggletoolbutton))
Editor::instance ()->changeMode (Editor::em_Fill);
}
gboolean ui_callback_on_filters_enabled(GtkToolButton *button, gpointer data)
{
gboolean enabled;
gboolean changed;
enabled = gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON(button));
g_info("Filters enabled event occurred %d", enabled);
changed = ui_filters_enable (enabled);
if (changed)
{
/* Set the tool tip text */
if (enabled)
{
gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM(button), "Disable messages filtering");
}
else
{
gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM(button), "Enable messages filtering");
}
ui_tree_view_refilter ();
}
return TRUE;
}
void
on_createPointFeatures_mode_radiotoolbutton_toggled
(GtkToggleToolButton * toggletoolbutton, gpointer user_data)
{
if (gtk_toggle_tool_button_get_active (toggletoolbutton))
Editor::instance ()->changeMode (Editor::em_CreatePointFeatures);
}
void GTKGeomWindow::menuitem_tool_change( GtkToolButton *button )
{
//std::cout << "GTKGeomWindow: ";
int tool;
const char *label = gtk_tool_button_get_label( button );
if( !strcmp( label, "Particle diagnostics" ) ) {
//std::cout << "TOOL_PARTICLE_DIAG ";
tool = TOOL_PARTICLE_DIAG;
} else if( !strcmp( label, "Field diagnostics" ) ) {
//std::cout << "TOOL_FIELD_DIAG ";
tool = TOOL_FIELD_DIAG;
} else {
//std::cout << "TOOL_UNKNOWN\n";
tool = TOOL_UNKNOWN;
return;
}
if( !gtk_toggle_tool_button_get_active( GTK_TOGGLE_TOOL_BUTTON(button) ) ) {
// Disable tool
//std::cout << "disable\n";
_tool = TOOL_UNKNOWN;
} else {
// Enable tool
//std::cout << "enable\n";
_tool = tool;
}
}
static gboolean
emoticon_tool_button_press_event (GtkWidget *widget,
GdkEventButton *event)
{
EEmoticonToolButton *button;
GtkToggleToolButton *toggle_button;
GtkWidget *event_widget;
button = E_EMOTICON_TOOL_BUTTON (widget);
event_widget = gtk_get_event_widget ((GdkEvent *) event);
if (event_widget == button->priv->window)
return TRUE;
if (event_widget != widget)
return FALSE;
toggle_button = GTK_TOGGLE_TOOL_BUTTON (widget);
if (gtk_toggle_tool_button_get_active (toggle_button))
return FALSE;
e_emoticon_tool_button_popup (button);
button->priv->popup_in_progress = TRUE;
return TRUE;
}
static gboolean
emoticon_tool_button_button_release_event_cb (EEmoticonToolButton *button,
GdkEventButton *event)
{
GtkToggleToolButton *tool_button;
GtkWidget *event_widget;
gboolean popup_in_progress;
tool_button = GTK_TOGGLE_TOOL_BUTTON (button);
event_widget = gtk_get_event_widget ((GdkEvent *) event);
popup_in_progress = button->priv->popup_in_progress;
button->priv->popup_in_progress = FALSE;
if (event_widget != GTK_WIDGET (button))
goto popdown;
if (popup_in_progress)
return FALSE;
if (gtk_toggle_tool_button_get_active (tool_button))
goto popdown;
return FALSE;
popdown:
e_emoticon_tool_button_popdown (button);
return TRUE;
}
static void
update_roll_button_sensitivity (void)
{
gboolean state = FALSE;
gint i;
for (i = 0; i < NUMBER_OF_DICE; i++)
state |=
gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (diceBox[i]));
if(!state){
gtk_button_set_label (GTK_BUTTON (mbutton), _("Roll all!"));
state = TRUE;
} else {
gtk_button_set_label (GTK_BUTTON (mbutton), _("Roll!"));
state = TRUE;
}
state &= NumberOfRolls < 3;
state &= !players[CurrentPlayer].comp;
if(GameIsOver ()){
state = FALSE;
}
gtk_widget_set_sensitive (GTK_WIDGET (mbutton), state);
}
void ToolDrawCombocontrol::selected(ActionGroup group, ActionType action)
{
XOJ_CHECK_TYPE(ToolDrawCombocontrol);
if (!this->item)
{
return;
}
if (!GTK_IS_TOGGLE_TOOL_BUTTON(this->item))
{
g_warning("ToolDrawCombocontrol: selected action %i which is not a toggle action!", action);
return;
}
string description;
for (ToolDrawType* t : drawTypes)
{
if (action == t->type && this->action != t->type)
{
this->action = t->type;
gtk_image_set_from_icon_name(GTK_IMAGE(iconWidget), t->icon.c_str(), GTK_ICON_SIZE_SMALL_TOOLBAR);
description = t->name;
break;
}
}
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(item), description.c_str());
if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(this->item)) != (this->action == action))
{
this->toolToggleButtonActive = (this->action == action);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(this->item), this->toolToggleButtonActive);
}
}
void ZLGtkApplicationWindow::setToggleButtonState(const ZLToolbar::ToggleButtonItem &button) {
GtkToggleToolButton *gtkButton =
GTK_TOGGLE_TOOL_BUTTON(myAbstractToGtk[&(ZLToolbar::Item&)button]);
const bool isPressed = button.isPressed();
if (gtk_toggle_tool_button_get_active(gtkButton) != isPressed) {
gtk_toggle_tool_button_set_active(gtkButton, isPressed);
}
}
static void on_click_category_button (GtkButton *button, gpointer data)
{
if (! gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON (button)))
return;
myData.iCurrentCaterogy = GPOINTER_TO_INT (data);
cd_debug ("filter on category %d", myData.iCurrentCaterogy);
cd_trigger_search ();
}
static void toggleJavascript(GtkWidget* item, WebKitWebView* webView) {
gboolean js;
WebKitWebSettings* settings = webkit_web_view_get_settings(
WEBKIT_WEB_VIEW(webView));
js = gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(item));
g_object_set(G_OBJECT(settings), "enable-scripts", js, NULL);
webkit_web_view_reload(webView);
}
void
on_dedicated_button_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
if(gtk_toggle_tool_button_get_active((GtkToggleToolButton*)toolbutton)==FALSE)
return;
ArenaStatus(3,1);
}
static void menu_button_cb (void)
{
if (gtk_toggle_tool_button_get_active ((GtkToggleToolButton *) menu_button))
gtk_menu_popup ((GtkMenu *) menu_main, NULL, NULL, menu_position_cb,
menu_button, 0, gtk_get_current_event_time ());
else
gtk_widget_hide (menu_main);
}
static void toggleDownload(GtkWidget* item, WebKitWebView* webView) {
use_dlmanager = gtk_toggle_tool_button_get_active(
GTK_TOGGLE_TOOL_BUTTON(item));
if (use_dlmanager == TRUE) {
dl_command = "dlu";
} else {
dl_command = "dlw";
}
}
static void
case_sensitive_toggled_callback (GtkToggleToolButton *button,
void *data)
{
EggFindBar *find_bar = EGG_FIND_BAR (data);
egg_find_bar_set_case_sensitive (find_bar,
gtk_toggle_tool_button_get_active (button));
}
gboolean ui_callback_on_enable_filters(GtkWidget *widget, gpointer data)
{
gboolean enabled;
enabled = gtk_toggle_tool_button_get_active (GTK_TOGGLE_TOOL_BUTTON(ui_main_data.filters_enabled));
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON(ui_main_data.filters_enabled), !enabled);
return TRUE;
}
void
on_toggle_timestamp_toggled (GtkToggleToolButton *toggletoolbutton,
gpointer user_data)
{
extern struct config_struct options_file;
if(gtk_toggle_tool_button_get_active(toggletoolbutton)==FALSE)
options_file.time_used=0;
else
options_file.time_used=1;
}
/* on_engineering_fullscreen_toggled */
static void _on_engineering_fullscreen_toggled(gpointer data)
{
Engineering * engineering = data;
if(gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(
engineering->tb_fullscreen)))
gtk_window_fullscreen(GTK_WINDOW(engineering->window));
else
gtk_window_unfullscreen(GTK_WINDOW(engineering->window));
}
static void
emoticon_tool_button_toggled (GtkToggleToolButton *button)
{
if (gtk_toggle_tool_button_get_active (button))
e_emoticon_tool_button_popup (
E_EMOTICON_TOOL_BUTTON (button));
else
e_emoticon_tool_button_popdown (
E_EMOTICON_TOOL_BUTTON (button));
}
static void
debug_dialog_pause_toggled_cb (GtkToggleToolButton *pause,
EmpathyDebugDialog *debug_dialog)
{
EmpathyDebugDialogPriv *priv = GET_PRIV (debug_dialog);
priv->paused = gtk_toggle_tool_button_get_active (pause);
debug_dialog_set_enabled (debug_dialog, !priv->paused);
}
//"Info" toolbar button handler
void onWindowToggled(GtkWidget *widget, gpointer window) {
GdkColor bgColor;
gdk_color_parse("black", &bgColor);
gtk_widget_modify_bg(GTK_WIDGET(window), GTK_STATE_NORMAL, &bgColor);
if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(widget)))
gtk_widget_show_all(GTK_WIDGET(window));
else
gtk_widget_hide_all(GTK_WIDGET(window));
}
/*static void reset_grid()
{
}*/
void toggle_callback(GtkToggleToolButton* w,gpointer data)
{
if(gtk_toggle_tool_button_get_active(w)==FALSE)return;
GObject* widget=(GObject*)w;
if(widget==gtk_builder_get_object(builder,"wirebutton"))draw_state=PLACE_WIRE;
if(widget==gtk_builder_get_object(builder,"resistorbutton"))draw_state=PLACE_RESISTOR;
if(widget==gtk_builder_get_object(builder,"batterybutton"))draw_state=PLACE_BATTERY;
if(widget==gtk_builder_get_object(builder,"deletebutton"))draw_state=DELETE;
if(widget==gtk_builder_get_object(builder,"editbutton"))draw_state=EDIT;
}
