static void
_new_page (OlPlayerChooser *window,
const char *page_name)
{
OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window);
OlPlayerChooserPage *page = g_new (OlPlayerChooserPage, 1);
page->page_button = GTK_TOGGLE_BUTTON (gtk_radio_button_new_with_label (priv->page_button_group,
page_name));
priv->page_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (page->page_button));
gtk_toggle_button_set_mode (page->page_button, FALSE);
gtk_button_set_relief (GTK_BUTTON (page->page_button), GTK_RELIEF_NONE);
page->chooser = OL_APP_CHOOSER_WIDGET (ol_app_chooser_widget_new ());
gtk_widget_show (GTK_WIDGET (page->chooser));
page->panel = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL));
gtk_scrolled_window_add_with_viewport (page->panel, GTK_WIDGET (page->chooser));
GtkViewport *viewport = GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (page->panel)));
gtk_viewport_set_shadow_type (viewport, GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (page->panel,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
g_signal_connect (page->page_button,
"toggled",
G_CALLBACK (_page_button_toggled),
page);
g_signal_connect (page->chooser,
"app-activate",
G_CALLBACK (_app_activate_cb),
window);
_page_button_toggled (page->page_button, page);
if (priv->pages->len > 0)
gtk_box_pack_start (priv->page_button_panel,
gtk_vseparator_new (),
FALSE,
FALSE,
5);
gtk_box_pack_start (priv->page_button_panel,
GTK_WIDGET (page->page_button),
FALSE, /* expand */
FALSE, /* fill */
0); /* padding */
gtk_box_pack_start (priv->chooser_panel,
GTK_WIDGET (page->panel),
TRUE, /* expand */
TRUE, /* fill */
0); /* padding */
g_ptr_array_add (priv->pages, page);
}
static gboolean
vfo_press_event_cb (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
if((int)event->x < (my_width/2)) {
lock_cb(NULL,NULL);
} else {
GtkWidget *dialog=gtk_dialog_new_with_buttons("Step",GTK_WINDOW(parent_window),GTK_DIALOG_DESTROY_WITH_PARENT,NULL,NULL);
GtkWidget *content=gtk_dialog_get_content_area(GTK_DIALOG(dialog));
GtkWidget *grid=gtk_grid_new();
gtk_grid_set_column_homogeneous(GTK_GRID(grid),TRUE);
gtk_grid_set_row_homogeneous(GTK_GRID(grid),TRUE);
GtkWidget *step_rb=NULL;
int i=0;
while(steps[i]!=0) {
if(i==0) {
step_rb=gtk_radio_button_new_with_label(NULL,step_labels[i]);
} else {
step_rb=gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(step_rb),step_labels[i]);
}
gtk_widget_override_font(step_rb, pango_font_description_from_string("FreeMono 18"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (step_rb), steps[i]==step);
gtk_widget_show(step_rb);
gtk_grid_attach(GTK_GRID(grid),step_rb,i%5,i/5,1,1);
g_signal_connect(step_rb,"pressed",G_CALLBACK(vfo_step_select_cb),(gpointer *)i);
i++;
}
gtk_container_add(GTK_CONTAINER(content),grid);
GtkWidget *close_button=gtk_dialog_add_button(GTK_DIALOG(dialog),"Close",GTK_RESPONSE_OK);
gtk_widget_override_font(close_button, pango_font_description_from_string("FreeMono 18"));
gtk_widget_show_all(dialog);
g_signal_connect_swapped (dialog,
"response",
G_CALLBACK (gtk_widget_destroy),
dialog);
int result=gtk_dialog_run(GTK_DIALOG(dialog));
}
return TRUE;
}
bool wxRadioButton::Create( wxWindow *parent,
wxWindowID id,
const wxString& label,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxRadioButton creation failed") );
return false;
}
GSList* radioButtonGroup = NULL;
if (!HasFlag(wxRB_GROUP) && !HasFlag(wxRB_SINGLE))
{
// search backward for last group start
wxWindowList::compatibility_iterator node = parent->GetChildren().GetLast();
for (; node; node = node->GetPrevious())
{
wxWindow *child = node->GetData();
if (child->HasFlag(wxRB_GROUP) && wxIsKindOf(child, wxRadioButton))
{
radioButtonGroup = gtk_radio_button_get_group(
GTK_RADIO_BUTTON(child->m_widget));
break;
}
}
}
m_widget = gtk_radio_button_new_with_label( radioButtonGroup, wxGTK_CONV( label ) );
g_object_ref(m_widget);
SetLabel(label);
g_signal_connect_after (m_widget, "clicked",
G_CALLBACK (gtk_radiobutton_clicked_callback), this);
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
static void roccat_handedness_selector_init(RoccatHandednessSelector *selector) {
RoccatHandednessSelectorPrivate *priv = ROCCAT_HANDEDNESS_SELECTOR_GET_PRIVATE(selector);
GtkWidget *hbox;
selector->priv = priv;
hbox = gtk_hbox_new(TRUE, 0);
gtk_container_add(GTK_CONTAINER(selector), hbox);
priv->left = GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(NULL, _("Left handed")));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->left), TRUE, TRUE, 0);
priv->right = GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(priv->left, _("Right handed")));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(priv->right), TRUE, TRUE, 0);
gtk_frame_set_label(GTK_FRAME(selector), _("Handedness"));
}
int
main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *grid;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *radio1;
GtkWidget *radio2;
GtkListStore *store;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Completion");
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
grid = gtk_grid_new();
gtk_container_add(GTK_CONTAINER(window), grid);
label = gtk_label_new("There are completions for numbers from 'one' to 'ten'");
gtk_grid_attach(GTK_GRID(grid), label, 0, 0, 2, 1);
radio1 = gtk_radio_button_new_with_label(NULL, "Popup");
gtk_grid_attach(GTK_GRID(grid), radio1, 0, 1, 1, 1);
radio2 = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(radio1), "Inline");
gtk_grid_attach(GTK_GRID(grid), radio2, 1, 1, 1, 1);
entry = gtk_entry_new();
gtk_grid_attach(GTK_GRID(grid), entry, 0, 2, 2, 1);
store = create_completion_list_store();
g_completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(g_completion, GTK_TREE_MODEL(store));
gtk_entry_completion_set_text_column(g_completion, 0);
gtk_entry_set_completion(GTK_ENTRY(entry), g_completion);
g_signal_connect(radio1, "toggled", G_CALLBACK(popup_radio_toggled), NULL);
g_signal_connect(radio2, "toggled", G_CALLBACK(inline_radio_toggled), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
// TODO: some quality/compression stuff?
void gui_init (dt_imageio_module_format_t *self)
{
dt_imageio_tiff_gui_t *gui = (dt_imageio_tiff_gui_t *)malloc(sizeof(dt_imageio_tiff_gui_t));
self->gui_data = (void *)gui;
int bpp = dt_conf_get_int("plugins/imageio/format/tiff/bpp");
self->widget = gtk_hbox_new(TRUE, 5);
GtkWidget *radiobutton = gtk_radio_button_new_with_label(NULL, _("8-bit"));
gui->b8 = GTK_TOGGLE_BUTTON(radiobutton);
gtk_box_pack_start(GTK_BOX(self->widget), radiobutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(radiobutton), "toggled", G_CALLBACK(radiobutton_changed), (gpointer)8);
if(bpp < 12) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton), TRUE);
radiobutton = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radiobutton), _("16-bit"));
gui->b16 = GTK_TOGGLE_BUTTON(radiobutton);
gtk_box_pack_start(GTK_BOX(self->widget), radiobutton, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(radiobutton), "toggled", G_CALLBACK(radiobutton_changed), (gpointer)16);
if(bpp >= 12) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton), TRUE);
}
void ChoiceOptionView::_createItem() {
myFrame = GTK_FRAME(gtk_frame_new(name().c_str()));
myVBox = GTK_BOX(gtk_vbox_new(true, 10));
gtk_container_set_border_width(GTK_CONTAINER(myVBox), 5);
int num = ((ZLChoiceOptionEntry&)*myOption).choiceNumber();
myButtons = new GtkRadioButton* [num];
GSList *group = 0;
for (int i = 0; i < num; ++i) {
myButtons[i] = GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(group, ((ZLChoiceOptionEntry&)*myOption).text(i).c_str()));
group = gtk_radio_button_get_group(myButtons[i]);
gtk_box_pack_start(myVBox, GTK_WIDGET(myButtons[i]), true, true, 0);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(myButtons[((ZLChoiceOptionEntry&)*myOption).initialCheckedIndex()]), true);
gtk_container_add(GTK_CONTAINER(myFrame), GTK_WIDGET(myVBox));
myHolder.attachWidget(*this, GTK_WIDGET(myFrame));
}
void
make_radio_group (const char **labels, GtkWidget *tobox,
GtkWidget **saveptr, gint t1, gint t2,
void (*sigfunc) (void))
{
GtkWidget *thing = NULL;
while (*labels) {
thing = gtk_radio_button_new_with_label ((thing
? gtk_radio_button_group (GTK_RADIO_BUTTON (thing))
: 0),
*labels++);
*saveptr++ = thing;
gtk_widget_show (thing);
gtk_box_pack_start (GTK_BOX (tobox), thing, t1, t2, 0);
gtk_signal_connect (GTK_OBJECT (thing), "clicked", (GtkSignalFunc) sigfunc, NULL);
}
}
RadioHBox RadioHBox_new(StringArrayRange names)
{
GtkHBox* hbox = GTK_HBOX(gtk_hbox_new(TRUE, 4));
gtk_widget_show(GTK_WIDGET(hbox));
GSList* group = 0;
GtkRadioButton* radio = 0;
for(StringArrayRange::Iterator i = names.begin; i != names.end; ++i)
{
radio = GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(group, *i));
gtk_widget_show(GTK_WIDGET(radio));
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(radio), FALSE, FALSE, 0);
group = gtk_radio_button_get_group(radio);
}
return RadioHBox(hbox, radio);
}
static void add_radios_color_effect(GtkBox *parent, NythLightEffectsFrame *frame) {
NythLightEffectsFramePrivate *priv = frame->priv;
GtkWidget *radio;
radio = gtk_radio_button_new_with_label(NULL, _("Flow direction down"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_COLOR_EFFECT_DOWN));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Flow direction up"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_COLOR_EFFECT_UP));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("All lights simultaneously"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_COLOR_EFFECT_SIMULTANEOUSLY));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("No color flow"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_COLOR_EFFECT_OFF));
priv->radios_color_effect = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
g_slist_foreach(priv->radios_color_effect, pack_radio_button, parent);
}
int main(int argc, char * argv[])
{
GtkWidget *window, *radio;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window, 400, 100);
radio = gtk_radio_button_new_with_label (NULL, "Hanya satu pilihan");
gtk_container_add (GTK_CONTAINER (window), radio);
gtk_widget_show_all (window);
gtk_main();
return 0;
};
static void add_radios_light_effect(GtkBox *parent, NythLightEffectsFrame *frame) {
NythLightEffectsFramePrivate *priv = frame->priv;
GtkWidget *radio;
radio = gtk_radio_button_new_with_label(NULL, _("Heartbeat"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_HEARTBEAT));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Breathing"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_BREATHING));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Blinking"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_BLINKING));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("Fully lighted"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_FULLY_LIGHTED));
radio = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio), _("All lights off"));
g_object_set_data(G_OBJECT(radio), value_key, GUINT_TO_POINTER(NYTH_PROFILE_SETTINGS_LIGHT_EFFECT_ALL_OFF));
priv->radios_light_effect = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
g_slist_foreach(priv->radios_light_effect, pack_radio_button, parent);
}
/*
* xv_sync_to_display_radio_button_add() - create a radio button and plug it
* into the xv_sync_display_buttons radio group.
*/
static GtkWidget *xv_sync_to_display_radio_button_add(CtkXVideo *ctk_xvideo,
GtkWidget *last_button,
gint display_id)
{
gchar *label;
GtkWidget *button;
GSList *slist;
if (display_id == NV_CTRL_XV_SYNC_TO_DISPLAY_ID_AUTO) {
label = g_strdup("Auto");
} else {
label = xv_sync_to_display_radio_button_label(ctk_xvideo, display_id);
}
if (last_button) {
slist = gtk_radio_button_get_group(GTK_RADIO_BUTTON(last_button));
} else {
slist = NULL;
}
button = gtk_radio_button_new_with_label(slist, label);
g_free(label);
gtk_box_pack_start(GTK_BOX(ctk_xvideo->xv_sync_to_display_button_box),
button, FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(button), "display_id",
GINT_TO_POINTER(display_id));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(xv_sync_to_display_id_toggled),
(gpointer) ctk_xvideo);
ctk_config_set_tooltip(ctk_xvideo->ctk_config, button,
__xv_sync_to_display_help);
return button;
}
int main (int argc,
char *argv[])
{
GtkWidget *window, *vbox, *radio1, *radio2, *radio3, *radio4;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Radio Buttons");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
/* Create three radio buttons where the second two join radio1's group. */
radio1 = gtk_radio_button_new_with_label (NULL, "I want to be clicked!");
radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),
"Click me instead!");
radio3 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),
"No! Click me!");
/* Note: The radio button you create the new widget from does not matter as
* long as it it already a member of the group! */
radio4 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio3),
"No! Click me instead!");
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (vbox), radio1, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), radio2, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), radio3, FALSE, FALSE, 5);
gtk_box_pack_start (GTK_BOX (vbox), radio4, FALSE, FALSE, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static GSList *add_resource_btn(GtkWidget * vbox,
GSList * grp, Resource resource)
{
GtkWidget *btn;
gboolean active;
active = grp == NULL;
btn = gtk_radio_button_new_with_label(grp,
resource_name(resource,
TRUE));
grp = gtk_radio_button_get_group(GTK_RADIO_BUTTON(btn));
gtk_widget_show(btn);
gtk_box_pack_start(GTK_BOX(vbox), btn, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(btn), active);
g_signal_connect(G_OBJECT(btn), "toggled",
G_CALLBACK(monop_toggled),
GINT_TO_POINTER(resource));
if (active)
monop_type = resource;
return grp;
}
static void nyth_dcu_frame_init(NythDcuFrame *frame) {
NythDcuFramePrivate *priv = NYTH_DCU_FRAME_GET_PRIVATE(frame);
GtkWidget *box;
GtkWidget *radio;
int i;
frame->priv = priv;
box = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), box);
struct {
NythControlUnitDcu state;
gchar const *title;
} radios[4] = {
{NYTH_DISTANCE_CONTROL_UNIT_OFF, N_("Off")},
{NYTH_DISTANCE_CONTROL_UNIT_EXTRA_LOW, N_("Extra low")},
{NYTH_DISTANCE_CONTROL_UNIT_LOW, N_("Low")},
{NYTH_DISTANCE_CONTROL_UNIT_NORMAL, N_("Normal")},
};
priv->radios = NULL;
for (i = 3; i >= 0; --i) {
radio = gtk_radio_button_new_with_label(priv->radios, _N(radios[i].title));
g_object_set_data(G_OBJECT(radio), state_key, GUINT_TO_POINTER(radios[i].state));
priv->radios = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
g_signal_connect(G_OBJECT(radio), "toggled", G_CALLBACK(radio_toggled_cb), frame);
}
g_slist_foreach(priv->radios, pack_radio_button, box);
gtk_frame_set_label(GTK_FRAME(frame), _("Distance control unit"));
gtk_widget_show_all(box);
}
/*
* Creates a radio button.
* box - the containing box.
* orient_type - The orientation ID
* label, help_string - self-describing
* radio_group -
* A pointer to a radio group. The function assigns its value
* as the radio group of the radio button. Afterwards, it assigns it
* a new value of the new radio group of the button.
* This is useful to group buttons. Just reset the variable to NULL,
* to create a new group.
* */
GtkWidget *
create_radio_button (GtkWidget *box,
int orient_type,
void (*callback) (GtkWidget *wg, void *d),
gchar *label,
gchar *help_string,
GSList **radio_group,
GtkWidget **buttons_array)
{
GtkWidget *tmpw;
buttons_array[orient_type] = tmpw =
gtk_radio_button_new_with_label ((*radio_group), label);
gtk_box_pack_start (GTK_BOX (box), tmpw, FALSE, FALSE, 0);
gtk_widget_show (tmpw);
g_signal_connect (tmpw, "clicked",
G_CALLBACK (callback), GINT_TO_POINTER (orient_type));
gimp_help_set_help_data (tmpw, help_string, NULL);
*radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (tmpw));
return tmpw;
}
/*
* snap_dialog
*
* Bring up the GTK dialog for setting snapshot
* parameters.
*/
static gboolean
snap_dialog (void)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkObject *adj;
GSList *radio_group = NULL;
gint radio_pressed[2];
gint decorations;
gboolean run;
/* Set defaults */
radio_pressed[0] = (winsnapvals.root == FALSE);
radio_pressed[1] = (winsnapvals.root == TRUE);
decorations = winsnapvals.decor;
/* Init GTK */
gimp_ui_init (PLUG_IN_BINARY, FALSE);
/* Main Dialog */
dialog = gimp_dialog_new (PLUG_IN_PRINT_NAME, PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("Grab"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
winsnapintf.single_button =
gtk_radio_button_new_with_label (radio_group,
_("Grab a single window"));
gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.single_button, FALSE, FALSE, 0);
g_signal_connect (winsnapintf.single_button, "toggled",
G_CALLBACK (snap_toggle_update),
&radio_pressed[0]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.single_button),
radio_pressed[0]);
gtk_widget_show (winsnapintf.single_button);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.single_button));
winsnapintf.root_button =
gtk_radio_button_new_with_label (radio_group,
_("Grab the whole screen"));
gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.root_button, FALSE, FALSE, 0);
g_signal_connect (winsnapintf.root_button, "toggled",
G_CALLBACK (snap_toggle_update),
&radio_pressed[1]);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.root_button),
radio_pressed[1]);
gtk_widget_show (winsnapintf.root_button);
radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.root_button));
/* with delay */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new (_("after"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
winsnapintf.delay_spinner = gimp_spin_button_new (&adj,
winsnapvals.delay,
0.0, 100.0,
1.0, 5.0, 0.0, 0, 0);
gtk_box_pack_start (GTK_BOX (hbox),
winsnapintf.delay_spinner, FALSE, FALSE, 0);
gtk_widget_show (winsnapintf.delay_spinner);
label = gtk_label_new (_("Seconds delay"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
#ifdef CAN_SET_DECOR
/* With decorations */
winsnapintf.decor_button =
gtk_check_button_new_with_label (_("Include decorations"));
g_signal_connect (winsnapintf.decor_button, "toggled",
G_CALLBACK (snap_toggle_update),
&decorations);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.decor_button),
decorations);
gtk_box_pack_end (GTK_BOX (vbox), winsnapintf.decor_button, FALSE, FALSE, 0);
gtk_widget_set_sensitive (winsnapintf.decor_button, radio_pressed[0]);
gtk_widget_show (winsnapintf.decor_button);
#endif /* CAN_SET_DECOR */
gtk_widget_show (dialog);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
winsnapvals.root = radio_pressed[1];
winsnapvals.decor = decorations;
winsnapvals.delay =
gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (winsnapintf.delay_spinner));
}
gtk_widget_destroy (dialog);
return run;
}
GtkWidget *AP_UnixDialog_Lists::_constructWindowContents (void)
{
GtkWidget *vbox2;
GtkWidget *hbox2;
GtkWidget *vbox4;
GtkWidget *table1;
GtkWidget *style_om;
GtkWidget *type_om;
GtkWidget *type_lb;
GtkWidget *style_lb;
GtkWidget *customized_cb;
GtkWidget *frame1;
GtkWidget *table2;
GtkComboBox *font_om;
GtkListStore *font_om_menu;
GtkWidget *format_en;
GtkWidget *decimal_en;
GtkAdjustment *start_sb_adj;
GtkWidget *start_sb;
GtkAdjustment *text_align_sb_adj;
GtkWidget *text_align_sb;
GtkAdjustment *label_align_sb_adj;
GtkWidget *label_align_sb;
GtkWidget *format_lb;
GtkWidget *font_lb;
GtkWidget *delimiter_lb;
GtkWidget *start_at_lb;
GtkWidget *text_align_lb;
GtkWidget *label_align_lb;
GtkWidget *vbox3;
GtkWidget *preview_lb;
GtkWidget *hbox1;
GSList *action_group = NULL;
GtkWidget *start_list_rb;
GtkWidget *apply_list_rb;
GtkWidget *resume_list_rb;
GtkWidget *preview_area;
GtkWidget *preview_frame;
const XAP_StringSet * pSS = m_pApp->getStringSet();
UT_UTF8String s;
GtkWidget * wNoteBook = NULL;
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox2);
if(!isModal())
{
// Note Book creation
wNoteBook = gtk_notebook_new ();
gtk_widget_show(wNoteBook);
// Container for the lists
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageProperties,s);
GtkWidget * lbPageLists = gtk_label_new(s.utf8_str());
gtk_widget_show(lbPageLists);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),vbox2,lbPageLists);
m_iPageLists = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),vbox2);
// Container for Text Folding
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_PageFolding,s);
GtkWidget * lbPageFolding = gtk_label_new(s.utf8_str());
GtkWidget * wFoldingTable = gtk_table_new(6,3,FALSE);
gtk_widget_show(lbPageFolding);
gtk_widget_show(wFoldingTable);
gtk_notebook_append_page(GTK_NOTEBOOK(wNoteBook),wFoldingTable,lbPageFolding);
m_iPageFold = gtk_notebook_page_num(GTK_NOTEBOOK(wNoteBook),wFoldingTable);
// Left Spacing Here
GtkWidget * lbLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbLeftSpacer,0,1,0,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbLeftSpacer);
// Bold markup
GtkWidget * lbFoldHeading = gtk_label_new("<b>%s</b>");
gtk_label_set_use_markup(GTK_LABEL(lbFoldHeading),TRUE);
localizeLabelMarkup(lbFoldHeading,pSS,AP_STRING_ID_DLG_Lists_FoldingLevelexp);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbFoldHeading,1,3,0,1,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(lbFoldHeading);
// Mid Left Spacing Here
GtkWidget * lbMidLeftSpacer = gtk_label_new("");
gtk_misc_set_padding(GTK_MISC(lbMidLeftSpacer),8,0);
gtk_table_attach(GTK_TABLE(wFoldingTable),lbMidLeftSpacer,1,2,1,6,GTK_SHRINK,GTK_FILL,0,0);
gtk_widget_show(lbMidLeftSpacer);
m_vecFoldCheck.clear();
m_vecFoldID.clear();
UT_uint32 ID =0;
// RadioButtons
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel0,s);
GtkWidget * wF = gtk_radio_button_new_with_label(NULL, s.utf8_str());
GSList *wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"0");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,1,2,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel1,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"1");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,2,3,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel2,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"2");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,3,4,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel3,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
wG = gtk_radio_button_get_group(GTK_RADIO_BUTTON(wF));
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"3");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,4,5,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_FoldingLevel4,s);
wF = gtk_radio_button_new_with_label(wG, s.utf8_str());
g_object_set_data(G_OBJECT(wF),"level",(gpointer)"4");
ID = g_signal_connect(G_OBJECT(wF),
"toggled",
G_CALLBACK(s_FoldCheck_changed),
(gpointer) this);
gtk_table_attach(GTK_TABLE(wFoldingTable),wF,2,3,5,6,GTK_FILL,GTK_EXPAND,0,0);
gtk_widget_show(wF);
m_vecFoldCheck.addItem(wF);
m_vecFoldID.addItem(ID);
gtk_widget_show(wFoldingTable);
gtk_notebook_set_current_page(GTK_NOTEBOOK(wNoteBook),m_iPageLists);
}
// List Page
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 8);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 8);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
vbox4 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4);
gtk_widget_show (vbox4);
gtk_box_pack_start (GTK_BOX (hbox2), vbox4, FALSE, TRUE, 0);
table1 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox4), table1, FALSE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table1), 4);
style_om = gtk_combo_box_text_new();
gtk_widget_show (style_om);
gtk_table_attach (GTK_TABLE (table1), style_om, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
m_wListStyleNone_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillNoneStyleMenu(m_wListStyleNone_menu.obj());
m_wListStyleNumbered_menu = gtk_list_store_new (2, G_TYPE_STRING,
G_TYPE_INT);
_fillNumberedStyleMenu(m_wListStyleNumbered_menu.obj());
m_wListStyleBulleted_menu = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_INT);
_fillBulletedStyleMenu(m_wListStyleBulleted_menu.obj());
// This is the default list. Change if the list style changes
//
m_wListStyle_menu = m_wListStyleNumbered_menu;
gtk_combo_box_set_model(GTK_COMBO_BOX (style_om),
GTK_TREE_MODEL(m_wListStyleNumbered_menu.obj()));
type_om = gtk_combo_box_text_new();
gtk_widget_show (type_om);
gtk_table_attach (GTK_TABLE (table1), type_om, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_none,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_bullet,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type_numbered,s);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(type_om), s.utf8_str());
gtk_combo_box_set_active(GTK_COMBO_BOX(type_om), 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Type,s);
type_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (type_lb);
gtk_table_attach (GTK_TABLE (table1), type_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (type_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Style,s);
style_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (style_lb);
gtk_table_attach (GTK_TABLE (table1), style_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (style_lb), 0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_SetDefault,s);
customized_cb = gtk_dialog_add_button (GTK_DIALOG(m_wMainWindow), s.utf8_str(), BUTTON_RESET);
gtk_widget_show (customized_cb);
/* todo
gtk_table_attach (GTK_TABLE (table1), customized_cb, 0, 2, 2, 3,
(GtkAttachOptions) (GTK_SHRINK),
(GtkAttachOptions) (0), 0, 0);
*/
frame1 = gtk_frame_new (NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame1), GTK_SHADOW_NONE);
//gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox4), frame1, TRUE, TRUE, 0);
table2 = gtk_table_new (6, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame1), table2);
gtk_container_set_border_width (GTK_CONTAINER (table2), 4);
gtk_widget_set_sensitive (table2, TRUE);
gtk_table_set_row_spacings (GTK_TABLE (table2), 4);
gtk_table_set_col_spacings (GTK_TABLE (table2), 4);
font_om_menu = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
_fillFontMenu(font_om_menu);
font_om = GTK_COMBO_BOX(gtk_combo_box_new());
gtk_combo_box_set_model(font_om, GTK_TREE_MODEL(font_om_menu));
gtk_widget_show (GTK_WIDGET(font_om));
gtk_table_attach (GTK_TABLE (table2), GTK_WIDGET(font_om), 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
format_en = gtk_entry_new ();
gtk_entry_set_max_length(GTK_ENTRY(format_en), 20);
gtk_widget_show (format_en);
gtk_table_attach (GTK_TABLE (table2), format_en, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "%L");
decimal_en = gtk_entry_new ();
gtk_widget_show (decimal_en);
gtk_table_attach (GTK_TABLE (table2), decimal_en, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_entry_set_text (GTK_ENTRY (format_en), "");
start_sb_adj = (GtkAdjustment*)gtk_adjustment_new (1, 0, G_MAXINT32, 1, 10, 10);
start_sb = gtk_spin_button_new (GTK_ADJUSTMENT (start_sb_adj), 1, 0);
gtk_widget_show (start_sb);
gtk_table_attach (GTK_TABLE (table2), start_sb, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
text_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0.25, 0, 10, 0.01, 0.2, 1);
text_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (text_align_sb_adj), 0.05, 2);
gtk_widget_show (text_align_sb);
gtk_table_attach (GTK_TABLE (table2), text_align_sb, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (text_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (text_align_sb), TRUE);
label_align_sb_adj = (GtkAdjustment*)gtk_adjustment_new (0, 0, 10, 0.01, 0.2, 1);
label_align_sb = gtk_spin_button_new (GTK_ADJUSTMENT (label_align_sb_adj), 0.05, 2);
gtk_widget_show (label_align_sb);
gtk_table_attach (GTK_TABLE (table2), label_align_sb, 1, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (label_align_sb), TRUE);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (label_align_sb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Format,s);
format_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (format_lb);
gtk_table_attach (GTK_TABLE (table2), format_lb, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (format_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Font,s);
font_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (font_lb);
gtk_table_attach (GTK_TABLE (table2), font_lb, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (font_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_DelimiterString,s);
delimiter_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (delimiter_lb);
gtk_table_attach (GTK_TABLE (table2), delimiter_lb, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (delimiter_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start,s);
start_at_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (start_at_lb);
gtk_table_attach (GTK_TABLE (table2), start_at_lb, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (start_at_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Align,s);
text_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (text_align_lb);
gtk_table_attach (GTK_TABLE (table2), text_align_lb, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (text_align_lb), 0.0, 0.5);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Indent,s);
label_align_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (label_align_lb);
gtk_table_attach (GTK_TABLE (table2), label_align_lb, 0, 1, 5, 6,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_align_lb), 0.0, 0.5);
vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (hbox2), vbox3, TRUE, TRUE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Preview,s);
preview_lb = gtk_label_new (s.utf8_str());
gtk_widget_show (preview_lb);
gtk_box_pack_start (GTK_BOX (vbox3), preview_lb, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (preview_lb), 0.0, 0.5);
preview_frame = gtk_frame_new (NULL);
gtk_widget_show (preview_frame);
gtk_box_pack_start (GTK_BOX (vbox3), preview_frame, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (preview_frame), 3);
gtk_frame_set_shadow_type (GTK_FRAME (preview_frame), GTK_SHADOW_NONE);
preview_area = createDrawingArea ();
gtk_widget_set_size_request (preview_area,180,225);
gtk_widget_show (preview_area);
gtk_container_add (GTK_CONTAINER (preview_frame), preview_area);
hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
if(!isModal())
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vbox2), hbox1, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Start_New,s);
start_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (start_list_rb));
if(!isModal())
gtk_widget_show (start_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), start_list_rb, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (start_list_rb), TRUE);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Apply_Current,s);
apply_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (apply_list_rb));
if(!isModal())
gtk_widget_show (apply_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), apply_list_rb, FALSE, FALSE, 0);
pSS->getValueUTF8(AP_STRING_ID_DLG_Lists_Resume,s);
resume_list_rb = gtk_radio_button_new_with_label (action_group, s.utf8_str());
action_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (resume_list_rb));
if(!isModal())
gtk_widget_show (resume_list_rb);
gtk_box_pack_start (GTK_BOX (hbox1), resume_list_rb, FALSE, FALSE, 0);
// Save useful widgets in member variables
if(isModal())
{
m_wContents = vbox2;
}
else
{
m_wContents = wNoteBook;
}
m_wStartNewList = start_list_rb;
m_wStartNew_label = gtk_bin_get_child(GTK_BIN(start_list_rb));
m_wApplyCurrent = apply_list_rb;
m_wStartSubList = resume_list_rb;
m_wStartSub_label = gtk_bin_get_child(GTK_BIN(resume_list_rb));
m_wRadioGroup = action_group;
m_wPreviewArea = preview_area;
m_wDelimEntry = format_en;
m_oAlignList_adj = text_align_sb_adj;
m_wAlignListSpin = text_align_sb;
m_oIndentAlign_adj = label_align_sb_adj;
m_wIndentAlignSpin = label_align_sb;
m_wDecimalEntry = decimal_en;
m_oStartSpin_adj = start_sb_adj;
m_wStartSpin = start_sb;
m_wFontOptions = font_om;
m_wFontOptions_menu = font_om_menu;
m_wCustomFrame = frame1;
m_wCustomLabel = customized_cb;
m_wCustomTable = table2;
m_wListStyleBox = GTK_COMBO_BOX(style_om);
m_wListTypeBox = GTK_COMBO_BOX(type_om);
m_wListType_menu = m_wListStyleNumbered_menu;
// Start by hiding the Custom frame
//
// gtk_widget_hide(m_wCustomFrame);
gtk_widget_show(m_wCustomFrame);
setbisCustomized(false);
return m_wContents;
}
static void
set_font_size (GtkWidget *widget, gint size)
{
const gchar *class[3] = { "small-font", "medium-font", "large-font" };
gtk_style_context_add_class (gtk_widget_get_style_context (widget), class[size]);
}
int
main (int argc,
char **argv)
{
GtkWidget *window, *label, *entry, *button, *grid, *notebook;
GtkWidget *vbox, *hbox, *grid_hbox, *spin, *spin2, *toggle, *combo, *image;
GtkAdjustment *adjustment;
int i, j;
GtkCssProvider *provider;
gtk_init ();
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider,
".small-font { font-size: 5px; }"
".medium-font { font-size: 10px; }"
".large-font { font-size: 15px; }", -1);
gtk_style_context_add_provider_for_display (gdk_display_get_default (),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
notebook = gtk_notebook_new ();
gtk_container_add (GTK_CONTAINER (window), notebook);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("hboxes"));
for (j = 0; j < 2; j++)
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
char *aligns_names[] = { "FILL", "BASELINE" };
GtkAlign aligns[] = { GTK_ALIGN_FILL, GTK_ALIGN_BASELINE};
label = gtk_label_new (aligns_names[j]);
gtk_container_add (GTK_CONTAINER (hbox), label);
for (i = 0; i < 3; i++) {
label = gtk_label_new ("│XYyj,Ö...");
set_font_size (label, i);
gtk_widget_set_valign (label, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), label);
}
for (i = 0; i < 3; i++) {
entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry), "│XYyj,Ö...");
set_font_size (entry, i);
gtk_widget_set_valign (entry, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), entry);
}
spin = gtk_spin_button_new (NULL, 0, 1);
gtk_orientable_set_orientation (GTK_ORIENTABLE (spin), GTK_ORIENTATION_VERTICAL);
gtk_widget_set_valign (spin, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), spin);
spin = gtk_spin_button_new (NULL, 0, 1);
gtk_widget_set_valign (spin, aligns[j]);
gtk_container_add (GTK_CONTAINER (hbox), spin);
}
grid_hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[0]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[1]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[2]);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
gtk_container_add (GTK_CONTAINER (hbox), combo);
for (j = 0; j < 2; j++)
{
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (baseline_position_changed), hbox);
if (j == 0)
label = gtk_label_new ("Baseline:");
else
label = gtk_label_new ("Normal:");
gtk_container_add (GTK_CONTAINER (hbox), label);
for (i = 0; i < 3; i++)
{
button = gtk_button_new_with_label ("│Xyj,Ö");
set_font_size (button, i);
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
for (i = 0; i < 3; i++)
{
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("face-sad"));
gtk_container_add (GTK_CONTAINER (button), box);
set_font_size (button, i);
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 34);
if (j == 0)
gtk_widget_set_valign (image, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), image);
button = gtk_toggle_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
button = gtk_toggle_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
button = gtk_check_button_new_with_label ("│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
button = gtk_radio_button_new_with_label (NULL, "│Xyj,Ö");
if (j == 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("grid"));
grid_hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
label = gtk_label_new ("Align me:");
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), label);
grid = gtk_grid_new ();
gtk_widget_set_valign (grid, GTK_ALIGN_BASELINE);
gtk_grid_set_column_spacing (GTK_GRID (grid), 8);
gtk_grid_set_row_spacing (GTK_GRID (grid), 8);
for (j = 0; j < 4; j++)
{
char *labels[] = { "Normal:", "Baseline (top):", "Baseline (center):", "Baseline (bottom):"};
label = gtk_label_new (labels[j]);
gtk_grid_attach (GTK_GRID (grid),
label,
0, j,
1, 1);
gtk_widget_set_vexpand (label, TRUE);
if (j != 0)
gtk_grid_set_row_baseline_position (GTK_GRID (grid),
j, (GtkBaselinePosition)(j-1));
for (i = 0; i < 3; i++)
{
label = gtk_label_new ("Xyjg,Ö.");
set_font_size (label, i);
if (j != 0)
gtk_widget_set_valign (label, GTK_ALIGN_BASELINE);
gtk_grid_attach (GTK_GRID (grid),
label,
i+1, j,
1, 1);
}
for (i = 0; i < 3; i++)
{
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
gtk_container_add (GTK_CONTAINER (box), gtk_image_new_from_icon_name ("face-sad"));
gtk_container_add (GTK_CONTAINER (button), box);
set_font_size (button, i);
if (j != 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_grid_attach (GTK_GRID (grid),
button,
i+4, j,
1, 1);
}
}
gtk_container_add (GTK_CONTAINER (hbox), grid);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
adjustment = gtk_adjustment_new (0.0, -1.0, 5.0, 1.0, 1.0, 0.0);
spin = gtk_spin_button_new (adjustment, 1.0, 0);
g_signal_connect (spin, "value-changed", (GCallback)baseline_row_value_changed, grid);
gtk_container_add (GTK_CONTAINER (hbox), spin);
toggle = gtk_toggle_button_new_with_label ("Homogeneous");
g_signal_connect (toggle, "toggled", (GCallback)homogeneous_changed, grid);
gtk_container_add (GTK_CONTAINER (hbox), toggle);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[0]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[1]);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), baseline_pos_str[2]);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (baseline_position_changed), grid_hbox);
gtk_container_add (GTK_CONTAINER (hbox), combo);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook),
vbox, gtk_label_new ("button box"));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
adjustment = gtk_adjustment_new (34.0, 1.0, 64.0, 1.0, 1.0, 0.0);
spin = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_container_add (GTK_CONTAINER (hbox), spin);
adjustment = gtk_adjustment_new (16.0, 1.0, 64.0, 1.0, 1.0, 0.0);
spin2 = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_container_add (GTK_CONTAINER (hbox), spin2);
for (j = 0; j < 3; j++)
{
hbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), hbox);
gtk_box_set_baseline_position (GTK_BOX (hbox), j);
label = gtk_label_new (baseline_pos_str[j]);
gtk_container_add (GTK_CONTAINER (hbox), label);
gtk_widget_set_vexpand (label, TRUE);
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 34);
gtk_container_add (GTK_CONTAINER (hbox), image);
g_signal_connect (spin, "value-changed", (GCallback)image_size_value_changed, image);
for (i = 0; i < 3; i++)
{
button = gtk_button_new_with_label ("│Xyj,Ö");
set_font_size (button, i);
if (i != 0)
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
for (i = 0; i < 3; i++)
{
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("│Xyj,Ö"));
image = gtk_image_new_from_icon_name ("face-sad");
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
gtk_container_add (GTK_CONTAINER (box), image);
gtk_container_add (GTK_CONTAINER (button), box);
if (i == 0)
g_signal_connect (spin2, "value-changed", (GCallback)image_size_value_changed, image);
set_font_size (button, i);
gtk_widget_set_valign (button, GTK_ALIGN_BASELINE);
gtk_container_add (GTK_CONTAINER (hbox), button);
}
}
gtk_widget_show (window);
gtk_main ();
return 0;
}
static void
target_version_box_fill (GladeProjectProperties *properties)
{
GladeProjectPropertiesPrivate *priv = properties->priv;
GladeProject *project = priv->project;
GtkWidget *vbox = priv->toolkit_box;
GtkWidget *label, *active_radio, *target_radio, *hbox;
GList *list, *targets;
/* Add stuff to vbox */
for (list = glade_app_get_catalogs (); list; list = g_list_next (list))
{
GladeCatalog *catalog = list->data;
gint minor, major;
/* Skip if theres only one option */
if (g_list_length (glade_catalog_get_targets (catalog)) <= 1)
continue;
glade_project_get_target_version (project,
glade_catalog_get_name (catalog),
&major, &minor);
/* Special case to mark GTK+ in upper case */
if (strcmp (glade_catalog_get_name (catalog), "gtk+") == 0)
label = gtk_label_new ("GTK+");
else
label = gtk_label_new (glade_catalog_get_name (catalog));
gtk_misc_set_alignment (GTK_MISC (label), 0.0F, 0.5F);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, TRUE, 2);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
active_radio = target_radio = NULL;
for (targets = glade_catalog_get_targets (catalog);
targets; targets = targets->next)
{
GladeTargetableVersion *version = targets->data;
gchar *name = g_strdup_printf ("%d.%d",
version->major,
version->minor);
if (!target_radio)
target_radio = gtk_radio_button_new_with_label (NULL, name);
else
target_radio =
gtk_radio_button_new_with_label_from_widget
(GTK_RADIO_BUTTON (target_radio), name);
g_free (name);
g_signal_connect (G_OBJECT (target_radio), "clicked",
G_CALLBACK (target_button_clicked), properties);
g_object_set_data (G_OBJECT (target_radio), "version", version);
g_object_set_data (G_OBJECT (target_radio), "catalog",
(gchar *) glade_catalog_get_name (catalog));
gtk_widget_show (target_radio);
gtk_box_pack_end (GTK_BOX (hbox), target_radio, TRUE, TRUE, 2);
if (major == version->major && minor == version->minor)
active_radio = target_radio;
}
if (active_radio)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (active_radio), TRUE);
g_hash_table_insert (priv->target_radios,
g_strdup (glade_catalog_get_name (catalog)),
gtk_radio_button_get_group (GTK_RADIO_BUTTON
(active_radio)));
}
else
g_warning ("Corrupt catalog versions");
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 2);
}
}
static GtkWidget *
message_get_properties(Message *message)
{
MessageDialog *prop_dialog;
GtkWidget *dialog;
GtkWidget *entry;
GtkWidget *hbox;
GtkWidget *label;
GSList *group;
if (properties_dialog == NULL) {
prop_dialog = g_new(MessageDialog, 1);
properties_dialog = prop_dialog;
dialog = gtk_vbox_new(FALSE, 0);
prop_dialog->dialog = dialog;
hbox = gtk_hbox_new(FALSE, 5);
label = gtk_label_new(_("Message:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
entry = gtk_entry_new();
prop_dialog->text = GTK_ENTRY(entry);
gtk_box_pack_start (GTK_BOX (hbox), entry, TRUE, TRUE, 0);
gtk_widget_show (label);
gtk_widget_show (entry);
gtk_box_pack_start (GTK_BOX (dialog), hbox, TRUE, TRUE, 0);
gtk_widget_show(hbox);
label = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (dialog), label, FALSE, TRUE, 0);
gtk_widget_show (label);
label = gtk_label_new(_("Message type:"));
gtk_box_pack_start (GTK_BOX (dialog), label, FALSE, TRUE, 0);
gtk_widget_show (label);
/* */
prop_dialog->m_call = gtk_radio_button_new_with_label (NULL, _("Call"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_call, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_call);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (prop_dialog->m_call), TRUE);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_call));
prop_dialog->m_return = gtk_radio_button_new_with_label(group, _("Return"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_return, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_return);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_return));
prop_dialog->m_send = gtk_radio_button_new_with_label(group, _("Asynchronous"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_send, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_send);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_send));
prop_dialog->m_create = gtk_radio_button_new_with_label(group, _("Create"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_create, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_create);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_create));
prop_dialog->m_destroy = gtk_radio_button_new_with_label(group, _("Destroy"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_destroy, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_destroy);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_destroy));
prop_dialog->m_simple = gtk_radio_button_new_with_label(group, _("Simple"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_simple, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_simple);
group = gtk_radio_button_group (GTK_RADIO_BUTTON (prop_dialog->m_simple));
prop_dialog->m_recursive = gtk_radio_button_new_with_label(group, _("Recursive"));
gtk_box_pack_start (GTK_BOX (dialog), prop_dialog->m_recursive, TRUE, TRUE, 0);
gtk_widget_show (prop_dialog->m_recursive);
}
fill_in_dialog(message);
gtk_widget_show (properties_dialog->dialog);
return properties_dialog->dialog;
}
gint* mooLevelSettings(GtkMenuItem *menuitem, gint* LEVEL)
{
GtkWidget *mooPreferences;
GtkWidget *vBox;
GtkWidget *vBoxRadio;
GtkWidget *button;
GtkWidget *l1, *l2, *l3;
menu = menuitem;
*LEVEL = 4;
DIG_SELECTED = LEVEL;
mooPreferences = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (mooPreferences, 200, 190);
gtk_window_set_title (GTK_WINDOW (mooPreferences), "Select Game Level");
gtk_container_set_border_width (GTK_CONTAINER (mooPreferences), 10);
gtk_window_set_position (GTK_WINDOW (mooPreferences), GTK_WIN_POS_CENTER);
gtk_window_set_resizable (GTK_WINDOW (mooPreferences), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (mooPreferences), GTK_STOCK_PREFERENCES);
g_signal_connect (G_OBJECT (mooPreferences), "delete_event",
G_CALLBACK (close_settings), NULL);
vBox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (mooPreferences), vBox);
gtk_widget_show (vBox);
vBoxRadio = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vBoxRadio), 10);
gtk_box_pack_start (GTK_BOX (vBox), vBoxRadio, TRUE, TRUE, 0);
gtk_widget_show (vBoxRadio);
/*Level 1*/
l1 = gtk_radio_button_new_with_label ( NULL, "Easy: 3 Digits" );
/*Level 2*/
l2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (l1), "Medium: 4 Digits");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (l2), TRUE);
/*Level 3*/
l3 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (l1), "Hard: 5 Digits");
gtk_box_pack_start (GTK_BOX (vBoxRadio), l1, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vBoxRadio), l2, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vBoxRadio), l3, TRUE, TRUE, 0);
gtk_widget_show (l1);
gtk_widget_show (l2);
gtk_widget_show (l3);
g_signal_connect (G_OBJECT (l1), "toggled",
G_CALLBACK (radio1Clicked), NULL);
g_signal_connect (G_OBJECT (l2), "toggled",
G_CALLBACK (radio2Clicked), NULL);
g_signal_connect (G_OBJECT (l3), "toggled",
G_CALLBACK (radio3Clicked), NULL);
vBoxRadio = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vBoxRadio), 10);
gtk_box_pack_start (GTK_BOX (vBox), vBoxRadio, FALSE, TRUE, 0);
gtk_widget_show (vBoxRadio);
button = gtk_button_new_with_label ("Moo");
gtk_box_pack_start (GTK_BOX (vBoxRadio), button, TRUE, TRUE, 0);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_HALF);
gtk_widget_show (button);
g_signal_connect_swapped (G_OBJECT (button), "clicked",
G_CALLBACK (close_settings), (gpointer)mooPreferences);
gtk_widget_show (mooPreferences);
return DIG_SELECTED;
}
GtkWidget *
do_form_model_change (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *models [3];
window = gtk_dialog_new_with_buttons ("Changing data in a GdauiForm",
GTK_WINDOW (do_widget),
0,
"Close", GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The data in the same GdauiForm widget can be change don the fly.");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* creating data models */
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products ORDER BY ref, category LIMIT 15", NULL, NULL);
models[0] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[0]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products WHERE price > 20.2 ORDER BY ref, category LIMIT 10", NULL, NULL);
models[1] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[1]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT name, price, ref, category FROM products WHERE price > 20.2 ORDER BY name LIMIT 30", NULL, NULL);
models[2] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[2]), NULL);
g_object_unref (stmt);
/* allow choosing which data model to display */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>Choose which data model to display:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
GtkWidget *layout, *rb;
GSList *group = NULL;
gint i;
layout = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (vbox), layout, FALSE, FALSE, 0);
for (i = 0; i < 3; i++) {
gchar *str;
str = g_strdup_printf ("%d columns x %d rows", gda_data_model_get_n_columns (models[i]),
gda_data_model_get_n_rows (models[i]));
rb = gtk_radio_button_new_with_label (group, str);
g_free (str);
gtk_grid_attach (GTK_GRID (layout), rb, i, 0, 1, 1);
g_signal_connect (rb, "toggled", G_CALLBACK (model_toggled_cb), models[i]);
g_object_set_data_full (G_OBJECT (rb), "model", models[i], g_object_unref);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb));
}
/* Create the form widget */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>GdauiForm:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
form = gdaui_form_new (models[0]);
g_object_set (G_OBJECT (form), "info-flags",
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_ROW_MOVE_BUTTONS |
GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS, NULL);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
GdaDataProxy *proxy;
proxy = gdaui_data_proxy_get_proxy (GDAUI_DATA_PROXY (form));
g_object_set (proxy, "cache-changes", TRUE, NULL);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
//This function returns a table containing the elements of the page arranged
GtkWidget * setPageLayout(GtkWidget* window, GtkWidget* browserForm){
GtkWidget * tableInitialing;
GtkWidget *image;
GtkWidget * mainSearchBox, *miniSearchBox, *centerSearchBox;
GtkWidget *searchMainBut, *searchMiniBut, *searchCenterBut, *exitButton , *goBackBut, *stopBut, *frontBut;
GtkWidget *scrolledWindow;
GtkWidget *webView;
GtkWidget *pageLayoutExpander;
webView = webkit_web_view_new();
pageLayoutExpander = gtk_expander_new_with_mnemonic("V_iew page");
//creates a table with 20 rows and 17 columns
tableInitialing = gtk_table_new( 30, 17, TRUE);
exitButton = gtk_button_new_with_mnemonic("E_xit One click browser");
g_signal_connect_swapped( G_OBJECT(exitButton), "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer) window);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), exitButton, 0, 17, 29,30);
//Start of expander setting
//declaration of variables involved in setting position of tabs
GtkWidget *settingExpander, *expanderVBox;
GtkWidget *setTapUpRadio, *setTapDownRadio, *clearHistoryBut, *viewHistoryBut;
GtkWidget *facebookLogo, *twitterLogo, *gmailLogo, *skypeLogo, *googleLogo;
GtkWidget *facebookEventBox, *twitterEventBox, *gmailEventBox, *skypeEventBox, *googleEventBox;
//Initialising variables
setTapUpRadio = gtk_radio_button_new_with_label(NULL,"Set tab position up");
setTapDownRadio = gtk_radio_button_new_with_label_from_widget( GTK_RADIO_BUTTON(setTapUpRadio), "Set tab position down");
//Initialises the clearHistoryBut and associate a callback to it
clearHistoryBut = gtk_button_new_with_mnemonic("_Clear history");
g_signal_connect(G_OBJECT(clearHistoryBut), "clicked", G_CALLBACK(clearHistory), NULL);
viewHistoryBut = gtk_button_new_with_mnemonic("_View history");
g_signal_connect_swapped(G_OBJECT(viewHistoryBut),"clicked", G_CALLBACK(viewHistory), NULL);
//Initialises the expander and the vbox
settingExpander = gtk_expander_new_with_mnemonic("_Settings");
expanderVBox = gtk_vbox_new(TRUE, 0);
//Adds radio buttons to the vbox
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapUpRadio);
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), setTapDownRadio);
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), clearHistoryBut);
gtk_box_pack_start_defaults( GTK_BOX(expanderVBox), viewHistoryBut);
//Linking signals of radio buttons to the respective callbacks
g_signal_connect_swapped( G_OBJECT(setTapUpRadio), "toggled", G_CALLBACK(setTapUp), browserForm);
g_signal_connect_swapped( G_OBJECT(setTapDownRadio), "toggled", G_CALLBACK(setTapDown), browserForm);
gtk_container_add( GTK_CONTAINER(settingExpander), expanderVBox);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing),settingExpander, 0,3,20,24);
//End of expander setting
goBackBut = gtk_button_new_with_label(" <-- ");
gtk_widget_set_size_request(goBackBut, 10, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), goBackBut, 1, 2, 1, 2);
g_signal_connect_swapped(goBackBut, "clicked", G_CALLBACK(back), webView);
stopBut = gtk_button_new_with_label(" X ");
gtk_widget_set_size_request(stopBut, 10, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), stopBut, 2, 3, 1, 2);
g_signal_connect_swapped(stopBut, "clicked", G_CALLBACK(stop), webView);
frontBut = gtk_button_new_with_label(" --> ");
gtk_widget_set_size_request(frontBut, 10, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), frontBut, 16, 17, 1, 2);
g_signal_connect_swapped(frontBut, "clicked", G_CALLBACK(forward), webView);
//This patch of code initiates autocompletion of the search box
GtkEntryCompletion *completion;
GtkTreeIter *iter;
GtkListStore *store_list;
FILE * historyPtr;
store_list = gtk_list_store_new(1,G_TYPE_STRING);
completion = gtk_entry_completion_new();
if( (historyPtr = fopen("History/History.htm","r+")) == NULL)
g_print("Error");
gchar historyString[100];
while( !feof(historyPtr)){
fscanf(historyPtr,"%s",historyString);
gtk_list_store_append(store_list, iter);
gtk_list_store_set(store_list, iter, 0, historyString, -1);
}
fclose(historyPtr);
gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(store_list));
gtk_entry_completion_set_text_column(completion, 0);
mainSearchBox = gtk_entry_new();
gtk_entry_set_completion(GTK_ENTRY(mainSearchBox), completion);
gtk_widget_set_size_request(mainSearchBox, 500, 25);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), mainSearchBox, 3, 15, 1, 2 );
g_signal_connect_swapped(mainSearchBox, "activate", G_CALLBACK(activate), webView);
searchMainBut = gtk_button_new_with_mnemonic("Sear_ch");
gtk_widget_set_size_request(searchMainBut, 10,15);
gtk_table_attach_defaults( GTK_TABLE(tableInitialing), searchMainBut, 15, 16, 1, 2 );
g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(setUri), mainSearchBox);
g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(go), webView);
//g_signal_connect_swapped(searchMainBut, "clicked", G_CALLBACK(initialiseEntryCompletion), completion);
//Linking callbacks to signals emitted by webview widget
g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-progress-changed",G_CALLBACK(progress),mainSearchBox);
g_signal_connect(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(finished),mainSearchBox);
scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW(scrolledWindow), webView);
gtk_widget_show_all(scrolledWindow);
//PageLayout expander
//gtk_widget_set_sensitive(pageLayoutExpander, FALSE);
gtk_container_add( GTK_CONTAINER(pageLayoutExpander), scrolledWindow);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), pageLayoutExpander, 0, 17, 2, 29);
g_signal_connect_swapped(WEBKIT_WEB_VIEW(webView),"load-finished",G_CALLBACK(viewSearchedPage),pageLayoutExpander);
image = gtk_image_new_from_file("images/OneClickLogo.png");
GtkWidget* imageEventBox = initialiseEventBox(image);
g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(searchOneClick), webView);
g_signal_connect( G_OBJECT(imageEventBox), "button_press_event", G_CALLBACK(logoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), imageEventBox, 3, 14, 14, 24);
//Adding pictures of some social media to the browser's home page
facebookLogo = gtk_image_new_from_file("images/facebook.jpg");
skypeLogo = gtk_image_new_from_file("images/skype.jpg");
twitterLogo = gtk_image_new_from_file("images/twitter.jpg");
gmailLogo = gtk_image_new_from_file("images/gmail.jpg");
googleLogo = gtk_image_new_from_file("images/google.jpg");
//Adding event handlers to images
facebookEventBox = initialiseEventBox(facebookLogo);
g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(searchFacebook), webView);
g_signal_connect( G_OBJECT(facebookEventBox), "button_press_event", G_CALLBACK(facebookLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), facebookEventBox, 4, 6, 24, 28 );
gmailEventBox = initialiseEventBox(gmailLogo);
g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(searchGmail), webView);
g_signal_connect( G_OBJECT(gmailEventBox), "button_press_event", G_CALLBACK(gmailLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), gmailEventBox, 6, 8, 24, 28 );
twitterEventBox = initialiseEventBox(twitterLogo);
g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(searchTwitter), webView);
g_signal_connect( G_OBJECT(twitterEventBox), "button_press_event", G_CALLBACK(twitterLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), twitterEventBox, 8, 10, 24, 28 );
skypeEventBox = initialiseEventBox(skypeLogo);
g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(searchSKype), webView);
g_signal_connect( G_OBJECT(skypeEventBox), "button_press_event", G_CALLBACK(skypeLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), skypeEventBox, 10, 12, 24, 28 );
googleEventBox = initialiseEventBox(googleLogo);
g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(searchGoogle), webView);
g_signal_connect( G_OBJECT(googleEventBox), "button_press_event", G_CALLBACK(googleLogoClicked), mainSearchBox);
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), googleEventBox, 12, 14, 24, 28 );
//This patch of code implements the file chooser button that opens files on the user's computer
GtkWidget *openFileChooser;
openFileChooser = gtk_file_chooser_button_new("Select an html document to open",GTK_FILE_CHOOSER_ACTION_OPEN);
g_signal_connect_swapped(G_OBJECT(openFileChooser), "selection_changed", G_CALLBACK(openFile), webView);
//gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(openFileChooser), g_get_home_dir());
gtk_table_attach_defaults(GTK_TABLE(tableInitialing), openFileChooser, 4, 12, 0, 1 );
GtkFileFilter *filter;
filter = gtk_file_filter_new();
gtk_file_filter_set_name (filter, "HTML Files");
gtk_file_filter_add_pattern (filter, "*.html");
gtk_file_filter_add_pattern (filter, "*.htm");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (openFileChooser), filter);
return tableInitialing;
}
static GtkWidget *
account_assistant_build_introduction_page (EmpathyAccountAssistant *self)
{
EmpathyAccountAssistantPriv *priv = GET_PRIV (self);
GtkWidget *main_vbox, *hbox_1, *w, *vbox_1;
GtkWidget *radio = NULL;
GdkPixbuf *pix;
const gchar *str;
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_widget_show (main_vbox);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
hbox_1 = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox_1, TRUE, TRUE, 0);
gtk_widget_show (hbox_1);
w = gtk_label_new (
_("With Empathy you can chat with people "
"online nearby and with friends and colleagues "
"who use Google Talk, AIM, Windows Live "
"and many other chat programs. With a microphone "
"or a webcam you can also have audio or video calls."));
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_box_pack_start (GTK_BOX (hbox_1), w, FALSE, FALSE, 0);
gtk_widget_show (w);
pix = empathy_pixbuf_from_icon_name_sized ("empathy", 80);
w = gtk_image_new_from_pixbuf (pix);
gtk_box_pack_start (GTK_BOX (hbox_1), w, FALSE, FALSE, 6);
gtk_widget_show (w);
g_object_unref (pix);
w = gtk_label_new (_("Do you have an account you've been using "
"with another chat program?"));
gtk_misc_set_alignment (GTK_MISC (w), 0, 0);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
w = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), w, TRUE, TRUE, 0);
gtk_widget_show (w);
vbox_1 = gtk_vbox_new (TRUE, 0);
gtk_container_add (GTK_CONTAINER (w), vbox_1);
gtk_widget_show (vbox_1);
if (empathy_import_accounts_to_import ())
{
hbox_1 = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox_1), hbox_1, TRUE, TRUE, 0);
gtk_widget_show (hbox_1);
radio = gtk_radio_button_new_with_label (NULL,
_("Yes, import my account details from "));
gtk_box_pack_start (GTK_BOX (hbox_1), radio, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (radio), "response",
GINT_TO_POINTER (RESPONSE_IMPORT));
gtk_widget_show (radio);
w = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (w), "Pidgin");
gtk_box_pack_start (GTK_BOX (hbox_1), w, TRUE, TRUE, 0);
gtk_combo_box_set_active (GTK_COMBO_BOX (w), 0);
gtk_widget_show (w);
g_signal_connect (radio, "clicked",
G_CALLBACK (account_assistant_radio_choice_toggled_cb), self);
priv->first_resp = RESPONSE_IMPORT;
}
else
{
priv->first_resp = RESPONSE_ENTER_ACCOUNT;
}
str = _("Yes, I'll enter my account details now");
if (radio == NULL)
{
radio = gtk_radio_button_new_with_label (NULL, str);
w = radio;
}
else
{
w = gtk_radio_button_new_with_label_from_widget (
GTK_RADIO_BUTTON (radio), str);
}
gtk_box_pack_start (GTK_BOX (vbox_1), w, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (w), "response",
GINT_TO_POINTER (RESPONSE_ENTER_ACCOUNT));
gtk_widget_show (w);
g_signal_connect (w, "clicked",
G_CALLBACK (account_assistant_radio_choice_toggled_cb), self);
w = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio),
_("No, I want a new account"));
gtk_box_pack_start (GTK_BOX (vbox_1), w, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (w), "response",
GINT_TO_POINTER (RESPONSE_CREATE_ACCOUNT));
gtk_widget_show (w);
g_signal_connect (w, "clicked",
G_CALLBACK (account_assistant_radio_choice_toggled_cb), self);
w = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio),
_("No, I just want to see people online nearby for now"));
gtk_box_pack_start (GTK_BOX (vbox_1), w, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (w), "response",
GINT_TO_POINTER (RESPONSE_SALUT_ONLY));
gtk_widget_show (w);
g_signal_connect (w, "clicked",
G_CALLBACK (account_assistant_radio_choice_toggled_cb), self);
return main_vbox;
}
static GtkWidget *
account_assistant_build_enter_or_create_page (EmpathyAccountAssistant *self)
{
EmpathyAccountAssistantPriv *priv = GET_PRIV (self);
GtkWidget *main_vbox, *w, *chooser, *vbox, *hbox, *radio;
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_widget_show (main_vbox);
w = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (w), 0, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
priv->first_label = w;
w = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
chooser = empathy_protocol_chooser_new ();
gtk_container_add (GTK_CONTAINER (w), chooser);
gtk_widget_show (chooser);
priv->chooser = chooser;
vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_end (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
w = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_misc_set_alignment (GTK_MISC (w), 0.0, 0.5);
gtk_widget_show (w);
priv->second_label = w;
w = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (w), 0, 0, 12, 0);
gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
gtk_widget_show (w);
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (w), hbox);
gtk_widget_show (hbox);
radio = gtk_radio_button_new_with_label (NULL, _("Yes"));
gtk_box_pack_start (GTK_BOX (hbox), radio, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (radio), "response",
GINT_TO_POINTER (RESPONSE_CREATE_AGAIN));
gtk_widget_show (radio);
w = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio),
_("No, that's all for now"));
gtk_box_pack_start (GTK_BOX (hbox), w, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (w), "response",
GINT_TO_POINTER (RESPONSE_CREATE_STOP));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), TRUE);
priv->create_enter_resp = RESPONSE_CREATE_STOP;
priv->create_again_radio = w;
gtk_widget_show (w);
g_signal_connect (w, "clicked",
G_CALLBACK (account_assistant_radio_create_again_clicked_cb), self);
g_signal_connect (radio, "clicked",
G_CALLBACK (account_assistant_radio_create_again_clicked_cb), self);
return main_vbox;
}
exec_on_incoming_entry = gtk_entry_new();
gtk_table_attach_defaults(GTK_TABLE(table), exec_on_incoming_entry, 1,2,2,3);
gtk_entry_set_text(GTK_ENTRY(exec_on_incoming_entry),
session->exec_on_incoming);
gtk_widget_show(exec_on_incoming_entry);
frame = gtk_frame_new(_("Recording Format"));
gtk_container_set_border_width(GTK_CONTAINER(frame), 10);
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
gtk_widget_show(frame);
vbox2 = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox2);
gtk_widget_show(vbox2);
recformat_radiobutton = gtk_radio_button_new_with_label(NULL,
_("Microsoft WAV, uLaw"));
gtk_box_pack_start(GTK_BOX(vbox2), recformat_radiobutton, FALSE, FALSE, 0);
gtk_widget_show(recformat_radiobutton);
gtk_object_set_data(GTK_OBJECT(recformat_radiobutton),
"rec_format", (gpointer) (RECORDING_FORMAT_WAV | RECORDING_FORMAT_ULAW));
if (session->option_recording_format == (enum recording_format_t)
gtk_object_get_data(GTK_OBJECT(recformat_radiobutton), "rec_format"))
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(recformat_radiobutton),TRUE);
recformat_radiobutton = gtk_radio_button_new_with_label_from_widget(
GTK_RADIO_BUTTON(recformat_radiobutton), _("Microsoft WAV, 16-bit signed"));
gtk_box_pack_start(GTK_BOX(vbox2), recformat_radiobutton, FALSE, FALSE, 0);
gtk_widget_show(recformat_radiobutton);
gtk_object_set_data(GTK_OBJECT(recformat_radiobutton),
"rec_format", (gpointer) (RECORDING_FORMAT_WAV | RECORDING_FORMAT_S16));
if (session->option_recording_format == (enum recording_format_t)
/*******************************************************************************
* prefs_imagewin_page:
* @ Create Image Window preference page.
*
* Return : Packed widget (GtkVbox)
*******************************************************************************/
GtkWidget *
prefs_imagewin_page (void)
{
GtkWidget *main_vbox, *frame, *hbox, *hbox2, *hbox3, *vbox;
GtkWidget *label, *button, *spinner, *toggle, *radio[3];
GtkAdjustment *adj;
main_vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 5);
/**********************************************
* Window Frame
**********************************************/
gimv_prefs_ui_create_frame(_("Window"), frame, vbox, main_vbox, FALSE);
/* Save window state on exit */
toggle = gtkutil_create_check_button (_("Save window state on exit"),
conf.imgwin_save_win_state,
cb_save_imgwin_state,
&config_changed->imgwin_save_win_state);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
/* Window width and height spinner */
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER(hbox), 5);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (_("Initial window size: "));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
label = gtk_label_new (_("width"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
adj = (GtkAdjustment *) gtk_adjustment_new (conf.imgwin_width,
1.0, 10000.0, 1.0, 5.0, 0.0);
spinner = gtkutil_create_spin_button (adj);
prefs_win.imgwin_width_spin = spinner;
gtk_widget_set_size_request(spinner, 50, -1);
g_signal_connect (G_OBJECT (adj), "value_changed",
G_CALLBACK (gtkutil_get_data_from_adjustment_by_int_cb),
&config_changed->imgwin_width);
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);
label = gtk_label_new (_("height"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
adj = (GtkAdjustment *) gtk_adjustment_new (conf.imgwin_height,
1.0, 10000.0, 1.0, 5.0, 0.0);
spinner = gtkutil_create_spin_button (adj);
prefs_win.imgwin_height_spin = spinner;
gtk_widget_set_size_request(spinner, 50, -1);
g_signal_connect (G_OBJECT (adj), "value_changed",
G_CALLBACK (gtkutil_get_data_from_adjustment_by_int_cb),
&config_changed->imgwin_height);
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0);
/* Auto resize window to image size */
toggle = gtkutil_create_check_button (_("Auto resize to image size"),
conf.imgwin_fit_to_image,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgwin_fit_to_image);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
/* Open New Window or not */
toggle = gtkutil_create_check_button (_("Open each file in separate window"),
conf.imgwin_open_new_win,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgwin_open_new_win);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
/* Raise window or not */
toggle = gtkutil_create_check_button (_("Raise window when open image in shared window"),
conf.imgwin_raise_window,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgwin_raise_window);
gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
/**********************************************
* Show/Hide Frame
**********************************************/
gimv_prefs_ui_create_frame(_("Show/Hide"), frame, vbox, main_vbox, FALSE);
hbox = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER(hbox), 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
hbox2 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER(hbox2), 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0);
hbox3 = gtk_hbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER(hbox3), 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox3, FALSE, FALSE, 0);
/* Show Menubar or not */
toggle = gtkutil_create_check_button (_("Menubar"),
conf.imgwin_show_menubar,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgwin_show_menubar);
prefs_win.imgwin_menubar_toggle = toggle;
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
/* Show Toolbar or not */
toggle = gtkutil_create_check_button (_("Toolbar"),
conf.imgwin_show_toolbar,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgwin_show_toolbar);
prefs_win.imgwin_toolbar_toggle = toggle;
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
/* Show Player toolbar or not */
toggle = gtkutil_create_check_button (_("Slide show player"),
conf.imgwin_show_player,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgwin_show_player);
prefs_win.imgwin_player_toggle = toggle;
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
/* Show Statusbar or not */
toggle = gtkutil_create_check_button (_("Statusbar"),
conf.imgwin_show_statusbar,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgwin_show_statusbar);
prefs_win.imgwin_statusbar_toggle = toggle;
gtk_box_pack_start (GTK_BOX (hbox2), toggle, FALSE, FALSE, 0);
/* Show Scrollbar or not */
toggle = gtkutil_create_check_button (_("Scrollbar"),
conf.imgview_scrollbar,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgview_scrollbar);
prefs_win.imgwin_scrollbar_toggle = toggle;
gtk_box_pack_start (GTK_BOX (hbox2), toggle, FALSE, FALSE, 0);
/* player */
label = gtk_label_new (_("Player toolbar :"));
gtk_box_pack_start (GTK_BOX (hbox3), label, FALSE, FALSE, 0);
prefs_win.imgwin_player_label = label;
radio[0] = gtk_radio_button_new_with_label (NULL, _("Show"));
gtk_box_pack_start (GTK_BOX (hbox3), radio[0], FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (radio[0]), "toggled",
G_CALLBACK (cb_player_visible),
GINT_TO_POINTER(GimvImageViewPlayerVisibleShow));
prefs_win.imgwin_player_radio[0] = radio[0];
radio[1] = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio[0]),
_("Hide"));
gtk_box_pack_start (GTK_BOX (hbox3), radio[1], FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (radio[1]), "toggled",
G_CALLBACK (cb_player_visible),
GINT_TO_POINTER(GimvImageViewPlayerVisibleHide));
prefs_win.imgwin_player_radio[1] = radio[1];
radio[2] = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio[1]),
_("Auto"));
gtk_box_pack_start (GTK_BOX (hbox3), radio[2], FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (radio[2]), "toggled",
G_CALLBACK (cb_player_visible),
GINT_TO_POINTER(GimvImageViewPlayerVisibleAuto));
prefs_win.imgwin_player_radio[2] = radio[2];
switch (config_changed->imgview_player_visible) {
case GimvImageViewPlayerVisibleShow:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio[0]), TRUE);
break;
case GimvImageViewPlayerVisibleHide:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio[1]), TRUE);
break;
case GimvImageViewPlayerVisibleAuto:
default:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio[2]), TRUE);
break;
}
/**********************************************
* Back Ground Frame
**********************************************/
gimv_prefs_ui_create_frame(_("Back Ground"), frame, vbox, main_vbox, FALSE);
/* back ground color of normal window */
hbox = gtk_hbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER(hbox), 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
toggle = gtkutil_create_check_button (_("Specify back ground color"),
conf.imgwin_set_bg,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgwin_set_bg);
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
button = gtkutil_color_sel_button (_("Choose Color"),
config_changed->imgwin_bg_color);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
/* back ground color of fullscreen window */
hbox = gtk_hbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER(hbox), 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
toggle = gtkutil_create_check_button (_("Specify back ground color of fullscreen"),
conf.imgwin_fullscreen_set_bg,
gtkutil_get_data_from_toggle_cb,
&config_changed->imgwin_fullscreen_set_bg);
gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0);
button = gtkutil_color_sel_button (_("Choose Color"),
config_changed->imgwin_fullscreen_bg_color);
gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0);
set_sensitive_imgwin_state ();
gtk_widget_show_all (main_vbox);
return main_vbox;
}
//*********************************************************************************
void guiControl::guiControl(void *button, void* data)
{
if (pos_winPid != NULL)
{
gtk_window_set_keep_above (GTK_WINDOW(pos_winPid),true);
return;
}
gtkClassData* currentClassData = (gtkClassData*) data;
partMover *currentPart = currentClassData->partPointer;
joint = currentClassData->indexPointer;
icntrl2 = currentPart->get_IControlMode2();
iinteract = currentPart->get_IInteractionMode();
ipid = currentPart->get_IPidControl();
iamp = currentPart->get_IAmplifierControl();
bool ret = true;
int control_mode=VOCAB_CM_UNKNOWN;
yarp::dev::InteractionModeEnum interaction_mode=VOCAB_IM_UNKNOWN;
ret &= icntrl2->getControlMode(*joint, &control_mode);
ret &= iinteract->getInteractionMode(*joint, &interaction_mode);
if (control_mode==VOCAB_CM_HW_FAULT)
{
printf("WARNING: you cannot change control mode of a joint in HARDWARE FAULT\n");
return;
}
//GtkWidget *winPid = NULL;
GtkWidget *inv = NULL;
//adding a popup window
pos_winPid = gtk_window_new (GTK_WINDOW_TOPLEVEL);
char title[255];
sprintf(title,"Control mode JNT:%d",*joint);
gtk_window_set_title (GTK_WINDOW (pos_winPid), title);
//adding a set of display
inv = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (pos_winPid), inv);
label_title = gtk_label_new (title);
sprintf(title,"Interaction mode JNT:%d",*joint);
label_title2 = gtk_label_new (title);
radiobutton_mode_idl = gtk_radio_button_new_with_label (NULL, "idle");
radiobutton_mode_pos = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "position");
radiobutton_mode_vel = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "velocity");
radiobutton_mode_trq = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "torque");
radiobutton_mode_imp_pos = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "impedance position");
radiobutton_mode_imp_vel = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "impedance velocity");
radiobutton_mode_open = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "openloop");
radiobutton_mode_pos_direct = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "position direct");
radiobutton_mode_mixed = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_mode_idl), "mixed");
radiobutton_interaction_stiff = gtk_radio_button_new_with_label (NULL, "stiff mode");
radiobutton_interaction_compl = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radiobutton_interaction_stiff), "compliant mode");
gtk_fixed_put (GTK_FIXED(inv), label_title, 10, 10 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_idl, 10, 30 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_pos, 10, 50 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_pos_direct, 10, 70 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_mixed, 10, 90 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_vel, 10, 110 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_trq, 10, 130 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_imp_pos, 10, 150 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_imp_vel, 10, 170 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_mode_open, 10, 190 );
gtk_fixed_put (GTK_FIXED(inv), label_title2, 10, 210 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_interaction_stiff,10, 230 );
gtk_fixed_put (GTK_FIXED(inv), radiobutton_interaction_compl,10, 250 );
update_menu(control_mode, interaction_mode);
gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_pos_direct), position_direct_enabled);
gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_open), openloop_enabled);
gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_imp_pos), old_impedance_enabled);
gtk_widget_set_sensitive (GTK_WIDGET(radiobutton_mode_imp_vel), old_impedance_enabled);
//Rememeber: these signal_connect MUST be placed after the update_menu!
g_signal_connect (radiobutton_mode_idl, "clicked",G_CALLBACK (radio_click_idl), &radiobutton_mode_idl);
g_signal_connect (radiobutton_mode_pos, "clicked",G_CALLBACK (radio_click_pos), &radiobutton_mode_pos);
g_signal_connect (radiobutton_mode_pos_direct, "clicked",G_CALLBACK (radio_click_pos_direct), &radiobutton_mode_pos_direct);
g_signal_connect (radiobutton_mode_mixed, "clicked",G_CALLBACK (radio_click_mode_mixed), &radiobutton_mode_mixed);
g_signal_connect (radiobutton_mode_vel, "clicked",G_CALLBACK (radio_click_vel), &radiobutton_mode_vel);
g_signal_connect (radiobutton_mode_trq, "clicked",G_CALLBACK (radio_click_trq), &radiobutton_mode_trq);
g_signal_connect (radiobutton_mode_imp_pos, "clicked",G_CALLBACK (radio_click_imp_pos), &radiobutton_mode_imp_pos);
g_signal_connect (radiobutton_mode_imp_vel, "clicked",G_CALLBACK (radio_click_imp_vel), &radiobutton_mode_imp_vel);
g_signal_connect (radiobutton_mode_open, "clicked",G_CALLBACK (radio_click_open), &radiobutton_mode_open);
g_signal_connect (radiobutton_interaction_stiff, "clicked",G_CALLBACK (radio_click_stiff), &radiobutton_interaction_stiff);
g_signal_connect (radiobutton_interaction_compl, "clicked",G_CALLBACK (radio_click_compl), &radiobutton_interaction_compl);
g_signal_connect (radiobutton_mode_idl, "key_press_event", G_CALLBACK (on_key_press), &radiobutton_mode_idl);
g_signal_connect (radiobutton_mode_pos, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_pos);
g_signal_connect (radiobutton_mode_pos_direct, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_pos_direct);
g_signal_connect (radiobutton_mode_mixed, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_mixed);
g_signal_connect (radiobutton_mode_vel, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_vel);
g_signal_connect (radiobutton_mode_trq, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_trq);
g_signal_connect (radiobutton_mode_imp_pos, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_imp_pos);
g_signal_connect (radiobutton_mode_imp_vel, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_imp_vel);
g_signal_connect (radiobutton_mode_open, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_mode_open);
g_signal_connect (radiobutton_interaction_stiff, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_interaction_stiff);
g_signal_connect (radiobutton_interaction_compl, "key_press_event",G_CALLBACK (on_key_press), &radiobutton_interaction_compl);
//connection to the destroyer
g_signal_connect (pos_winPid, "destroy",G_CALLBACK (destroy_main), &pos_winPid);
//make it visible
if (!GTK_WIDGET_VISIBLE (pos_winPid))
gtk_widget_show_all (pos_winPid);
else
{
gtk_widget_destroy (pos_winPid);
pos_winPid = NULL;
}
gtk_window_set_keep_above (GTK_WINDOW(pos_winPid),true);
gtk_main ();
return;
}
