void CMatchingDlg::SetSelectMode(tSelectMode mode)
{
m_SelectMode = mode;
switch (mode)
{
case REFERENCE_FRAME:
gtk_label_set_markup(GTK_LABEL(m_SelLabel), "<b>Select a reference frame</b>");
gtk_widget_hide(m_CatalogBox);
gtk_widget_hide(m_PathLabel);
gtk_widget_hide(m_PathEntry);
gtk_widget_hide(m_PathBtn);
gtk_widget_show(m_FrameBox);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowChart),
m_DMFrame == DISPLAY_CHART);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowImage),
m_DMFrame == DISPLAY_IMAGE);
break;
case CATALOG_FILE:
gtk_label_set_markup(GTK_LABEL(m_SelLabel), "<b>Select a catalog file</b>");
gtk_widget_hide(m_FrameBox);
gtk_widget_show(m_PathLabel);
gtk_widget_show(m_PathEntry);
gtk_widget_show(m_PathBtn);
gtk_widget_show(m_CatalogBox);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowChart),
m_DMCatalog == DISPLAY_CHART);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowImage),
m_DMCatalog == DISPLAY_IMAGE);
break;
}
}
void set_button_state(BUTTONS_STATE state, EDITOR *e)
{
#ifdef HAVE_GTK_34
GdkRGBA rgba;
#else
GdkColor color;
#endif
gtk_toggle_tool_button_set_active(e->toolitems.bold, state.bold);
gtk_toggle_tool_button_set_active(e->toolitems.italic, state.italic);
gtk_toggle_tool_button_set_active(e->toolitems.underline, state.underline);
gtk_toggle_tool_button_set_active(e->toolitems.strike, state.strike);
gtk_combo_box_set_active((GtkComboBox *)e->toolitems.cb, state.style);
if (state.color) {
XI_message(("state.color: %s", state.color));
#ifdef HAVE_GTK_34
if (gdk_rgba_parse(&rgba, state.color))
gtk_color_chooser_set_rgba((GtkColorChooser *)
e->toolitems.color,
&rgba);
#else
if (gdk_color_parse(state.color, &color))
gtk_color_button_set_color((GtkColorButton *)
e->toolitems.color,
&color);
#endif
}
}
NOT IMPLEMENTED YET
/* callback to show and hide the offsets columns pane */
G_MODULE_EXPORT void
on_view_offsets (GtkObject *object, gpointer user_data)
{
/* NOT YET TESTED */
GtkWidget *offsets_w, *menu_w, *btn_w;
offsets_w = get_widget("inst_list");
menu_w = get_widget("m_view_metrics");
btn_w = get_widget("view_metrics_btn");
g_print("on_view_offsets\n");
g_signal_handlers_block_by_func(G_OBJECT(object),
G_CALLBACK(on_view_offsets), NULL);
if (GTK_WIDGET_VISIBLE(offsets_w)) {
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_w), FALSE);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(btn_w),
FALSE);
gtk_widget_hide(offsets_w);
} else {
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_w), TRUE);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(btn_w),
TRUE);
gtk_widget_show(offsets_w);
}
g_signal_handlers_unblock_by_func(G_OBJECT(object),
G_CALLBACK(on_view_offsets), NULL);
}
static void update_toggles (void * data, void * user)
{
gtk_toggle_tool_button_set_active ((GtkToggleToolButton *) button_repeat,
aud_get_bool (NULL, "repeat"));
gtk_toggle_tool_button_set_active ((GtkToggleToolButton *) button_shuffle,
aud_get_bool (NULL, "shuffle"));
}
void ColorToolItem::enableColor(int color) {
XOJ_CHECK_TYPE(ColorToolItem);
if (isSelector()) {
selectcolor_set_color(this->iconWidget, color);
this->color = color;
if (GTK_IS_TOGGLE_BUTTON(this->item)) {
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(this->item), false);
}
} else {
bool active = colorEqualsMoreOreLess(color);
if (this->item) {
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(this->item), active);
}
if (active) {
this->toolHandler->setColorFound();
// Only equals more ore less, so we will set it exact to the default color
if (this->color != color) {
this->toolHandler->setColor(this->color);
}
}
}
}
/* callback to show and hide the choice pane */
G_MODULE_EXPORT void
on_view_choices (GtkObject *object, gpointer user_data)
{
GtkWidget *scroll_w, *menu_w, *btn_w;
scroll_w = get_widget("choice_scrollwin");
menu_w = get_widget("m_view_choices");
btn_w = get_widget("view_choice_btn");
g_signal_handlers_block_by_func(G_OBJECT(object),
G_CALLBACK(on_view_choices), NULL);
if (GTK_WIDGET_VISIBLE(scroll_w)) {
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_w), FALSE);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(btn_w),
FALSE);
gtk_widget_hide(scroll_w);
} else {
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_w), TRUE);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(btn_w),
TRUE);
gtk_widget_show(scroll_w);
}
g_signal_handlers_unblock_by_func(G_OBJECT(object),
G_CALLBACK(on_view_choices), NULL);
}
/* 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 CTopographicMap3DView::init()
{
//reflect default interpolation type
m_rTopographicMapDatabase.setInterpolationType(m_ui64CurrentInterpolation);
enableInterpolationButtonSignals(false);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_pMapPotentials), m_ui64CurrentInterpolation == OVP_TypeId_SphericalLinearInterpolationType_Spline);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_pMapCurrents), m_ui64CurrentInterpolation == OVP_TypeId_SphericalLinearInterpolationType_Laplacian);
enableInterpolationButtonSignals(true);
}
G_MODULE_EXPORT
void on_menu_rightpane_toggled (GtkWidget *widget, void *user) {
if (gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (widget))) {
gtk_widget_show (GTK_WIDGET (gui->rightpane));
config_set_value ("rightpane", "True");
gtk_toggle_tool_button_set_active (gui->previewoff, FALSE);
} else {
gtk_widget_hide (GTK_WIDGET (gui->rightpane));
config_set_value ("rightpane", "False");
gtk_toggle_tool_button_set_active (gui->previewoff, TRUE);
}
}
static int fmcomms2_handle_driver(const char *attrib, const char *value)
{
if (MATCH_ATTRIB("load_fir_filter_file")) {
if (value[0]) {
load_fir_filter(value);
gtk_file_chooser_set_filename(
GTK_FILE_CHOOSER(filter_fir_config),
value);
}
} else if (MATCH_ATTRIB("dds_mode_tx1")) {
dac_data_manager_set_dds_mode(dac_tx_manager,
DDS_DEVICE, 1, atoi(value));
} else if (MATCH_ATTRIB("dds_mode_tx2")) {
dac_data_manager_set_dds_mode(dac_tx_manager,
DDS_DEVICE, 2, atoi(value));
} else if (MATCH_ATTRIB("global_settings_show")) {
gtk_toggle_tool_button_set_active(
section_toggle[SECTION_GLOBAL], !!atoi(value));
hide_section_cb(section_toggle[SECTION_GLOBAL],
section_setting[SECTION_GLOBAL]);
} else if (MATCH_ATTRIB("tx_show")) {
gtk_toggle_tool_button_set_active(
section_toggle[SECTION_TX], !!atoi(value));
hide_section_cb(section_toggle[SECTION_TX],
section_setting[SECTION_TX]);
} else if (MATCH_ATTRIB("rx_show")) {
gtk_toggle_tool_button_set_active(
section_toggle[SECTION_RX], !!atoi(value));
hide_section_cb(section_toggle[SECTION_RX],
section_setting[SECTION_RX]);
} else if (MATCH_ATTRIB("fpga_show")) {
gtk_toggle_tool_button_set_active(
section_toggle[SECTION_FPGA], !!atoi(value));
hide_section_cb(section_toggle[SECTION_FPGA],
section_setting[SECTION_FPGA]);
} else if (!strncmp(attrib, "tx_channel_", sizeof("tx_channel_") - 1)) {
int tx = atoi(attrib + sizeof("tx_channel_") - 1);
dac_data_manager_set_tx_channel_state(
dac_tx_manager, tx, !!atoi(value));
} else if (MATCH_ATTRIB("dac_buf_filename")) {
dac_data_manager_set_buffer_chooser_filename(
dac_tx_manager, value);
} else if (MATCH_ATTRIB("SYNC_RELOAD")) {
if (can_update_widgets)
reload_button_clicked(NULL, NULL);
} else {
return -EINVAL;
}
return 0;
}
static void
emoticon_tool_button_popdown (EEmoticonToolButton *button)
{
GtkToggleToolButton *tool_button;
if (!gtk_widget_get_realized (GTK_WIDGET (button)))
return;
if (!button->priv->popup_shown)
return;
/* Hide the pop-up. */
gtk_device_grab_remove (button->priv->window, button->priv->grab_mouse);
gtk_widget_hide (button->priv->window);
/* Deactivate the tool button. */
tool_button = GTK_TOGGLE_TOOL_BUTTON (button);
gtk_toggle_tool_button_set_active (tool_button, FALSE);
if (button->priv->grab_keyboard)
gdk_device_ungrab (button->priv->grab_keyboard, GDK_CURRENT_TIME);
if (button->priv->grab_mouse)
gdk_device_ungrab (button->priv->grab_mouse, GDK_CURRENT_TIME);
button->priv->grab_keyboard = NULL;
button->priv->grab_mouse = NULL;
}
void FormatDialog::setOrientation(Orientation orientation)
{
XOJ_CHECK_TYPE(FormatDialog);
if (this->orientation == orientation)
{
return;
}
this->orientation = orientation;
GtkWidget* btPortrait = get("btPortrait");
GtkWidget* btLandscape = get("btLandscape");
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(btPortrait), orientation == ORIENTATION_PORTRAIT);
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(btLandscape), orientation == ORIENTATION_LANDSCAPE);
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkToggleToolButton_gtk_1toggle_1tool_1button_1set_1active
(
JNIEnv* env,
jclass cls,
jlong _self,
jboolean _isActive
)
{
GtkToggleToolButton* self;
gboolean isActive;
// convert parameter self
self = (GtkToggleToolButton*) _self;
// convert parameter isActive
isActive = (gboolean) _isActive;
// call function
gtk_toggle_tool_button_set_active(self, isActive);
// cleanup parameter self
// cleanup parameter isActive
}
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);
}
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);
}
}
G_MODULE_EXPORT gboolean
preview_state_cb(
GtkWidget *widget,
GdkEvent *event,
signal_user_data_t *ud)
{
GdkEventType type = ghb_event_get_event_type(event);
if (type == GDK_WINDOW_STATE)
{
// Look for transition to iconified state.
// Toggle "Show Preview" button when iconified.
// I only do this because there seems to be no
// way to reliably disable the iconfy button without
// also disabling the maximize button.
#if GTK_CHECK_VERSION(3, 90, 0)
GdkWindow * window = gdk_event_get_window(event);
GdkWindowState state = gdk_window_get_state(window);
if (state & GDK_WINDOW_STATE_ICONIFIED)
#else
GdkEventWindowState * wse = (GdkEventWindowState*)event;
if (wse->changed_mask & wse->new_window_state &
GDK_WINDOW_STATE_ICONIFIED)
#endif
{
live_preview_stop(ud);
GtkWidget *widget = GHB_WIDGET(ud->builder, "show_preview");
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), FALSE);
}
}
return FALSE;
}
void init_Code(GtkWidget *Main)
{
GtkWidget *widget;
PangoFontDescription *codefont;
codetext = lookup_widget(Main, "Code_Text");
code_textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(codetext));
codefont = pango_font_description_from_string("Monospace");
gtk_widget_modify_font(codetext, codefont);
redtag = gtk_text_buffer_create_tag(code_textbuffer, "redtag",
"foreground", "red", NULL);
greentag = gtk_text_buffer_create_tag(code_textbuffer, "greentag",
"foreground", "green", NULL);
bluetag = gtk_text_buffer_create_tag(code_textbuffer, "bluetag",
"foreground", "blue", NULL);
boldtag = gtk_text_buffer_create_tag(code_textbuffer, "boldtag",
"weight", PANGO_WEIGHT_BOLD, NULL);
/* default the machine code button to FALSE */
widget = lookup_widget(Main, "OpcodeButton");
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), FALSE);
/* Set up the runslow stuff. Note that the widget holds values in mS */
/* but the internal values are in usecs */
run_slow_pref = RUN_SLOW_MSECS * 1000;
widget = lookup_widget(Main, "SlowRunSpin");
gtk_spin_button_set_value(GTK_SPIN_BUTTON(widget), RUN_SLOW_MSECS);
Code_Selected = FALSE;
build_code_cache();
}
/**
* egg_find_bar_set_case_sensitive:
*
* Sets whether the search is case sensitive
*
* Since: 2.6
*/
void
egg_find_bar_set_case_sensitive (EggFindBar *find_bar,
gboolean case_sensitive)
{
EggFindBarPrivate *priv;
g_return_if_fail (EGG_IS_FIND_BAR (find_bar));
priv = (EggFindBarPrivate *)find_bar->priv;
g_object_freeze_notify (G_OBJECT (find_bar));
case_sensitive = case_sensitive != FALSE;
if (priv->case_sensitive != case_sensitive)
{
priv->case_sensitive = case_sensitive;
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (priv->case_button),
priv->case_sensitive);
g_object_notify (G_OBJECT (find_bar),
"case_sensitive");
}
g_object_thaw_notify (G_OBJECT (find_bar));
}
// This is needed to correctly connect the ToggleButton to Radiant's callbacks
// The "handler" object data was set in CreateToolItem
inline void toggleButtonSetActiveNoSignal(GtkToggleToolButton* button, gboolean active)
{
guint handler_id = gpointer_to_int(g_object_get_data(G_OBJECT(button), "handler"));
g_signal_handler_block(G_OBJECT(button), handler_id);
gtk_toggle_tool_button_set_active(button, active);
g_signal_handler_unblock(G_OBJECT(button), handler_id);
}
void sc_gui_update_toolbar(void)
{
/* toolbar item is not requested, so remove the item if it exists */
if (! sc_info->show_toolbar_item)
{
if (sc_info->toolbar_button != NULL)
{
gtk_widget_hide(GTK_WIDGET(sc_info->toolbar_button));
}
}
else
{
if (sc_info->toolbar_button == NULL)
{
sc_info->toolbar_button = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_SPELL_CHECK);
plugin_add_toolbar_item(geany_plugin, sc_info->toolbar_button);
ui_add_document_sensitive(GTK_WIDGET(sc_info->toolbar_button));
g_signal_connect(sc_info->toolbar_button, "toggled",
G_CALLBACK(toolbar_item_toggled_cb), NULL);
}
gtk_widget_show(GTK_WIDGET(sc_info->toolbar_button));
sc_ignore_callback = TRUE;
gtk_toggle_tool_button_set_active(
GTK_TOGGLE_TOOL_BUTTON(sc_info->toolbar_button), sc_info->check_while_typing);
sc_ignore_callback = FALSE;
}
}
G_MODULE_EXPORT
void toggle_compilestatus(GtkWidget* widget, void* user)
{
gboolean newval = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
config_set_value("compile_status", newval ? "True" : "False");
gtk_widget_set_sensitive(GTK_WIDGET(gui->prefsgui->compile_timer), newval);
gtk_toggle_tool_button_set_active(gui->previewoff, !newval);
}
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);
}
}
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 CMatchingDlg::UpdateControls(void)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_FrameBtn),
(m_SelectMode == REFERENCE_FRAME));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_CatalogBtn),
(m_SelectMode == CATALOG_FILE));
if (m_SelectMode == REFERENCE_FRAME) {
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowImage),
(m_DMFrame == DISPLAY_IMAGE));
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowChart),
(m_DMFrame == DISPLAY_CHART));
} else {
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowImage),
(m_DMCatalog == DISPLAY_IMAGE));
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(m_ShowChart),
(m_DMCatalog == DISPLAY_CHART));
}
}
G_MODULE_EXPORT void
preview_menu_toggled_cb(GtkWidget *xwidget, signal_user_data_t *ud)
{
GtkToggleToolButton *button;
gboolean active;
active = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(xwidget));
button = GTK_TOGGLE_TOOL_BUTTON(GHB_WIDGET(ud->builder, "show_preview"));
gtk_toggle_tool_button_set_active(button, active);
}
void
DeselectAllDice (void)
{
int i;
if (test_computer_play > 0) return;
for (i = 0; i < NUMBER_OF_DICE; i++)
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (diceBox[i]),
FALSE);
}
void Sidebar::buttonClicked(GtkToolButton * toolbutton, SidebarPageButton * buttonData) {
XOJ_CHECK_TYPE_OBJ(buttonData->sidebar, Sidebar);
if (gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(toolbutton))) {
if (buttonData->sidebar->visiblePage != buttonData->page->getWidget()) {
buttonData->sidebar->setSelectedPage(buttonData->index);
}
} else if (buttonData->sidebar->visiblePage == buttonData->page->getWidget()) {
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(toolbutton), true);
}
}
G_MODULE_EXPORT gboolean
preview_window_delete_cb(
GtkWidget *widget,
GdkEvent *event,
signal_user_data_t *ud)
{
live_preview_stop(ud);
widget = GHB_WIDGET(ud->builder, "show_preview");
gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), FALSE);
return TRUE;
}
static void
moko_talking_reset_ui (MokoTalking *talking)
{
MokoTalkingPrivate *priv;
priv = MOKO_TALKING_GET_PRIVATE (talking);
gtk_toggle_tool_button_set_active (
GTK_TOGGLE_TOOL_BUTTON (priv->speaker_toggle_btn), FALSE);
moko_dialer_textview_empty (MOKO_DIALER_TEXTVIEW (priv->dtmf_display));
gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), 0);
}
/**
Set/unset the toggle button audio process
*/
void UI_setAProcessToggleStatus( uint8_t status )
{
gint b;
if(status) b=TRUE;
else b=FALSE;
if(b!=gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(guiAudioToggle)))
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON(guiAudioToggle),b);
aprintf("++ audio toggle : %d(%d)\n",b,status);
}
