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);
}
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);
}
}
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);
}
}
}
}
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 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;
}
}
static void library_view_adjust_aspect_buttons(library_view_t* view, aspect_enum aspect)
{
GtkToggleToolButton* g_btn = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(view->builder, "tbtn_genres"));
GtkToggleToolButton* ar_btn = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(view->builder, "tbtn_artists"));
GtkToggleToolButton* al_btn = GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(view->builder, "tbtn_albums"));
switch (aspect) {
case GENRE_ASPECT: {
SET_TOGGLE(ar_btn, FALSE);
SET_TOGGLE(al_btn, FALSE);
SET_TOGGLE(g_btn, TRUE);
}
break;
case ARTIST_ASPECT: {
SET_TOGGLE(ar_btn, TRUE);
SET_TOGGLE(al_btn, FALSE);
SET_TOGGLE(g_btn, FALSE);
}
break;
case ALBUM_ASPECT: {
SET_TOGGLE(ar_btn, FALSE);
SET_TOGGLE(al_btn, TRUE);
SET_TOGGLE(g_btn, FALSE);
}
break;
default:
break;
}
}
/* 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);
}
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);
}
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 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);
}
}
/**
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);
}
void Interface_iniciar() {
GtkWidget *window;
GdkGLConfig *glconfig;
gtk_init(NULL, NULL);
gtk_gl_init(NULL, NULL);
GtkBuilder *builderPrincipal=Interface_carregarXML(INTERFACE_PRINCIPAL);
window = GTK_WIDGET(gtk_builder_get_object (builderPrincipal, "window"));
drawOpengl=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "drawOpengl"));
frameProgresso=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "frameProgresso"));
progress=GTK_PROGRESS_BAR(gtk_builder_get_object(builderPrincipal, "progressbar"));
labelPosicaoXY=GTK_LABEL(gtk_builder_get_object(builderPrincipal, "labelPosicaoXY"));
ajustScrollHorizGL=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollHorizGL"));
ajustScrollVertGL=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollVertGL"));
adjustAlpha=GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "adjustAlpha"));
tbAddEntidade=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddEntidade"));
tbAddImagem=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddImagem"));
tbAddTexto=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAddTexto"));
tbAmpliar=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbAmpliar"));
tbReduzir=GTK_TOGGLE_TOOL_BUTTON(gtk_builder_get_object(builderPrincipal, "tbReduzir"));
frameFerramentas=GTK_WIDGET(gtk_builder_get_object(builderPrincipal, "frameFerramentas"));
/*gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollHorizGL")),500);
gtk_adjustment_set_value(GTK_ADJUSTMENT(gtk_builder_get_object(builderPrincipal, "ajustScrollVertGL")),500);*/
//Configura widget para opengl
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB |
GDK_GL_MODE_DEPTH |
GDK_GL_MODE_DOUBLE);
if (!glconfig) {
g_print ("*** Cannot find the double-buffered visual.\n");
g_print ("*** Trying single-buffered visual.\n");
/* Try single-buffered visual */
glconfig = gdk_gl_config_new_by_mode (GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH);
if (!glconfig) {
g_print ("*** No appropriate OpenGL-capable visual found.\n");
g_assert_not_reached();
}
}
if (!gtk_widget_set_gl_capability(drawOpengl, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE))
g_assert_not_reached();
gtk_builder_connect_signals(builderPrincipal, NULL);
gtk_widget_show(window);
g_object_unref(G_OBJECT(builderPrincipal));
}
/*
Set/unset the toggle button video process
*/
void UI_setVProcessToggleStatus( uint8_t status )
{
gint b;
if(status) b=TRUE;
else b=FALSE;
if(b!=gtk_toggle_tool_button_get_active(GTK_TOGGLE_TOOL_BUTTON(guiVideoToggle)))
{
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON(guiVideoToggle),b);
aprintf("Changing it to %d\n",b);
}
aprintf("++ video toggle : %d\n",b);
}
/* 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;
}
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;
}
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;
}
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 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
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);
}
}
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 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;
}
}
/**
* 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));
}
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 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;
}
}
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 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);
}
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();
}
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 ();
}
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);
}
}
