CV_IMPL int cvNamedWindow( const char* name, int flags )
{
int result = 0;
CV_FUNCNAME( "cvNamedWindow" );
__BEGIN__;
CvWindow* window;
int len;
cvInitSystem(1,(char**)&name);
if( !name )
CV_ERROR( CV_StsNullPtr, "NULL name string" );
// Check the name in the storage
if( icvFindWindowByName( name ) != 0 )
{
result = 1;
EXIT;
}
len = strlen(name);
CV_CALL( window = (CvWindow*)cvAlloc(sizeof(CvWindow) + len + 1));
memset( window, 0, sizeof(*window));
window->name = (char*)(window + 1);
memcpy( window->name, name, len + 1 );
window->flags = flags;
window->signature = CV_WINDOW_MAGIC_VAL;
window->last_key = 0;
window->on_mouse = 0;
window->on_mouse_param = 0;
memset( &window->toolbar, 0, sizeof(window->toolbar));
window->next = hg_windows;
window->prev = 0;
CV_LOCK_MUTEX();
window->frame = gtk_window_new( GTK_WINDOW_TOPLEVEL );
window->paned = gtk_vbox_new( FALSE, 0 );
window->widget = cvImageWidgetNew( flags );
gtk_box_pack_end( GTK_BOX(window->paned), window->widget, TRUE, TRUE, 0 );
gtk_widget_show( window->widget );
gtk_container_add( GTK_CONTAINER(window->frame), window->paned );
gtk_widget_show( window->paned );
//
// configure event handlers
// TODO -- move this to CvImageWidget ?
gtk_signal_connect( GTK_OBJECT(window->frame), "key-press-event",
GTK_SIGNAL_FUNC(icvOnKeyPress), window );
gtk_signal_connect( GTK_OBJECT(window->widget), "button-press-event",
GTK_SIGNAL_FUNC(icvOnMouse), window );
gtk_signal_connect( GTK_OBJECT(window->widget), "button-release-event",
GTK_SIGNAL_FUNC(icvOnMouse), window );
gtk_signal_connect( GTK_OBJECT(window->widget), "motion-notify-event",
GTK_SIGNAL_FUNC(icvOnMouse), window );
gtk_signal_connect( GTK_OBJECT(window->frame), "delete-event",
GTK_SIGNAL_FUNC(icvOnClose), window );
gtk_widget_add_events (window->widget, GDK_EXPOSURE_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK) ;
gtk_widget_show( window->frame );
gtk_window_set_title( GTK_WINDOW(window->frame), name );
if( hg_windows )
hg_windows->prev = window;
hg_windows = window;
gtk_window_set_resizable( GTK_WINDOW(window->frame), (flags & CV_WINDOW_AUTOSIZE) == 0 );
// allow window to be resized
if( (flags & CV_WINDOW_AUTOSIZE)==0 ){
GdkGeometry geometry;
geometry.min_width = 50;
geometry.min_height = 50;
gtk_window_set_geometry_hints( GTK_WINDOW( window->frame ), GTK_WIDGET( window->widget ),
&geometry, (GdkWindowHints) (GDK_HINT_MIN_SIZE));
}
CV_UNLOCK_MUTEX();
result = 1;
__END__;
return result;
}
static gboolean
dialog (void)
{
/* Missing options: Color-dialogs? / own curl layer ? / transparency
to original drawable / Warp-curl (unsupported yet) */
GtkWidget *dialog;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *frame;
GtkWidget *button;
GtkWidget *combo;
GtkObject *adjustment;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (_("Pagecurl Effect"), PLUG_IN_BINARY,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
vbox = gtk_vbox_new (FALSE, 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);
frame = gimp_frame_new (_("Curl Location"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
table = gtk_table_new (3, 2, TRUE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_container_add (GTK_CONTAINER (frame), table);
curl_image = gtk_image_new ();
gtk_table_attach (GTK_TABLE (table), curl_image, 0, 2, 1, 2,
GTK_SHRINK, GTK_SHRINK, 0, 0);
gtk_widget_show (curl_image);
curl_pixbuf_update ();
{
static const gchar *name[] =
{
N_("Lower right"),
N_("Lower left"),
N_("Upper left"),
N_("Upper right")
};
gint i;
button = NULL;
for (i = CURL_EDGE_FIRST; i <= CURL_EDGE_LAST; i++)
{
button =
gtk_radio_button_new_with_label (button == NULL ?
NULL :
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
gettext (name[i - CURL_EDGE_FIRST]));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
curl.edge == i);
g_object_set_data (G_OBJECT (button),
"gimp-item-data", GINT_TO_POINTER (i));
gtk_table_attach (GTK_TABLE (table), button,
CURL_EDGE_LEFT (i) ? 0 : 1,
CURL_EDGE_LEFT (i) ? 1 : 2,
CURL_EDGE_UPPER (i) ? 0 : 2,
CURL_EDGE_UPPER (i) ? 1 : 3,
GTK_FILL | GTK_EXPAND, GTK_SHRINK, 0, 0);
gtk_widget_show (button);
g_signal_connect (button, "toggled",
G_CALLBACK (gimp_radio_button_update),
&curl.edge);
g_signal_connect (button, "toggled",
G_CALLBACK (curl_pixbuf_update),
NULL);
}
}
gtk_widget_show (table);
gtk_widget_show (frame);
frame = gimp_frame_new (_("Curl Orientation"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
hbox = gtk_hbox_new (TRUE, 6);
gtk_container_add (GTK_CONTAINER (frame), hbox);
{
static const gchar *name[] =
{
N_("_Vertical"),
N_("_Horizontal")
};
gint i;
button = NULL;
for (i = 0; i <= CURL_ORIENTATION_LAST; i++)
{
button = gtk_radio_button_new_with_mnemonic (button == NULL ?
NULL :
gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)),
gettext (name[i]));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
curl.orientation == i);
g_object_set_data (G_OBJECT (button),
"gimp-item-data", GINT_TO_POINTER (i));
gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect (button, "toggled",
G_CALLBACK (gimp_radio_button_update),
&curl.orientation);
g_signal_connect (button, "toggled",
G_CALLBACK (curl_pixbuf_update),
NULL);
}
}
gtk_widget_show (hbox);
gtk_widget_show (frame);
button = gtk_check_button_new_with_mnemonic (_("_Shade under curl"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), curl.shade);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&curl.shade);
combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL);
gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (combo),
GIMP_INT_STORE_VALUE, CURL_COLORS_GRADIENT_REVERSE,
GIMP_INT_STORE_LABEL, _("Current gradient (reversed)"),
GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_GRADIENT,
-1);
gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (combo),
GIMP_INT_STORE_VALUE, CURL_COLORS_GRADIENT,
GIMP_INT_STORE_LABEL, _("Current gradient"),
GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_GRADIENT,
-1);
gimp_int_combo_box_prepend (GIMP_INT_COMBO_BOX (combo),
GIMP_INT_STORE_VALUE, CURL_COLORS_FG_BG,
GIMP_INT_STORE_LABEL, _("Foreground / background colors"),
GIMP_INT_STORE_STOCK_ID, GIMP_STOCK_DEFAULT_COLORS,
-1);
gtk_box_pack_start (GTK_BOX (vbox), combo, FALSE, FALSE, 0);
gtk_widget_show (combo);
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
curl.colors,
G_CALLBACK (gimp_int_combo_box_get_active),
&curl.colors);
gtk_widget_show (dialog);
table = gtk_table_new (1, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
adjustment = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,
_("_Opacity:"), 100, 0,
curl.opacity * 100.0, 0.0, 100.0,
1.0, 1.0, 0.0,
TRUE, 0, 0,
NULL, NULL);
g_signal_connect (adjustment, "value-changed",
G_CALLBACK (dialog_scale_update),
&curl.opacity);
run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dialog);
return run;
}
void
sp_text_edit_dialog (void)
{
if (!dlg) {
gchar title[500];
sp_ui_dialog_title_string (Inkscape::Verb::get(SP_VERB_DIALOG_TEXT), title);
Inkscape::Preferences *prefs = Inkscape::Preferences::get();
dlg = sp_window_new (title, TRUE);
if (x == -1000 || y == -1000) {
x = prefs->getInt(prefs_path + "x", -1000);
y = prefs->getInt(prefs_path + "y", -1000);
}
if (w ==0 || h == 0) {
w = prefs->getInt(prefs_path + "w", 0);
h = prefs->getInt(prefs_path + "h", 0);
}
// if (x<0) x=0;
// if (y<0) y=0;
if (w && h)
gtk_window_resize ((GtkWindow *) dlg, w, h);
if (x >= 0 && y >= 0 && (x < (gdk_screen_width()-MIN_ONSCREEN_DISTANCE)) && (y < (gdk_screen_height()-MIN_ONSCREEN_DISTANCE))) {
gtk_window_move ((GtkWindow *) dlg, x, y);
} else {
gtk_window_set_position(GTK_WINDOW(dlg), GTK_WIN_POS_CENTER);
}
sp_transientize (dlg);
wd.win = dlg;
wd.stop = 0;
g_signal_connect ( G_OBJECT (INKSCAPE), "activate_desktop", G_CALLBACK (sp_transientize_callback), &wd );
gtk_signal_connect ( GTK_OBJECT (dlg), "event", GTK_SIGNAL_FUNC (sp_dialog_event_handler), dlg );
gtk_signal_connect ( GTK_OBJECT (dlg), "destroy", G_CALLBACK (sp_text_edit_dialog_destroy), dlg );
gtk_signal_connect ( GTK_OBJECT (dlg), "delete_event", G_CALLBACK (sp_text_edit_dialog_delete), dlg );
g_signal_connect ( G_OBJECT (INKSCAPE), "shut_down", G_CALLBACK (sp_text_edit_dialog_delete), dlg );
g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_hide", G_CALLBACK (sp_dialog_hide), dlg );
g_signal_connect ( G_OBJECT (INKSCAPE), "dialogs_unhide", G_CALLBACK (sp_dialog_unhide), dlg );
gtk_window_set_policy (GTK_WINDOW (dlg), TRUE, TRUE, FALSE);
GtkTooltips *tt = gtk_tooltips_new();
// box containing the notebook and the bottom buttons
GtkWidget *mainvb = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (dlg), mainvb);
// notebook
GtkWidget *nb = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (mainvb), nb, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "notebook", nb);
// Font tab
{
GtkWidget *l = gtk_label_new (_("Font"));
GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN);
gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
/* HBox containing font selection and layout */
GtkWidget *hb = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vb), hb, TRUE, TRUE, 0);
// font and style selector
GtkWidget *fontsel = sp_font_selector_new ();
g_signal_connect ( G_OBJECT (fontsel), "font_set", G_CALLBACK (sp_text_edit_dialog_font_changed), dlg );
g_signal_connect_swapped ( G_OBJECT (g_object_get_data (G_OBJECT(fontsel), "family-treeview")),
"row-activated",
G_CALLBACK (gtk_window_activate_default),
dlg);
gtk_box_pack_start (GTK_BOX (hb), fontsel, TRUE, TRUE, 0);
g_object_set_data (G_OBJECT (dlg), "fontsel", fontsel);
// Layout
{
GtkWidget *f = gtk_frame_new (_("Layout"));
gtk_box_pack_start (GTK_BOX (hb), f, FALSE, FALSE, 4);
GtkWidget *l_vb = gtk_vbox_new (FALSE, VB_MARGIN);
gtk_container_add (GTK_CONTAINER (f), l_vb);
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
GtkWidget *group;
// align left
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_LEFT, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = group = gtk_radio_button_new (NULL);
gtk_tooltips_set_tip (tt, b, _("Align lines left"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg);
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE );
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_start", b);
}
// align center
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_CENTER, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
/* TRANSLATORS: `Center' here is a verb. */
gtk_tooltips_set_tip (tt, b, _("Center lines"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_middle", b);
}
// align right
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_RIGHT, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
gtk_tooltips_set_tip (tt, b, _("Align lines right"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_end", b);
}
// align justify
{
// TODO - replace with Inkscape-specific call
GtkWidget *px = gtk_image_new_from_stock ( GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_LARGE_TOOLBAR );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
gtk_tooltips_set_tip (tt, b, _("Justify lines"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "text_anchor_justify", b);
}
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
}
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
GtkWidget *group;
// horizontal
{
GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
INKSCAPE_STOCK_WRITING_MODE_LR );
GtkWidget *b = group = gtk_radio_button_new (NULL);
gtk_tooltips_set_tip (tt, b, _("Horizontal text"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_LR, b);
}
// vertical
{
GtkWidget *px = sp_icon_new( Inkscape::ICON_SIZE_LARGE_TOOLBAR,
INKSCAPE_STOCK_WRITING_MODE_TB );
GtkWidget *b = gtk_radio_button_new (gtk_radio_button_group (GTK_RADIO_BUTTON (group)));
gtk_tooltips_set_tip (tt, b, _("Vertical text"), NULL);
gtk_button_set_relief (GTK_BUTTON (b), GTK_RELIEF_NONE);
g_signal_connect ( G_OBJECT (b), "toggled", G_CALLBACK (sp_text_edit_dialog_any_toggled), dlg );
gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (b), FALSE);
gtk_container_add (GTK_CONTAINER (b), px);
gtk_box_pack_start (GTK_BOX (row), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), INKSCAPE_STOCK_WRITING_MODE_TB, b);
}
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
}
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
l = gtk_label_new (_("Line spacing:"));
gtk_misc_set_alignment (GTK_MISC (l), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (row), l, FALSE, FALSE, VB_MARGIN);
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, 0);
}
{
GtkWidget *row = gtk_hbox_new (FALSE, VB_MARGIN);
GtkWidget *c = gtk_combo_new ();
gtk_combo_set_value_in_list ((GtkCombo *) c, FALSE, FALSE);
gtk_combo_set_use_arrows ((GtkCombo *) c, TRUE);
gtk_combo_set_use_arrows_always ((GtkCombo *) c, TRUE);
gtk_widget_set_size_request (c, 90, -1);
{ /* Setup strings */
GList *sl = NULL;
for (int i = 0; spacings[i]; i++) {
sl = g_list_prepend (sl, (void *) spacings[i]);
}
sl = g_list_reverse (sl);
gtk_combo_set_popdown_strings ((GtkCombo *) c, sl);
g_list_free (sl);
}
g_signal_connect ( (GObject *) ((GtkCombo *) c)->entry,
"changed",
(GCallback) sp_text_edit_dialog_line_spacing_changed,
dlg );
gtk_box_pack_start (GTK_BOX (row), c, FALSE, FALSE, VB_MARGIN);
g_object_set_data (G_OBJECT (dlg), "line_spacing", c);
gtk_box_pack_start (GTK_BOX (l_vb), row, FALSE, FALSE, VB_MARGIN);
}
}
/* Font preview */
GtkWidget *preview = sp_font_preview_new ();
gtk_box_pack_start (GTK_BOX (vb), preview, TRUE, TRUE, 4);
g_object_set_data (G_OBJECT (dlg), "preview", preview);
}
// Text tab
{
GtkWidget *l = gtk_label_new (_("Text"));
GtkWidget *vb = gtk_vbox_new (FALSE, VB_MARGIN);
gtk_container_set_border_width (GTK_CONTAINER (vb), VB_MARGIN);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), vb, l);
GtkWidget *scroller = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (scroller),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC );
gtk_scrolled_window_set_shadow_type ( GTK_SCROLLED_WINDOW(scroller), GTK_SHADOW_IN );
gtk_widget_show (scroller);
GtkTextBuffer *tb = gtk_text_buffer_new (NULL);
GtkWidget *txt = gtk_text_view_new_with_buffer (tb);
gtk_text_view_set_wrap_mode ((GtkTextView *) txt, GTK_WRAP_WORD);
#ifdef WITH_GTKSPELL
GError *error = NULL;
char *errortext = NULL;
/* todo: Use computed xml:lang attribute of relevant element, if present, to specify the
language (either as 2nd arg of gtkspell_new_attach, or with explicit
gtkspell_set_language call in; see advanced.c example in gtkspell docs).
sp_text_edit_dialog_read_selection looks like a suitable place. */
if (gtkspell_new_attach(GTK_TEXT_VIEW(txt), NULL, &error) == NULL) {
g_print("gtkspell error: %s\n", error->message);
errortext = g_strdup_printf("GtkSpell was unable to initialize.\n"
"%s", error->message);
g_error_free(error);
}
#endif
gtk_widget_set_size_request (txt, -1, 64);
gtk_text_view_set_editable (GTK_TEXT_VIEW (txt), TRUE);
gtk_container_add (GTK_CONTAINER (scroller), txt);
gtk_box_pack_start (GTK_BOX (vb), scroller, TRUE, TRUE, 0);
g_signal_connect ( G_OBJECT (tb), "changed",
G_CALLBACK (sp_text_edit_dialog_text_changed), dlg );
g_signal_connect (G_OBJECT (txt), "focus-in-event", G_CALLBACK (text_view_focus_in), dlg);
g_signal_connect (G_OBJECT (txt), "focus-out-event", G_CALLBACK (text_view_focus_out), dlg);
g_object_set_data (G_OBJECT (dlg), "text", tb);
g_object_set_data (G_OBJECT (dlg), "textw", txt);
}
/* Buttons */
GtkWidget *hb = gtk_hbox_new (FALSE, VB_MARGIN);
gtk_container_set_border_width (GTK_CONTAINER (hb), 4);
gtk_box_pack_start (GTK_BOX (mainvb), hb, FALSE, FALSE, 0);
{
GtkWidget *b = gtk_button_new_with_label (_("Set as default"));
g_signal_connect ( G_OBJECT (b), "clicked",
G_CALLBACK (sp_text_edit_dialog_set_default),
dlg );
gtk_box_pack_start (GTK_BOX (hb), b, FALSE, FALSE, 0);
g_object_set_data (G_OBJECT (dlg), "default", b);
}
{
GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect ( G_OBJECT (b), "clicked",
G_CALLBACK (sp_text_edit_dialog_close), dlg );
gtk_box_pack_end (GTK_BOX (hb), b, FALSE, FALSE, 0);
}
{
GtkWidget *b = gtk_button_new_from_stock (GTK_STOCK_APPLY);
GTK_WIDGET_SET_FLAGS (b, GTK_CAN_DEFAULT | GTK_HAS_DEFAULT);
g_signal_connect ( G_OBJECT (b), "clicked",
G_CALLBACK (sp_text_edit_dialog_apply), dlg );
gtk_box_pack_end ( GTK_BOX (hb), b, FALSE, FALSE, 0 );
g_object_set_data (G_OBJECT (dlg), "apply", b);
}
g_signal_connect ( G_OBJECT (INKSCAPE), "modify_selection",
G_CALLBACK (sp_text_edit_dialog_selection_modified), dlg);
g_signal_connect ( G_OBJECT (INKSCAPE), "change_selection",
G_CALLBACK (sp_text_edit_dialog_selection_changed), dlg);
g_signal_connect (INKSCAPE, "change_subselection", G_CALLBACK (sp_text_edit_dialog_subselection_changed), dlg);
gtk_widget_show_all (dlg);
sp_text_edit_dialog_read_selection (dlg, TRUE, TRUE);
}
gtk_window_present ((GtkWindow *) dlg);
} // end of sp_text_edit_dialog()
void pidgin_log_show_contact(PurpleContact *contact) {
struct log_viewer_hash_t *ht;
PurpleBlistNode *child;
PidginLogViewer *lv = NULL;
GList *logs = NULL;
GdkPixbuf *pixbuf;
GtkWidget *image;
const char *name = NULL;
char *title;
int total_log_size = 0;
g_return_if_fail(contact != NULL);
ht = g_new0(struct log_viewer_hash_t, 1);
ht->type = PURPLE_LOG_IM;
ht->contact = contact;
if (log_viewers == NULL) {
log_viewers = g_hash_table_new(log_viewer_hash, log_viewer_equal);
} else if ((lv = g_hash_table_lookup(log_viewers, ht))) {
gtk_window_present(GTK_WINDOW(lv->window));
g_free(ht);
return;
}
for (child = purple_blist_node_get_first_child((PurpleBlistNode*)contact) ;
child != NULL ;
child = purple_blist_node_get_sibling_next(child)) {
const char *buddy_name;
PurpleAccount *account;
if (!PURPLE_BLIST_NODE_IS_BUDDY(child))
continue;
buddy_name = purple_buddy_get_name((PurpleBuddy *)child);
account = purple_buddy_get_account((PurpleBuddy *)child);
logs = g_list_concat(purple_log_get_logs(PURPLE_LOG_IM, buddy_name, account), logs);
total_log_size += purple_log_get_total_size(PURPLE_LOG_IM, buddy_name, account);
}
logs = g_list_sort(logs, purple_log_compare);
image = gtk_image_new();
pixbuf = gtk_widget_render_icon(image, PIDGIN_STOCK_STATUS_PERSON,
gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_SMALL), "GtkWindow");
if (pixbuf) {
gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf);
g_object_unref(pixbuf);
} else {
gtk_widget_destroy(image);
image = NULL;
}
if (contact->alias != NULL)
name = contact->alias;
else if (contact->priority != NULL)
name = purple_buddy_get_contact_alias(contact->priority);
/* This will happen if the contact doesn't have an alias,
* and none of the contact's buddies are online.
* There is probably a better way to deal with this. */
if (name == NULL) {
if (contact->node.child != NULL && PURPLE_BLIST_NODE_IS_BUDDY(contact->node.child))
name = purple_buddy_get_contact_alias((PurpleBuddy *) contact->node.child);
if (name == NULL)
name = "";
}
title = g_strdup_printf(_("Conversations with %s"), name);
display_log_viewer(ht, logs, title, image, total_log_size);
g_free(title);
}
/* Main Window Initialization */
void init_main_window(const gchar * glade_file)
{
GladeXML *xml;
GtkWidget *widget;
GtkTextBuffer *txtbuf;
GtkStyle *style;
xml = glade_xml_new(glade_file, "window1", NULL);
if (!xml)
g_error(_("GUI loading failed !\n"));
glade_xml_signal_autoconnect(xml);
main_wnd = glade_xml_get_widget(xml, "window1");
hpaned = glade_xml_get_widget(xml, "hpaned1");
vpaned = glade_xml_get_widget(xml, "vpaned1");
tree1_w = glade_xml_get_widget(xml, "treeview1");
tree2_w = glade_xml_get_widget(xml, "treeview2");
text_w = glade_xml_get_widget(xml, "textview3");
back_btn = glade_xml_get_widget(xml, "button1");
gtk_widget_set_sensitive(back_btn, FALSE);
widget = glade_xml_get_widget(xml, "show_name1");
gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
show_name);
widget = glade_xml_get_widget(xml, "show_range1");
gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
show_range);
widget = glade_xml_get_widget(xml, "show_data1");
gtk_check_menu_item_set_active((GtkCheckMenuItem *) widget,
show_value);
save_btn = glade_xml_get_widget(xml, "button3");
save_menu_item = glade_xml_get_widget(xml, "save1");
conf_set_changed_callback(conf_changed);
style = gtk_widget_get_style(main_wnd);
widget = glade_xml_get_widget(xml, "toolbar1");
replace_button_icon(xml, main_wnd->window, style,
"button4", (gchar **) xpm_single_view);
replace_button_icon(xml, main_wnd->window, style,
"button5", (gchar **) xpm_split_view);
replace_button_icon(xml, main_wnd->window, style,
"button6", (gchar **) xpm_tree_view);
txtbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text_w));
tag1 = gtk_text_buffer_create_tag(txtbuf, "mytag1",
"foreground", "red",
"weight", PANGO_WEIGHT_BOLD,
NULL);
tag2 = gtk_text_buffer_create_tag(txtbuf, "mytag2",
/*"style", PANGO_STYLE_OBLIQUE, */
NULL);
gtk_window_set_title(GTK_WINDOW(main_wnd), rootmenu.prompt->text);
gtk_widget_show(main_wnd);
}
int main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *button;
GtkWidget *grid;
GtkWidget *entry;
GtkWidget *menu_widget;
GtkAccelGroup *accel_group;
guint i;
GMenu *menu;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_resize (GTK_WINDOW (window), 400, 300);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), grid);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
/* Button next to entry */
entry = gtk_entry_new ();
gtk_grid_attach (GTK_GRID (grid),
entry,
0, 0,
1, 1);
button = gtk_menu_button_new ();
gtk_grid_attach (GTK_GRID (grid),
button,
1, 0,
1, 1);
/* Button with GtkMenu */
menu_widget = gtk_menu_new ();
for (i = 5; i > 0; i--) {
GtkWidget *item;
if (i == 3) {
item = gtk_menu_item_new_with_mnemonic ("_Copy");
} else {
char *label;
label = g_strdup_printf ("Item _%d", i);
item = gtk_menu_item_new_with_mnemonic (label);
g_free (label);
}
gtk_menu_item_set_use_underline (GTK_MENU_ITEM (item), TRUE);
gtk_menu_attach (GTK_MENU (menu_widget),
item,
0, 1,
i - 1, i);
}
gtk_widget_show_all (menu_widget);
button = gtk_menu_button_new ();
gtk_menu_button_set_popup (GTK_MENU_BUTTON (button), menu_widget);
gtk_grid_attach (GTK_GRID (grid),
button,
1, 1,
1, 1);
gtk_widget_show (create_prop_editor (G_OBJECT (button), 0));
/* Button with GMenuModel */
menu = g_menu_new ();
for (i = 5; i > 0; i--) {
char *label;
label = g_strdup_printf ("Item _%d", i);
g_menu_insert (menu, i - 1, label, NULL);
g_free (label);
}
button = gtk_menu_button_new ();
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), G_MENU_MODEL (menu));
gtk_grid_attach (GTK_GRID (grid),
button,
1, 2,
1, 1);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
int l_uosgrnu(int metka_rr, //0-ввод и корек. 1-выбор
iceb_u_str *kod,iceb_u_str *naim,GtkWidget *wpredok)
{
l_uosgrnu_data data;
char bros[512];
GdkColor color;
data.poisk.clear_data();
data.metka_rr=metka_rr;
data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
sprintf(bros,"%s %s",name_system,gettext("Список групп налогового учёта"));
gtk_window_set_title (GTK_WINDOW (data.window),bros);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(l_uosgrnu_key_press),&data);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_release_event",GTK_SIGNAL_FUNC(iceb_key_release),&data.kl_shift);
GtkWidget *hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (data.window), hbox);
GtkWidget *vbox1 = gtk_vbox_new (FALSE, 1);
GtkWidget *vbox2 = gtk_vbox_new (FALSE, 1);
gtk_box_pack_start (GTK_BOX (hbox), vbox1, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
gtk_widget_show(hbox);
data.label_kolstr=gtk_label_new(gettext("Список групп налогового учёта"));
gtk_box_pack_start (GTK_BOX (vbox2),data.label_kolstr,FALSE, FALSE, 0);
gtk_widget_show(vbox1);
gtk_widget_show(vbox2);
data.label_poisk=gtk_label_new ("");
gdk_color_parse("red",&color);
gtk_widget_modify_fg(data.label_poisk,GTK_STATE_NORMAL,&color);
gtk_box_pack_start (GTK_BOX (vbox2),data.label_poisk,FALSE, FALSE, 0);
data.sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_usize(GTK_WIDGET(data.sw),400,300);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (data.sw),GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (data.sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_box_pack_end (GTK_BOX (vbox2), data.sw, TRUE, TRUE, 0);
//Кнопки
GtkTooltips *tooltips[KOL_F_KL];
sprintf(bros,"F2 %s",gettext("Запись"));
data.knopka[FK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK2], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]), "clicked",GTK_SIGNAL_FUNC(l_uosgrnu_knopka),&data);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Ввод новой записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_widget_show(data.knopka[FK2]);
sprintf(bros,"%sF2 %s",RFK,gettext("Корректировать"));
data.knopka[SFK2]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK2],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK2]), "clicked",GTK_SIGNAL_FUNC(l_uosgrnu_knopka),&data);
tooltips[SFK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK2],data.knopka[SFK2],gettext("Корректировка выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK2]),(gpointer)SFK2);
gtk_widget_show(data.knopka[SFK2]);
sprintf(bros,"F3 %s",gettext("Удалить"));
data.knopka[FK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK3]), "clicked",GTK_SIGNAL_FUNC(l_uosgrnu_knopka),&data);
tooltips[FK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK3],data.knopka[FK3],gettext("Удаление выбранной записи"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK3]),(gpointer)FK3);
gtk_widget_show(data.knopka[FK3]);
sprintf(bros,"%sF3 %s",RFK,gettext("Удалить"));
data.knopka[SFK3]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[SFK3],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[SFK3]), "clicked",GTK_SIGNAL_FUNC(l_uosgrnu_knopka),&data);
tooltips[SFK3]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[SFK3],data.knopka[SFK3],gettext("Удалить неиспользуемые коды"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[SFK3]),(gpointer)SFK3);
gtk_widget_show(data.knopka[SFK3]);
sprintf(bros,"F4 %s",gettext("Поиск"));
data.knopka[FK4]=gtk_button_new_with_label(bros);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]), "clicked",GTK_SIGNAL_FUNC(l_uosgrnu_knopka),&data);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK4],TRUE,TRUE, 0);
tooltips[FK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Поиск нужных записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
gtk_widget_show(data.knopka[FK4]);
sprintf(bros,"F5 %s",gettext("Печать"));
data.knopka[FK5]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1), data.knopka[FK5],TRUE,TRUE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK5]), "clicked",GTK_SIGNAL_FUNC(l_uosgrnu_knopka),&data);
tooltips[FK5]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK5],data.knopka[FK5],gettext("Распечатка записей"),NULL);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK5]),(gpointer)FK5);
gtk_widget_show(data.knopka[FK5]);
sprintf(bros,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(bros);
gtk_box_pack_start(GTK_BOX(vbox1),data.knopka[FK10],TRUE,TRUE, 0);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]), "clicked",GTK_SIGNAL_FUNC(l_uosgrnu_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_widget_show(data.knopka[FK10]);
gtk_widget_realize(data.window);
gdk_window_set_cursor(data.window->window,gdk_cursor_new(ICEB_CURSOR));
gtk_widget_grab_focus(data.knopka[FK10]);
l_uosgrnu_create_list(&data);
gtk_widget_show(data.window);
if(metka_rr == 0)
gtk_window_maximize(GTK_WINDOW(data.window));
gtk_main();
if(data.metka_voz == 0)
{
kod->new_plus(data.kodv.ravno());
naim->new_plus(data.naimv.ravno());
}
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.metka_voz);
}
static gboolean
gui_message_error_dialog (Gimp *gimp,
GObject *handler,
GimpMessageSeverity severity,
const gchar *domain,
const gchar *message)
{
GtkWidget *dialog;
if (GIMP_IS_PROGRESS (handler))
{
/* If there's already an error dialog associated with this
* progress, then continue without trying gimp_progress_message().
*/
if (! g_object_get_data (handler, "gimp-error-dialog") &&
gimp_progress_message (GIMP_PROGRESS (handler), gimp,
severity, domain, message))
{
return TRUE;
}
}
else if (GTK_IS_WIDGET (handler))
{
GtkWidget *parent = GTK_WIDGET (handler);
GtkMessageType type = GTK_MESSAGE_ERROR;
switch (severity)
{
case GIMP_MESSAGE_INFO:
type = GTK_MESSAGE_INFO;
break;
case GIMP_MESSAGE_WARNING:
type = GTK_MESSAGE_WARNING;
break;
case GIMP_MESSAGE_ERROR:
type = GTK_MESSAGE_ERROR;
break;
}
dialog =
gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (parent)),
GTK_DIALOG_DESTROY_WITH_PARENT,
type, GTK_BUTTONS_OK,
"%s", message);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy),
NULL);
gtk_widget_show (dialog);
return TRUE;
}
if (GIMP_IS_PROGRESS (handler) && ! GIMP_IS_PROGRESS_DIALOG (handler))
dialog = progress_error_dialog (GIMP_PROGRESS (handler));
else
dialog = global_error_dialog ();
if (dialog)
{
gimp_error_dialog_add (GIMP_ERROR_DIALOG (dialog),
gimp_get_message_icon_name (severity),
domain, message);
gtk_window_present (GTK_WINDOW (dialog));
return TRUE;
}
return FALSE;
}
static void
gpk_log_startup_cb (GtkApplication *application, gpointer user_data)
{
g_autoptr(GError) error = NULL;
GtkTreeSelection *selection;
GtkWidget *widget;
GtkWindow *window;
guint retval;
client = pk_client_new ();
g_object_set (client,
"background", FALSE,
NULL);
/* get UI */
builder = gtk_builder_new ();
retval = gtk_builder_add_from_resource (builder,
"/org/gnome/packagekit/gpk-log.ui",
&error);
if (retval == 0) {
g_warning ("failed to load ui: %s", error->message);
goto out;
}
window = GTK_WINDOW (gtk_builder_get_object (builder, "dialog_simple"));
gtk_window_set_icon_name (window, GPK_ICON_SOFTWARE_LOG);
gtk_window_set_application (window, application);
/* set a size, as the screen allows */
gpk_window_set_size_request (window, 1200, 1200);
/* if command line arguments are set, then setup UI */
if (filter != NULL) {
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
gtk_entry_set_text (GTK_ENTRY(widget), filter);
}
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_refresh"));
g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_refresh_cb), NULL);
gtk_widget_hide (widget);
widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_filter"));
g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_filter_cb), NULL);
/* hit enter in the search box for filter */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package"));
g_signal_connect (widget, "activate", G_CALLBACK (gpk_log_button_filter_cb), NULL);
/* autocompletion can be turned off as it's slow */
g_signal_connect (widget, "key-release-event", G_CALLBACK (gpk_log_entry_filter_cb), NULL);
/* create list stores */
list_store = gtk_list_store_new (GPK_LOG_COLUMN_LAST, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
/* create transaction_id tree view */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "treeview_simple"));
gtk_tree_view_set_model (GTK_TREE_VIEW (widget),
GTK_TREE_MODEL (list_store));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
g_signal_connect (selection, "changed",
G_CALLBACK (gpk_log_treeview_clicked_cb), NULL);
/* add columns to the tree view */
pk_treeview_add_general_columns (GTK_TREE_VIEW (widget));
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (widget));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store),
GPK_LOG_COLUMN_TIMESPEC, GTK_SORT_DESCENDING);
/* show */
widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_simple"));
gtk_widget_show (widget);
/* set the parent window if it is specified */
if (xid != 0) {
g_debug ("Setting xid %i", xid);
gpk_window_set_parent_xid (GTK_WINDOW (widget), xid);
}
/* get the update list */
gpk_log_refresh ();
out:
g_object_unref (list_store);
g_object_unref (client);
g_free (transaction_id);
g_free (filter);
if (transactions != NULL)
g_ptr_array_unref (transactions);
}
int iceb_l_subbal_v(class iceb_u_str *kod_gr,GtkWidget *wpredok)
{
class iceb_l_subbal_v_data data;
char strsql[512];
iceb_u_str kikz;
data.kod_gr.new_plus(kod_gr->ravno());
data.rk.clear_data();
if(data.kod_gr.getdlinna() > 1)
{
data.rk.kod.new_plus(data.kod_gr.ravno());
sprintf(strsql,"select * from Glksubbal where kod='%s'",data.kod_gr.ravno());
SQL_str row;
SQLCURSOR cur;
if(iceb_sql_readkey(strsql,&row,&cur,wpredok) < 1)
{
iceb_menu_soob(gettext("Не найдена запись для корректировки !"),wpredok);
return(1);
}
data.rk.naim.new_plus(row[1]);
kikz.plus(iceb_kikz(row[2],row[3],wpredok));
}
else
{
sprintf(strsql,"%d",iceb_get_new_kod("Glksubbal",0,wpredok));
data.rk.kod.new_plus(strsql);
}
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
GtkWidget *label=NULL;
if(data.kod_gr.getdlinna() <= 1)
{
sprintf(strsql,"%s %s",name_system,gettext("Ввод новой записи"));
label=gtk_label_new(gettext("Ввод новой записи"));
}
else
{
sprintf(strsql,"%s %s",name_system,gettext("Корректировка записи"));
iceb_u_str repl;
repl.plus(gettext("Корректировка записи"));
repl.ps_plus(kikz.ravno());
label=gtk_label_new(repl.ravno_toutf());
}
gtk_window_set_title(GTK_WINDOW(data.window),strsql);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(iceb_l_subbal_v_key_press),&data);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
GtkWidget *hbox[KOLENTER];
for(int i=0; i < KOLENTER; i++)
hbox[i] = gtk_hbox_new (FALSE, 0);
GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (data.window), vbox);
gtk_container_add (GTK_CONTAINER (vbox), label);
for(int i=0; i < KOLENTER; i++)
gtk_container_add (GTK_CONTAINER (vbox), hbox[i]);
gtk_container_add (GTK_CONTAINER (vbox), hboxknop);
label=gtk_label_new(gettext("Код"));
gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), label, FALSE, FALSE, 0);
data.entry[E_KOD] = gtk_entry_new_with_max_length (4);
gtk_box_pack_start (GTK_BOX (hbox[E_KOD]), data.entry[E_KOD], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD]), "activate",GTK_SIGNAL_FUNC(iceb_l_subbal_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD]),data.rk.kod.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD]),(gpointer)E_KOD);
label=gtk_label_new(gettext("Наименование"));
gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), label, FALSE, FALSE, 0);
data.entry[E_NAIM] = gtk_entry_new_with_max_length (100);
gtk_box_pack_start (GTK_BOX (hbox[E_NAIM]), data.entry[E_NAIM], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_NAIM]), "activate",GTK_SIGNAL_FUNC(iceb_l_subbal_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_NAIM]),data.rk.naim.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_NAIM]),(gpointer)E_NAIM);
GtkTooltips *tooltips[KOL_FK];
sprintf(strsql,"F2 %s",gettext("Запись"));
data.knopka[FK2]=gtk_button_new_with_label(strsql);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Запись введеной в меню информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(iceb_l_subbal_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(strsql);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы с меню без записи введенной информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(iceb_l_subbal_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0);
gtk_widget_grab_focus(data.entry[0]);
gtk_widget_show_all (data.window);
gtk_main();
if(data.voz == 0)
kod_gr->new_plus(data.rk.kod.ravno());
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.voz);
}
/*!
* \brief Create a dialog window containing a pre-defined pixbuf (from
* file).
*
* The \c footprint_name variable is used in the dialog title.
*
* \return 0 when successful.
*/
int
dimensions_create_window
(
gchar *image_filename,
/*!< : is the filename of the image to draw in the
* window.*/
gchar *footprint_type
/*!< : is the footprint type.*/
)
{
/* Create a dimensions window */
GtkWidget *dimensions_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* Destroy the dimensions window when the main window of pcb-gfpw gets
* destroyed */
gtk_window_set_destroy_with_parent (GTK_WINDOW (dimensions_window),
TRUE);
/* Set the preview window title */
gchar *dimensions_window_title = g_strdup_printf (_("dimensions of %s"),
footprint_type);
gtk_window_set_title (GTK_WINDOW (dimensions_window),
dimensions_window_title);
g_free (dimensions_window_title);
gtk_container_set_border_width (GTK_CONTAINER (dimensions_window), 10);
/* Set the delete signal for the window */
g_signal_connect
(
GTK_OBJECT (dimensions_window),
"delete_event",
(GtkSignalFunc) dimensions_window_delete_event,
NULL
);
/* Create a vertical box */
GtkWidget *vbox = gtk_vbox_new (FALSE, 10);
gtk_container_add (GTK_CONTAINER (dimensions_window), vbox);
/* Load a pre-cooked dimensions image for the footprint type
* and set the name accordingly */
GdkPixbuf *dimensions_image = gdk_pixbuf_new_from_file (image_filename, NULL);
GtkWidget *drawing_area = gtk_drawing_area_new ();
gtk_widget_set_app_paintable (drawing_area, TRUE);
/* Set the expose signal for the window */
g_signal_connect
(
GTK_OBJECT (drawing_area),
"expose-event",
(GtkSignalFunc) dimensions_window_expose_event,
dimensions_image
);
/* Get size of drawing_area and resize */
gint width = gdk_pixbuf_get_width (dimensions_image);
gint height = gdk_pixbuf_get_height (dimensions_image);
gtk_widget_set_size_request (GTK_WIDGET (drawing_area), width, height);
gtk_container_add (GTK_CONTAINER (vbox), drawing_area);
/* Create a horizontal button box */
GtkWidget *hbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END);
/* Create a close button */
GtkWidget *button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect
(
G_OBJECT (button),
"clicked",
G_CALLBACK (dimensions_window_close_cb),
dimensions_window
);
/* Pack the button into the hbox */
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
/* Pack the hbox into the vbox */
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* Show the window */
gtk_window_set_resizable (GTK_WINDOW (dimensions_window), FALSE);
gtk_widget_realize (dimensions_window);
gtk_widget_show_all (dimensions_window);
/* Enter the GTK main loop */
gtk_main ();
return 0;
}
static void
logview_filter_manager_init (LogviewFilterManager *manager)
{
GtkWidget *table;
GtkWidget *scrolled_window;
GtkTreeViewColumn *column;
GtkCellRenderer *text_renderer;
LogviewFilterManagerPrivate *priv;
manager->priv = LOGVIEW_FILTER_MANAGER_GET_PRIVATE (manager);
priv = manager->priv;
priv->builder = gtk_builder_new ();
g_object_ref (priv->builder);
priv->prefs = logview_prefs_get ();
gtk_dialog_add_button (GTK_DIALOG(manager),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE);
gtk_window_set_modal (GTK_WINDOW (manager),
TRUE);
priv->model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_OBJECT));
logview_filter_manager_update_model (manager);
table = gtk_table_new (3, 2, FALSE);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_ETCHED_IN);
priv->tree = gtk_tree_view_new_with_model (priv->model);
gtk_widget_set_size_request (priv->tree, 150, 200);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree), FALSE);
gtk_container_add (GTK_CONTAINER (scrolled_window), priv->tree);
text_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start (column, text_renderer, TRUE);
gtk_tree_view_column_set_attributes (column,
text_renderer,
"text", COLUMN_NAME,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree),
column);
priv->add_button = gtk_button_new_from_stock (GTK_STOCK_ADD);
priv->edit_button = gtk_button_new_from_stock (GTK_STOCK_PROPERTIES);
priv->remove_button = gtk_button_new_from_stock (GTK_STOCK_REMOVE);
gtk_window_set_title (GTK_WINDOW (manager),
_("Filters"));
g_signal_connect (priv->add_button, "clicked",
G_CALLBACK (on_add_clicked), manager);
g_signal_connect (priv->edit_button, "clicked",
G_CALLBACK (on_edit_clicked), manager);
g_signal_connect (priv->remove_button, "clicked",
G_CALLBACK (on_remove_clicked), manager);
gtk_widget_set_sensitive (priv->edit_button, FALSE);
gtk_widget_set_sensitive (priv->remove_button, FALSE);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree)),
"changed", G_CALLBACK (on_tree_selection_changed),
manager);
gtk_table_attach_defaults (GTK_TABLE (table),
scrolled_window,
0, 1, 0, 3);
gtk_table_attach (GTK_TABLE (table),
priv->add_button,
1, 2, 0, 1, GTK_FILL, 0, 5, 5);
gtk_table_attach (GTK_TABLE (table),
priv->edit_button,
1, 2, 1, 2, GTK_FILL, 0, 5, 5);
gtk_table_attach (GTK_TABLE (table),
priv->remove_button,
1, 2, 2, 3, GTK_FILL, 0, 5, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (manager))),
table, TRUE, TRUE, 5);
gtk_widget_show_all (GTK_WIDGET (manager));
}
static void
run_add_edit_dialog (LogviewFilterManager *manager, LogviewFilter *filter)
{
int response;
GError *error;
gchar *name, *regex;
const gchar *title;
GtkWidget *dialog, *entry_name, *entry_regex, *radio_color;
GtkWidget *radio_visible, *check_foreground, *check_background;
GtkWidget *color_foreground, *color_background, *vbox_color;
gboolean foreground_set, background_set, invisible;
GtkTextTag *tag;
GtkBuilder* builder;
builder = manager->priv->builder;
error = NULL;
name = NULL;
gtk_builder_add_from_file (builder, UI_FILE, &error);
if (error) {
g_warning ("Could not load filter ui: %s", error->message);
g_error_free (error);
return;
}
title = (filter != NULL ? _("Edit filter") : _("Add new filter"));
dialog = GTK_WIDGET (gtk_builder_get_object (builder,
"dialog_filter"));
entry_name = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_name"));
entry_regex = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_regex"));
radio_color = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_color"));
radio_visible = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_visible"));
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radio_color),
gtk_radio_button_get_group (GTK_RADIO_BUTTON (radio_visible)));
check_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"check_foreground"));
check_background = GTK_WIDGET (gtk_builder_get_object (builder,
"check_background"));
color_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"color_foreground"));
color_background = GTK_WIDGET (gtk_builder_get_object (builder,
"color_background"));
g_signal_connect (check_foreground, "toggled", G_CALLBACK (on_check_toggled),
color_foreground);
g_signal_connect (check_background, "toggled", G_CALLBACK (on_check_toggled),
color_background);
on_check_toggled (GTK_TOGGLE_BUTTON (check_foreground),
color_foreground);
on_check_toggled (GTK_TOGGLE_BUTTON (check_background),
color_background);
vbox_color = GTK_WIDGET (gtk_builder_get_object (builder, "vbox_color"));
g_signal_connect (radio_color, "toggled", G_CALLBACK (on_check_toggled),
vbox_color);
on_check_toggled (GTK_TOGGLE_BUTTON (radio_color),
vbox_color);
if (filter) {
g_object_get (filter,
"name", &name,
"regex", ®ex,
"texttag", &tag,
NULL);
g_object_get (tag,
"foreground-set", &foreground_set,
"paragraph-background-set", &background_set,
"invisible", &invisible, NULL);
gtk_entry_set_text (GTK_ENTRY(entry_name), name);
gtk_entry_set_text (GTK_ENTRY(entry_regex), regex);
if (foreground_set) {
GdkColor *foreground;
g_object_get (tag, "foreground-gdk", &foreground, NULL);
gtk_color_button_set_color (GTK_COLOR_BUTTON (color_foreground),
foreground);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_foreground),
TRUE);
gdk_color_free (foreground);
}
if (background_set) {
GdkColor *background;
g_object_get (tag, "paragraph-background-gdk", &background, NULL);
gtk_color_button_set_color (GTK_COLOR_BUTTON (color_background),
background);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_background),
TRUE);
gdk_color_free (background);
}
if (background_set || foreground_set) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_color), TRUE);
} else if (invisible) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radio_visible), TRUE);
}
g_free (regex);
g_object_unref (tag);
}
g_object_set_data_full (G_OBJECT (manager), "old_name", name, g_free);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (on_dialog_add_edit_reponse), manager);
gtk_window_set_transient_for (GTK_WINDOW (dialog),
GTK_WINDOW (manager));
gtk_window_set_modal (GTK_WINDOW (dialog),
TRUE);
gtk_widget_show (GTK_WIDGET (dialog));
}
static void
on_dialog_add_edit_reponse (GtkWidget *dialog, int response_id,
LogviewFilterManager *manager)
{
GtkWidget *entry_name, *entry_regex;
GtkWidget *radio_color, *radio_visible;
GtkWidget *check_foreground, *check_background;
GtkWidget *color_foreground, *color_background;
gchar *old_name;
const gchar *name;
const gchar *regex;
LogviewFilter *filter;
GtkTextTag *tag;
GtkBuilder *builder;
old_name = g_object_get_data (G_OBJECT (manager), "old_name");
builder = manager->priv->builder;
entry_name = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_name"));
entry_regex = GTK_WIDGET (gtk_builder_get_object (builder,
"entry_regex"));
radio_color = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_color"));
radio_visible = GTK_WIDGET (gtk_builder_get_object (builder,
"radio_visible"));
check_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"check_foreground"));
check_background = GTK_WIDGET (gtk_builder_get_object (builder,
"check_background"));
color_foreground = GTK_WIDGET (gtk_builder_get_object (builder,
"color_foreground"));
color_background = GTK_WIDGET (gtk_builder_get_object (builder,
"color_background"));
if (response_id == GTK_RESPONSE_APPLY) {
name = gtk_entry_get_text (GTK_ENTRY (entry_name));
regex = gtk_entry_get_text (GTK_ENTRY (entry_regex));
if (!check_name (manager, name) || !check_regex (manager, regex)) {
return;
}
filter = logview_filter_new (name, regex);
tag = gtk_text_tag_new (name);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radio_color))) {
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_foreground))) {
GdkColor foreground_color;
gtk_color_button_get_color (GTK_COLOR_BUTTON (color_foreground),
&foreground_color);
g_object_set (G_OBJECT (tag),
"foreground-gdk", &foreground_color,
"foreground-set", TRUE, NULL);
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_background))) {
GdkColor background_color;
gtk_color_button_get_color (GTK_COLOR_BUTTON (color_background),
&background_color);
g_object_set (tag,
"paragraph-background-gdk", &background_color,
"paragraph-background-set", TRUE, NULL);
}
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_foreground))
&& !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check_background))) {
GtkWidget *error_dialog;
error_dialog = gtk_message_dialog_new (GTK_WINDOW (manager),
GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
"%s",
_("Please specify either foreground or background color!"));
gtk_dialog_run (GTK_DIALOG (error_dialog));
gtk_widget_destroy (error_dialog);
g_object_unref (tag);
g_object_unref (filter);
return;
}
} else { /* !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (radio_color)) */
g_object_set (tag, "invisible", TRUE, NULL);
}
if (old_name && !g_str_equal (old_name, name)) {
logview_prefs_remove_filter (manager->priv->prefs, old_name);
}
g_object_set (G_OBJECT (filter), "texttag", tag, NULL);
g_object_unref (tag);
logview_prefs_add_filter (manager->priv->prefs, filter);
g_object_unref (filter);
logview_filter_manager_update_model (manager);
}
gtk_widget_destroy (dialog);
}
int main (int argc, char *argv[])
{
/*init critical variables*/
bServerOnline = false;
bConsoleActive = false;
/*init resources*/
GtkWidget *window;
/*init threads*/
g_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
add_console_msg("[Lucky",motd, "SoftServer Build "+convert_to_str(BUILD_NUM)+"\nhttp://www.softserver.org\n\nAre you still using the trial version?\nDevelop an app using SoftServer and submit it to earn a license!");
add_console_msg("[Main]",notification,"Initializing GTK+ v2.0");
/*init GTK*/
gtk_init(&argc, &argv);
/*Window setup*/
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (window), std::string("SoftServer Build "+convert_to_str(BUILD_NUM)).c_str());
gtk_window_set_default_size(GTK_WINDOW(window), 550, 350);
gtk_window_set_resizable(GTK_WINDOW(window), false);
/*Console*/
console_text = gtk_text_view_new(); //Start console up
console_buffer = gtk_text_view_get_buffer((GtkTextView*)console_text);
while(!start_console_format()); //Start up formats
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(console_text), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(console_text), false);
gtk_widget_set_size_request(console_text, 595, 345);
GdkColor console_color_bg;
console_color_bg.red = 0;
console_color_bg.green = 0;
console_color_bg.blue = 0;
gtk_widget_modify_base(console_text, GTK_STATE_NORMAL, &console_color_bg);
/*Label setup*/
status_msg = gtk_label_new(NULL);
change_status_msg("SoftServer <i>Build "+convert_to_str(BUILD_NUM)+"</i>");
start_and_stop_button = gtk_button_new_with_label("Start");
fixed_location = gtk_fixed_new();
gtk_fixed_put(GTK_FIXED(fixed_location), console_text,0,0);
gtk_fixed_put(GTK_FIXED(fixed_location), status_msg, 5, 360);
gtk_fixed_put(GTK_FIXED(fixed_location), start_and_stop_button, 550, 350);
gtk_container_add(GTK_CONTAINER(window), fixed_location);
/*Show widgets here*/
gtk_container_set_border_width(GTK_CONTAINER(window), 5);
gtk_widget_show_all(window);
add_console_msg("[Main]", notification,"Waiting for start button to be pressed");
start_stop_button_ls_id = g_signal_connect_after(start_and_stop_button, "released", G_CALLBACK(init_serv), NULL);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
activate_console();
/*Exit*/
gtk_main();
gdk_threads_leave();
return 0;
}
static void
op_configure(void)
{
GtkWidget *dev_vbox;
GtkWidget *adevice_frame, *adevice_text, *adevice_vbox;
GtkWidget *bbox, *ok, *cancel;
if (configure_win) {
gdk_window_raise(configure_win->window);
return;
}
configure_win = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_signal_connect(GTK_OBJECT(configure_win), "destroy",
GTK_SIGNAL_FUNC(configure_win_destroy), NULL);
gtk_window_set_title(GTK_WINDOW(configure_win), _("sndio device"));
gtk_window_set_policy(GTK_WINDOW(configure_win), FALSE, FALSE, FALSE);
gtk_window_set_position(GTK_WINDOW(configure_win), GTK_WIN_POS_MOUSE);
gtk_container_border_width(GTK_CONTAINER(configure_win), 10);
dev_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(configure_win), dev_vbox);
gtk_container_set_border_width(GTK_CONTAINER(dev_vbox), 5);
adevice_frame = gtk_frame_new(_("Audio device:"));
gtk_box_pack_start(GTK_BOX(dev_vbox), adevice_frame, FALSE, FALSE, 0);
adevice_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(adevice_vbox), 5);
gtk_container_add(GTK_CONTAINER(adevice_frame), adevice_vbox);
adevice_text = gtk_label_new(_("(empty means default)"));
gtk_box_pack_start_defaults(GTK_BOX(adevice_vbox), adevice_text);
adevice_entry = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(adevice_entry), audiodev);
gtk_box_pack_start_defaults(GTK_BOX(adevice_vbox), adevice_entry);
bbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(dev_vbox), bbox, FALSE, FALSE, 0);
ok = gtk_button_new_with_label(_("OK"));
gtk_signal_connect(GTK_OBJECT(ok), "clicked",
GTK_SIGNAL_FUNC(configure_win_ok_cb), NULL);
GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), ok, TRUE, TRUE, 0);
gtk_widget_grab_default(ok);
cancel = gtk_button_new_with_label(_("Cancel"));
gtk_signal_connect_object(GTK_OBJECT(cancel), "clicked",
GTK_SIGNAL_FUNC(configure_win_cancel_cb),
GTK_OBJECT(configure_win));
GTK_WIDGET_SET_FLAGS(cancel, GTK_CAN_DEFAULT);
gtk_box_pack_start(GTK_BOX(bbox), cancel, TRUE, TRUE, 0);
gtk_widget_show_all(configure_win);
}
void
prop_cb (GtkAction *action,
ProgressData *battstat)
{
GtkBuilder *builder;
GtkWidget *combo_ptr, *spin_ptr;
GtkListStore *liststore;
GtkCellRenderer *renderer;
GtkTreeIter iter;
if (DEBUG) g_print("prop_cb()\n");
if (battstat->prop_win) {
gtk_window_set_screen (GTK_WINDOW (battstat->prop_win),
gtk_widget_get_screen (battstat->applet));
gtk_window_present (GTK_WINDOW (battstat->prop_win));
return;
}
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, GTK_BUILDERDIR"/battstat_applet.ui", NULL);
battstat->prop_win = GTK_DIALOG (gtk_builder_get_object (builder,
"battstat_properties"));
gtk_window_set_screen (GTK_WINDOW (battstat->prop_win),
gtk_widget_get_screen (battstat->applet));
g_signal_connect (G_OBJECT (battstat->prop_win), "delete_event",
G_CALLBACK (gtk_true), NULL);
battstat->lowbatt_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "lowbatt_toggle"));
g_signal_connect (G_OBJECT (battstat->lowbatt_toggle), "toggled",
G_CALLBACK (lowbatt_toggled), battstat);
if (!g_settings_is_writable (battstat->settings,
"low-battery-notification"))
{
hard_set_sensitive (battstat->lowbatt_toggle, FALSE);
}
battstat->hbox_ptr = GTK_WIDGET (gtk_builder_get_object (builder, "hbox_ptr"));
hard_set_sensitive (battstat->hbox_ptr, battstat->lowbattnotification);
combo_ptr = GTK_WIDGET (gtk_builder_get_object (builder, "combo_ptr"));
g_signal_connect (G_OBJECT (combo_ptr), "changed",
G_CALLBACK (combo_ptr_cb), battstat);
liststore = gtk_list_store_new (1, G_TYPE_STRING);
gtk_combo_box_set_model (GTK_COMBO_BOX (combo_ptr),
GTK_TREE_MODEL (liststore));
gtk_cell_layout_clear (GTK_CELL_LAYOUT (combo_ptr));
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo_ptr),
renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo_ptr),
renderer,
"text", 0,
NULL);
gtk_list_store_append (liststore, &iter);
/* TRANSLATOR: this is a selectable item in a drop-down menu to end
* this sentence:
* "Warn when battery charge drops to: [XX] percent".
*/
gtk_list_store_set (liststore, &iter, 0, _("Percent"), -1);
gtk_list_store_append (liststore, &iter);
/* TRANSLATOR: this is a selectable item in a drop-down menu to end
* this sentence:
* "Warn when battery charge drops to: [XX] minutes remaining"
*/
gtk_list_store_set (liststore, &iter, 0, _("Minutes Remaining"), -1);
spin_ptr = GTK_WIDGET (gtk_builder_get_object (builder, "spin_ptr"));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (spin_ptr),
battstat->red_val);
g_signal_connect (G_OBJECT (spin_ptr), "value-changed",
G_CALLBACK (spin_ptr_cb), battstat);
if (battstat->red_value_is_time)
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_ptr), 1);
else
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_ptr), 0);
battstat->full_toggle = GTK_WIDGET (gtk_builder_get_object (builder, "full_toggle"));
g_signal_connect (G_OBJECT (battstat->full_toggle), "toggled",
G_CALLBACK (full_toggled), battstat);
if (!g_settings_is_writable (battstat->settings,
"full-battery-notification"))
{
hard_set_sensitive (battstat->full_toggle, FALSE);
}
if (battstat->fullbattnot)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (battstat->full_toggle),
TRUE);
}
if (battstat->lowbattnotification)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (battstat->lowbatt_toggle),
TRUE);
}
battstat->radio_traditional_battery = GTK_WIDGET (gtk_builder_get_object (builder,
"battery_view_2"));
g_signal_connect (G_OBJECT (battstat->radio_traditional_battery), "toggled",
G_CALLBACK (radio_traditional_toggled), battstat);
if (!g_settings_is_writable (battstat->settings, "show-battery"))
hard_set_sensitive (battstat->radio_traditional_battery, FALSE);
if (battstat->showbattery)
{
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (battstat->radio_traditional_battery),
TRUE);
}
battstat->radio_ubuntu_battery = GTK_WIDGET (gtk_builder_get_object (builder,
"battery_view"));
g_signal_connect (G_OBJECT (battstat->radio_ubuntu_battery), "toggled",
G_CALLBACK (radio_ubuntu_toggled), battstat);
if (!g_settings_is_writable (battstat->settings, "show-status"))
hard_set_sensitive (battstat->radio_ubuntu_battery, FALSE);
if (battstat->showstatus)
{
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (battstat->radio_ubuntu_battery), TRUE);
}
battstat->radio_text_1 = GTK_WIDGET (gtk_builder_get_object (builder, "show_text_radio"));
battstat->radio_text_2 = GTK_WIDGET (gtk_builder_get_object (builder,
"show_text_radio_2"));
battstat->check_text = GTK_WIDGET (gtk_builder_get_object (builder,
"show_text_remaining"));
g_object_unref (builder);
g_signal_connect (G_OBJECT (battstat->radio_text_1), "toggled",
G_CALLBACK (show_text_toggled), battstat);
g_signal_connect (G_OBJECT (battstat->radio_text_2), "toggled",
G_CALLBACK (show_text_toggled), battstat);
g_signal_connect (G_OBJECT (battstat->check_text), "toggled",
G_CALLBACK (show_text_toggled), battstat);
if (!g_settings_is_writable (battstat->settings, "show-text"))
{
hard_set_sensitive (battstat->check_text, FALSE);
hard_set_sensitive (battstat->radio_text_1, FALSE);
hard_set_sensitive (battstat->radio_text_2, FALSE);
}
if (battstat->showtext == APPLET_SHOW_PERCENT)
{
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (battstat->check_text), TRUE);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (battstat->radio_text_2), TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_1),
TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_2),
TRUE);
}
else if (battstat->showtext == APPLET_SHOW_TIME)
{
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (battstat->check_text),
TRUE);
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (battstat->radio_text_1),
TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_1),
TRUE);
gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_2),
TRUE);
}
else /* APPLET_SHOW_NONE */
{
gtk_toggle_button_set_active (
GTK_TOGGLE_BUTTON (battstat->check_text), FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_1),
FALSE);
gtk_widget_set_sensitive (GTK_WIDGET (battstat->radio_text_2),
FALSE);
}
gtk_dialog_set_default_response (GTK_DIALOG (battstat->prop_win),
GTK_RESPONSE_CLOSE);
gtk_window_set_resizable (GTK_WINDOW (battstat->prop_win), FALSE);
gtk_dialog_set_has_separator (GTK_DIALOG (battstat->prop_win), FALSE);
g_signal_connect (G_OBJECT (battstat->prop_win), "response",
G_CALLBACK (response_cb), battstat);
gtk_widget_show_all (GTK_WIDGET (battstat->prop_win));
}
void start_GUI() {
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), "telerobot client");
gtk_window_set_icon_from_file(GTK_WINDOW(main_window), "icons/PlayStation_3_gamepad.svg", NULL);
/* gdk_window_set_icon_list(GTK_WINDOW(main_window), NULL); */
gtk_window_set_default_size(GTK_WINDOW(main_window), 973, 309); /* actually 1024, 254 */
gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_CENTER);
/* gtk_widget_show(main_window); */
left_table = gtk_table_new(6, 3, TRUE);
gtk_table_set_row_spacings(GTK_TABLE(left_table), 2);
gtk_table_set_col_spacings(GTK_TABLE(left_table), 2);
provider = gtk_css_provider_new();
/* gtk_css_provider_load_from_path(cssProvider,"./style.css", NULL); */
gtk_css_provider_load_from_data(GTK_CSS_PROVIDER(provider), "GtkProgressBar {\n"
"min-height: 30px;\n"
"}\n", -1, NULL);
display = gdk_display_get_default();
screen = gdk_display_get_default_screen(display);
gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref(provider);
progress1 = gtk_progress_bar_new();
//gtk_progress_bar_set_inverted(progress1, TRUE);
/* this would invert progressbar direction */
gtk_progress_bar_set_text(progress1, "L2:");
gtk_progress_bar_set_show_text(progress1, TRUE);
/*g_object_set(progress1, "min-height", 30, NULL);*/
gtk_table_attach(GTK_TABLE(left_table), progress1, 0, 3, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress1), GTK_ALIGN_CENTER);
progress2 = gtk_progress_bar_new();
gtk_progress_bar_set_text(progress2, "R2:");
gtk_progress_bar_set_show_text(progress2, TRUE);
/*g_object_set(progress2, "min-height", 30, NULL);*/
gtk_table_attach(GTK_TABLE(left_table), progress2, 0, 3, 1, 2, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress2), GTK_ALIGN_CENTER);
progress3 = gtk_progress_bar_new();
gtk_progress_bar_set_show_text(progress3, TRUE);
gtk_table_attach(GTK_TABLE(left_table), progress3, 0, 3, 2, 3, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress3), GTK_ALIGN_CENTER);
progress4 = gtk_progress_bar_new();
gtk_progress_bar_set_show_text(progress4, TRUE);
gtk_table_attach(GTK_TABLE(left_table), progress4, 0, 3, 3, 4, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress4), GTK_ALIGN_CENTER);
progress5 = gtk_progress_bar_new();
gtk_progress_bar_set_show_text(progress5, TRUE);
gtk_table_attach(GTK_TABLE(left_table), progress5, 0, 3, 4, 5, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(progress5), GTK_ALIGN_CENTER);
/* feedback labels */
label_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
label_roll = gtk_label_new("roll (\u00B0)");
gtk_box_pack_start(GTK_WIDGET(label_box), label_roll, FALSE, FALSE, 10);
label_pitch = gtk_label_new("pitch (\u00B0)");
gtk_box_pack_start(GTK_WIDGET(label_box), label_pitch, FALSE, FALSE, 10);
label_alt = gtk_label_new("altitude (m)");
gtk_box_pack_start(GTK_WIDGET(label_box), label_alt, FALSE, FALSE, 10);
gtk_table_attach(GTK_TABLE(left_table), label_box, 0, 3, 5, 6, GTK_FILL, GTK_EXPAND, 0, 0);
gtk_widget_set_valign(GTK_WIDGET(label_box), GTK_ALIGN_CENTER);
left_frame = gtk_aspect_frame_new(NULL, /* label */
0.5, /* horizontal position */
0.0, /* vertical position */
1, /* xsize/ysize = 1 */
FALSE /* ignore child's aspect */);
drawing_area_frame = gtk_aspect_frame_new(NULL, 0.5, 0.0, 1, TRUE /* ignore child's aspect */);
gtk_frame_set_shadow_type(GTK_FRAME(drawing_area_frame), GTK_SHADOW_ETCHED_IN);
GtkWidget *text_area_frame;
text_area_frame = gtk_aspect_frame_new(NULL, 0.5, 0.0, 1, TRUE);
gtk_frame_set_shadow_type(GTK_FRAME(text_area_frame), GTK_SHADOW_ETCHED_IN);
drawing_area = gtk_drawing_area_new();
gtk_widget_set_size_request(drawing_area, 320, 320);
gtk_container_add(GTK_CONTAINER(drawing_area_frame), drawing_area);
g_signal_connect(G_OBJECT(drawing_area), "draw", G_CALLBACK(on_draw_event), NULL);
g_signal_connect(main_window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_frame_set_shadow_type(GTK_FRAME(left_frame), GTK_SHADOW_ETCHED_IN);
/* draws a frame */
gtk_container_add(GTK_CONTAINER(left_frame), left_table);
/* places the widget inside frame */
main_table = gtk_table_new(1, 3, FALSE);
/* creates three column table */
gtk_table_attach_defaults(GTK_TABLE(main_table), left_frame, 0, 1, 0, 1);
/* places the widget inside leftmost cell of the table */
gtk_table_attach_defaults(GTK_TABLE(main_table), drawing_area_frame, 1, 2, 0, 1);
/* places the video/artificial horizon widget inside middle cell */
/* prawa komórka głównej tabeli */
// grid method
// right_table = gtk_grid_new();
// table method
right_table = gtk_table_new(3, 3, TRUE);
/* prawa ramka */
right_frame = gtk_aspect_frame_new(NULL, /* label */
0.5, /* wyrównanie w poziomie */
0.0, /* wyrównanie w pionie */
1, /* xsize/ysize = 1 */
FALSE /* ignore child's aspect */);
/* zamiast "0" może być NULL - wtedy pole jest puste */
label_x1 = gtk_label_new("");
label_y1 = gtk_label_new("");
label_x2 = gtk_label_new("");
label_y2 = gtk_label_new("");
/* 0 - pierwsza kolumna, 1 - druga kolumna następna (numerowane od zera) */
/* umieszcza wskaźniki w polach tabeli */
gtk_label_set_justify(label_x1, GTK_JUSTIFY_RIGHT);
gtk_label_set_justify(label_y1, GTK_JUSTIFY_RIGHT);
/* "0,2,Y,Y" oznacza że zajmują dwie komórki tabeli */
/* typ obwiedni */
gtk_frame_set_shadow_type(GTK_FRAME(right_frame), GTK_SHADOW_ETCHED_IN);
/* umieszcza right_table w wskazniki */
gtk_container_add(GTK_CONTAINER(right_frame), right_table);
gtk_table_attach_defaults(GTK_TABLE(main_table), right_frame, 2, 3, 0, 1);
/* umieszcza ramkę wskazniki w prawej (2,3) komórce głównej tabeli */
/* tworzy przycisk wyłączający serwer */
/*
GtkWidget *quit_icon;
GtkWidget *quit_button;
quit_icon = gtk_image_new_from_file("icons/system-shutdown.svg");
quit_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(quit_button), quit_icon);
g_signal_connect(quit_button, "pressed", G_CALLBACK(wyslij_przycisk_13_on), NULL);
g_signal_connect(quit_button, "released", G_CALLBACK(wyslij_przycisk_13_off), NULL);
gtk_button_set_relief(quit_button, GTK_RELIEF_NONE);
*/
/* Sets whether the button will grab focus when it is clicked with the mouse.
Making mouse clicks not grab focus is useful in places like toolbars
where you don't want the keyboard focus removed from the main area of the application. */
/* gtk_button_set_focus_on_click(quit_button, 0); */
/* regulator & servo controller buttons */
servocontroller_enable_button = gtk_button_new_with_label("enable\nUSC-16");
gtk_button_set_relief(servocontroller_enable_button, GTK_RELIEF_NONE);
gtk_table_attach_defaults(GTK_TABLE(right_table), servocontroller_enable_button, 0, 1, 2, 3);
servocontroller_disable_button = gtk_button_new_with_label("disable\nUSC-16");
gtk_button_set_relief(servocontroller_disable_button, GTK_RELIEF_NONE);
gtk_table_attach_defaults(GTK_TABLE(right_table), servocontroller_disable_button, 0, 1, 2, 3);
check_button_regulator = gtk_check_button_new_with_label("50 Hz");
gtk_toggle_button_set_active(check_button_regulator, FALSE);
gtk_table_attach_defaults(GTK_TABLE(right_table), check_button_regulator, 1, 2, 2, 3);
/* record buttons */
record_start_icon = gtk_image_new_from_file("icons/media-record.svg");
record_start_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(record_start_button), record_start_icon);
gtk_table_attach_defaults(GTK_TABLE(right_table), record_start_button, 2, 3, 1, 2);
gtk_button_set_relief(GTK_BUTTON(record_start_button), GTK_RELIEF_NONE);
record_stop_icon = gtk_image_new_from_file("icons/media-playback-stop.svg");
record_stop_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(record_stop_button), record_stop_icon);
gtk_table_attach_defaults(GTK_TABLE(right_table), record_stop_button, 2, 3, 1, 2);
gtk_button_set_relief(GTK_BUTTON(record_stop_button), GTK_RELIEF_NONE);
/* fullscreen buttons */
fullscreen_enable_icon = gtk_image_new_from_file("icons/view-fullscreen.svg");
fullscreen_enable_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(fullscreen_enable_button), fullscreen_enable_icon);
g_signal_connect(fullscreen_enable_button, "clicked", G_CALLBACK(enable_Fullscreen), NULL);
gtk_button_set_relief(fullscreen_enable_button, GTK_RELIEF_NONE);
fullscreen_disable_icon = gtk_image_new_from_file("icons/view-windowed.svg");
fullscreen_disable_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(fullscreen_disable_button), fullscreen_disable_icon);
g_signal_connect(fullscreen_disable_button, "clicked", G_CALLBACK(disable_Fullscreen), NULL);
gtk_button_set_relief(fullscreen_disable_button, GTK_RELIEF_NONE);
/* joystick button */
// https://commons.wikimedia.org/wiki/File:PlayStation_3_gamepad.svg
joystick_icon = gtk_image_new_from_file("icons/PlayStation_3_gamepad.svg");
check_button_joystick = gtk_check_button_new();
/* gtk_container_add (GTK_CONTAINER (check_button_joystick), joystick_icon); */
/* łączenie sygnału przeniesione za pierwsze wykrycie joysticka */
/* video button */
video_icon = gtk_image_new_from_file("icons/camera-web.svg");
check_button_video = gtk_check_button_new();
gtk_toggle_button_set_active(check_button_video, TRUE);
/* reconnect button */
reconnect_icon = gtk_image_new_from_file("icons/gnome-modem.svg");
reconnect_button = gtk_button_new();
gtk_container_add(GTK_CONTAINER(reconnect_button), reconnect_icon);
gtk_button_set_relief(reconnect_button, GTK_RELIEF_NONE);
/* table method */
gtk_table_attach_defaults(GTK_TABLE(right_table), label_x1, 0, 1, 0, 1);
gtk_table_attach(GTK_TABLE(right_table), label_y1, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 20);
gtk_table_attach_defaults(GTK_TABLE(right_table), label_x2, 1, 2, 0, 1);
gtk_table_attach(GTK_TABLE(right_table), label_y2, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 20);
gtk_table_attach_defaults(GTK_TABLE(right_table), reconnect_button, 2, 3, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), fullscreen_enable_button, 2, 3, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(right_table), fullscreen_disable_button, 2, 3, 2, 3);
gtk_table_attach_defaults(GTK_TABLE(right_table), video_icon, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), check_button_video, 1, 2, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), joystick_icon, 0, 1, 3, 4);
gtk_table_attach_defaults(GTK_TABLE(right_table), check_button_joystick, 0, 1, 3, 4);
/* grid method */
// FIXME: works only with GTK+ 3.0
/*
gtk_grid_attach(GTK_GRID(right_table), label_x, 0, 0, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), label_y, 0, 1, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), label_x2, 1, 0, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), label_y2, 1, 1, 2, 1);
gtk_grid_attach(GTK_GRID(right_table), fullscreen_enable_button, 2, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), fullscreen_disable_button, 2, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), video_icon, 1, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_video, 1, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), joystick_icon, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_joystick, 0, 3, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_serwokontroler, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), check_button_regulator, 1, 2, 1, 1);
gtk_grid_attach(GTK_GRID(right_table), quit_button, 2, 3, 1, 1);
*/
statusbar = gtk_statusbar_new();
context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "Statusbar example");
/* pakowanie głównych elementów okna programu: */
vbox = gtk_vbox_new(FALSE, 2);
/* ustawianie szerokości marginesu wokół elementu */
gtk_box_pack_start(GTK_BOX(vbox), main_table, TRUE, TRUE, 1);
gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
gtk_container_set_border_width(GTK_CONTAINER(main_table), 5);
gtk_container_add(GTK_CONTAINER(main_window), vbox);
}
void
view_padding_color_cmd_callback (GtkAction *action,
gint value,
gpointer data)
{
GimpDisplay *display;
GimpImageWindow *window;
GimpDisplayShell *shell;
GimpDisplayOptions *options;
gboolean fullscreen;
return_if_no_display (display, data);
shell = gimp_display_get_shell (display);
window = gimp_display_shell_get_window (shell);
if (window)
fullscreen = gimp_image_window_get_fullscreen (window);
else
fullscreen = FALSE;
if (fullscreen)
options = shell->fullscreen_options;
else
options = shell->options;
switch ((GimpCanvasPaddingMode) value)
{
case GIMP_CANVAS_PADDING_MODE_DEFAULT:
case GIMP_CANVAS_PADDING_MODE_LIGHT_CHECK:
case GIMP_CANVAS_PADDING_MODE_DARK_CHECK:
g_object_set_data (G_OBJECT (shell), "padding-color-dialog", NULL);
options->padding_mode_set = TRUE;
gimp_display_shell_set_padding (shell, (GimpCanvasPaddingMode) value,
&options->padding_color);
break;
case GIMP_CANVAS_PADDING_MODE_CUSTOM:
{
GtkWidget *color_dialog;
color_dialog = g_object_get_data (G_OBJECT (shell),
"padding-color-dialog");
if (! color_dialog)
{
GimpImage *image = gimp_display_get_image (display);
GimpDisplayShell *shell = gimp_display_get_shell (display);
color_dialog =
gimp_color_dialog_new (GIMP_VIEWABLE (image),
action_data_get_context (data),
_("Set Canvas Padding Color"),
GTK_STOCK_SELECT_COLOR,
_("Set Custom Canvas Padding Color"),
GTK_WIDGET (shell),
NULL, NULL,
&options->padding_color,
FALSE, FALSE);
g_signal_connect (color_dialog, "update",
G_CALLBACK (view_padding_color_dialog_update),
shell);
g_object_set_data_full (G_OBJECT (shell), "padding-color-dialog",
color_dialog,
(GDestroyNotify) gtk_widget_destroy);
}
gtk_window_present (GTK_WINDOW (color_dialog));
}
break;
case GIMP_CANVAS_PADDING_MODE_RESET:
g_object_set_data (G_OBJECT (shell), "padding-color-dialog", NULL);
{
GimpDisplayOptions *default_options;
options->padding_mode_set = FALSE;
if (fullscreen)
default_options = display->config->default_fullscreen_view;
else
default_options = display->config->default_view;
gimp_display_shell_set_padding (shell,
default_options->padding_mode,
&default_options->padding_color);
}
break;
}
}
gint main(gint argc, char** argv) {
gtk_init(&argc, &argv);
ball = g_slice_new(balls);
paddle = g_slice_new(paddles);
white = g_slice_new(GdkGC);
black = g_slice_new(GdkGC);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(window, DISPLAY_WIDTH, DISPLAY_HEIGHT);
gtk_window_set_resizable(GTK_WINDOW(window), false);
gtk_window_set_title(GTK_WINDOW(window), "GTK Pong");
draw = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window), draw);
InitCallback();
gtk_widget_show_all(window);
pixmap = gdk_pixmap_new(draw->window, draw->allocation.width,
draw->allocation.height, -1);
black = draw->style->black_gc;
white = draw->style->white_gc;
GtkWidget *ballimagetmp = gtk_image_new_from_file("data/chromium.png");
ballimage = gtk_image_get_pixbuf(GTK_IMAGE(ballimagetmp));
BallInfo();
paddle->width = 100;
paddle->height = 10;
paddle->y = DISPLAY_HEIGHT - paddle->height;
paddle->x = (DISPLAY_WIDTH / 2) - (paddle->width / 2);
paddle->speed = paddle->width / 2;
if (DISPLAY_WIDTH < paddle->width) {
printf("Paddle too big");
return 2;
}
if (DISPLAY_WIDTH < ball->width) {
printf("Ball too big");
return 2;
}
if (DISPLAY_HEIGHT < paddle->height + ball->height) {
printf("Height of paddle and ball too big");
return 2;
}
ball->x = UniformRandom(0, DISPLAY_WIDTH - ball->width); //Initial position
ball->y = UniformRandom(0, (DISPLAY_HEIGHT - ball->height - paddle->height)
/ 2);
ball->dx = UniformRandom(3, 7); //Initial speed/direction of travel
ball->dy = UniformRandom(3, 7);
if (UniformRandom(1, 2) == 1)//Allow negative values initially
ball->dx *= -1;
if (UniformRandom(1, 2) == 1)
ball->dy *= -1;
Fill(white, 0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT);
DrawPaddle(true);
DrawBall(true);
#ifdef DEBUG
ball->dx = 0;
ball->dy = 0;
#else
for (g_usleep(2 * G_USEC_PER_SEC); g_main_context_iteration(NULL, 0);)
;
#endif
while (true) {
DrawBall(false);
gint i;
for (i = 0; i < ABS(ball->dx) || i < ABS(ball->dy); ++i) {//Move ball
if (i < ABS(ball->dx)) {
ball->x += ABS(ball->dx) / ball->dx;
if (!checkPos()) {
ball->dx *= -1;
ball->x += 2 * ABS(ball->dx) / ball->dx;
}
}
if (i < ABS(ball->dy)) {
ball->y += ABS(ball->dy) / ball->dy;
if (!checkPos()) {
ball->dy *= -1;
ball->y += 2 * ABS(ball->dy) / ball->dy;
}
}
}
DrawBall(true);
for (g_usleep(20000); g_main_context_iteration(NULL, 0);)
;
}
return 0;
}
static PidginLogViewer *display_log_viewer(struct log_viewer_hash_t *ht, GList *logs,
const char *title, GtkWidget *icon, int log_size)
{
PidginLogViewer *lv;
GtkWidget *title_box;
char *text;
GtkWidget *pane;
GtkWidget *sw;
GtkCellRenderer *rend;
GtkTreeViewColumn *col;
GtkTreeSelection *sel;
GtkWidget *vbox;
GtkWidget *frame;
GtkWidget *hbox;
GtkWidget *find_button;
GtkWidget *size_label;
if (logs == NULL)
{
/* No logs were found. */
const char *log_preferences = NULL;
if (ht == NULL) {
if (!purple_prefs_get_bool("/purple/logging/log_system"))
log_preferences = _("System events will only be logged if the \"Log all status changes to system log\" preference is enabled.");
} else {
if (ht->type == PURPLE_LOG_IM) {
if (!purple_prefs_get_bool("/purple/logging/log_ims"))
log_preferences = _("Instant messages will only be logged if the \"Log all instant messages\" preference is enabled.");
} else if (ht->type == PURPLE_LOG_CHAT) {
if (!purple_prefs_get_bool("/purple/logging/log_chats"))
log_preferences = _("Chats will only be logged if the \"Log all chats\" preference is enabled.");
}
g_free(ht->buddyname);
g_free(ht);
}
if(icon != NULL)
gtk_widget_destroy(icon);
purple_notify_info(NULL, title, _("No logs were found"), log_preferences);
return NULL;
}
lv = g_new0(PidginLogViewer, 1);
lv->logs = logs;
if (ht != NULL)
g_hash_table_insert(log_viewers, ht, lv);
/* Window ***********/
lv->window = gtk_dialog_new_with_buttons(title, NULL, 0,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
#ifdef _WIN32
/* Steal the "HELP" response and use it to trigger browsing to the logs folder */
gtk_dialog_add_button(GTK_DIALOG(lv->window), _("_Browse logs folder"), GTK_RESPONSE_HELP);
#endif
gtk_container_set_border_width (GTK_CONTAINER(lv->window), PIDGIN_HIG_BOX_SPACE);
gtk_dialog_set_has_separator(GTK_DIALOG(lv->window), FALSE);
gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(lv->window)->vbox), 0);
g_signal_connect(G_OBJECT(lv->window), "response",
G_CALLBACK(destroy_cb), ht);
gtk_window_set_role(GTK_WINDOW(lv->window), "log_viewer");
/* Icon *************/
if (icon != NULL) {
title_box = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
gtk_container_set_border_width(GTK_CONTAINER(title_box), PIDGIN_HIG_BOX_SPACE);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), title_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(title_box), icon, FALSE, FALSE, 0);
} else
title_box = GTK_DIALOG(lv->window)->vbox;
/* Label ************/
lv->label = gtk_label_new(NULL);
text = g_strdup_printf("<span size='larger' weight='bold'>%s</span>", title);
gtk_label_set_markup(GTK_LABEL(lv->label), text);
gtk_misc_set_alignment(GTK_MISC(lv->label), 0, 0);
gtk_box_pack_start(GTK_BOX(title_box), lv->label, FALSE, FALSE, 0);
g_free(text);
/* Pane *************/
pane = gtk_hpaned_new();
gtk_container_set_border_width(GTK_CONTAINER(pane), PIDGIN_HIG_BOX_SPACE);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), pane, TRUE, TRUE, 0);
/* List *************/
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_paned_add1(GTK_PANED(pane), sw);
lv->treestore = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
lv->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (lv->treestore));
g_object_unref(G_OBJECT(lv->treestore));
rend = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes ("time", rend, "markup", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(lv->treeview), col);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (lv->treeview), FALSE);
gtk_container_add (GTK_CONTAINER (sw), lv->treeview);
populate_log_tree(lv);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (lv->treeview));
g_signal_connect (G_OBJECT (sel), "changed",
G_CALLBACK (log_select_cb),
lv);
g_signal_connect (G_OBJECT(lv->treeview), "row-activated",
G_CALLBACK(log_row_activated_cb),
lv);
pidgin_set_accessible_label(lv->treeview, lv->label);
g_signal_connect(lv->treeview, "button-press-event", G_CALLBACK(log_button_press_cb), lv);
g_signal_connect(lv->treeview, "popup-menu", G_CALLBACK(log_popup_menu_cb), lv);
/* Log size ************/
if(log_size) {
char *sz_txt = purple_str_size_to_units(log_size);
text = g_strdup_printf("<span weight='bold'>%s</span> %s", _("Total log size:"), sz_txt);
size_label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(size_label), text);
/* gtk_paned_add1(GTK_PANED(pane), size_label); */
gtk_misc_set_alignment(GTK_MISC(size_label), 0, 0);
gtk_box_pack_end(GTK_BOX(GTK_DIALOG(lv->window)->vbox), size_label, FALSE, FALSE, 0);
g_free(sz_txt);
g_free(text);
}
/* A fancy little box ************/
vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
gtk_paned_add2(GTK_PANED(pane), vbox);
/* Viewer ************/
frame = pidgin_create_imhtml(FALSE, &lv->imhtml, NULL, NULL);
gtk_widget_set_name(lv->imhtml, "pidgin_log_imhtml");
gtk_widget_set_size_request(lv->imhtml, 320, 200);
gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
gtk_widget_show(frame);
/* Search box **********/
hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
lv->entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(hbox), lv->entry, TRUE, TRUE, 0);
find_button = gtk_button_new_from_stock(GTK_STOCK_FIND);
gtk_box_pack_start(GTK_BOX(hbox), find_button, FALSE, FALSE, 0);
g_signal_connect(GTK_ENTRY(lv->entry), "activate", G_CALLBACK(search_cb), lv);
g_signal_connect(GTK_BUTTON(find_button), "clicked", G_CALLBACK(search_cb), lv);
select_first_log(lv);
gtk_widget_show_all(lv->window);
return lv;
}
int imp_kr_m(class imp_kr_rek *rek_ras,GtkWidget *wpredok)
{
class imp_kr_m_data data;
data.rk=rek_ras;
char strsql[512];
data.window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position( GTK_WINDOW(data.window),ICEB_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(data.window),TRUE);
sprintf(strsql,"%s %s",name_system,gettext("Импорт из подсистемы \"Учёт кассовых ордеров\""));
gtk_window_set_title (GTK_WINDOW (data.window),strsql);
gtk_container_set_border_width (GTK_CONTAINER (data.window), 5);
gtk_signal_connect(GTK_OBJECT(data.window),"delete_event",GTK_SIGNAL_FUNC(gtk_widget_destroy),NULL);
gtk_signal_connect(GTK_OBJECT(data.window),"destroy",GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
gtk_signal_connect_after(GTK_OBJECT(data.window),"key_press_event",GTK_SIGNAL_FUNC(imp_kr_m_v_key_press),&data);
if(wpredok != NULL)
{
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
//Удерживать окно над породившем его окном всегда
gtk_window_set_transient_for(GTK_WINDOW(data.window),GTK_WINDOW(wpredok));
//Закрыть окно если окно предок удалено
gtk_window_set_destroy_with_parent(GTK_WINDOW(data.window),TRUE);
}
class iceb_u_str repl;
repl.plus(gettext("Импорт из подсистемы \"Учёт кассовых ордеров\""));
//repl.ps_plus(data.rk->naim_oth.ravno());
GtkWidget *label=gtk_label_new(repl.ravno_toutf());
GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
GtkWidget *hbox[KOLENTER];
for(int i=0; i < KOLENTER; i++)
hbox[i] = gtk_hbox_new (FALSE, 0);
//GtkWidget *hboxradio = gtk_hbox_new (FALSE, 0);
GtkWidget *hboxknop = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (data.window), vbox);
gtk_container_add (GTK_CONTAINER (vbox), label);
for(int i=0; i < KOLENTER; i++)
gtk_container_add (GTK_CONTAINER (vbox), hbox[i]);
gtk_container_add (GTK_CONTAINER (vbox), hboxknop);
sprintf(strsql,"%s",gettext("Дата начала"));
data.knopka_enter[E_DATAN]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_DATAN]), data.knopka_enter[E_DATAN], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_DATAN]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_DATAN]),(gpointer)E_DATAN);
data.entry[E_DATAN] = gtk_entry_new_with_max_length (10);
gtk_box_pack_start (GTK_BOX (hbox[E_DATAN]), data.entry[E_DATAN], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAN]), "activate",GTK_SIGNAL_FUNC(imp_kr_m_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAN]),data.rk->datan.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAN]),(gpointer)E_DATAN);
sprintf(strsql,"%s",gettext("Дата конца"));
data.knopka_enter[E_DATAK]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_DATAK]), data.knopka_enter[E_DATAK], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_DATAK]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_DATAK]),(gpointer)E_DATAK);
data.entry[E_DATAK] = gtk_entry_new_with_max_length (10);
gtk_box_pack_start (GTK_BOX (hbox[E_DATAK]), data.entry[E_DATAK], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_DATAK]), "activate",GTK_SIGNAL_FUNC(imp_kr_m_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_DATAK]),data.rk->datak.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DATAK]),(gpointer)E_DATAK);
label=gtk_label_new(gettext("День записи"));
gtk_box_pack_start (GTK_BOX (hbox[E_DENZ]), label, FALSE, FALSE, 0);
data.entry[E_DENZ] = gtk_entry_new_with_max_length (2);
gtk_box_pack_start (GTK_BOX (hbox[E_DENZ]), data.entry[E_DENZ], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_DENZ]), "activate",GTK_SIGNAL_FUNC(imp_kr_m_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_DENZ]),data.rk->denz.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_DENZ]),(gpointer)E_DENZ);
sprintf(strsql,"%s",gettext("Код затрат"));
data.knopka_enter[E_KOD_ZAT]=gtk_button_new_with_label(iceb_u_toutf(strsql));
gtk_box_pack_start (GTK_BOX (hbox[E_KOD_ZAT]), data.knopka_enter[E_KOD_ZAT], FALSE, FALSE, 0);
gtk_signal_connect(GTK_OBJECT(data.knopka_enter[E_KOD_ZAT]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_e_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka_enter[E_KOD_ZAT]),(gpointer)E_KOD_ZAT);
data.entry[E_KOD_ZAT] = gtk_entry_new_with_max_length (10);
gtk_box_pack_start (GTK_BOX (hbox[E_KOD_ZAT]), data.entry[E_KOD_ZAT], TRUE, TRUE, 0);
gtk_signal_connect(GTK_OBJECT (data.entry[E_KOD_ZAT]), "activate",GTK_SIGNAL_FUNC(imp_kr_m_v_vvod),&data);
gtk_entry_set_text(GTK_ENTRY(data.entry[E_KOD_ZAT]),data.rk->kod_zat.ravno_toutf());
gtk_object_set_user_data(GTK_OBJECT(data.entry[E_KOD_ZAT]),(gpointer)E_KOD_ZAT);
GtkTooltips *tooltips[KOL_F_KL];
sprintf(strsql,"F2 %s",gettext("Расчет"));
data.knopka[FK2]=gtk_button_new_with_label(strsql);
tooltips[FK2]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK2],data.knopka[FK2],gettext("Начать расчет"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK2]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK2]),(gpointer)FK2);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK2], TRUE, TRUE, 0);
sprintf(strsql,"F4 %s",gettext("Очистить"));
data.knopka[FK4]=gtk_button_new_with_label(strsql);
tooltips[FK4]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK4],data.knopka[FK4],gettext("Очистить меню от введенной информации"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK4]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK4]),(gpointer)FK4);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK4], TRUE, TRUE, 0);
sprintf(strsql,"F10 %s",gettext("Выход"));
data.knopka[FK10]=gtk_button_new_with_label(strsql);
tooltips[FK10]=gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips[FK10],data.knopka[FK10],gettext("Завершение работы в этом окне"),NULL);
gtk_signal_connect(GTK_OBJECT(data.knopka[FK10]),"clicked",GTK_SIGNAL_FUNC(imp_kr_m_v_knopka),&data);
gtk_object_set_user_data(GTK_OBJECT(data.knopka[FK10]),(gpointer)FK10);
gtk_box_pack_start(GTK_BOX(hboxknop), data.knopka[FK10], TRUE, TRUE, 0);
gtk_widget_grab_focus(data.entry[0]);
gtk_widget_show_all (data.window);
gtk_main();
if(wpredok != NULL)
gdk_window_set_cursor(wpredok->window,gdk_cursor_new(ICEB_CURSOR));
return(data.voz);
}
void pull (struct tilda_window_ *tw, enum pull_state state)
{
DEBUG_FUNCTION ("pull");
DEBUG_ASSERT (tw != NULL);
DEBUG_ASSERT (state == PULL_UP || state == PULL_DOWN || state == PULL_TOGGLE);
gint i;
if (tw->current_state == UP && state != PULL_UP)
{
/* Keep things here just like they are. If you use gtk_window_present() here, you
* will introduce some weird graphical glitches. Also, calling gtk_window_move()
* before showing the window avoids yet more glitches. You should probably not use
* gtk_window_show_all() here, as it takes a long time to execute.
*
* Overriding the user time here seems to work a lot better than calling
* gtk_window_present_with_time() here, or at the end of the function. I have
* no idea why, they should do the same thing. */
gdk_x11_window_set_user_time (gtk_widget_get_window (tw->window),
tomboy_keybinder_get_current_event_time());
gtk_window_move (GTK_WINDOW(tw->window), config_getint ("x_pos"), config_getint ("y_pos"));
gtk_widget_show (GTK_WIDGET(tw->window));
/* Nasty code to make metacity behave. Starting at metacity-2.22 they "fixed" the
* focus stealing prevention to make the old _NET_WM_USER_TIME hack
* not work anymore. This is working for now... */
tilda_window_set_active (tw);
/* The window should maintain its properties when it is merely hidden, but it does
* not. If you delete the following call, the window will not remain visible
* on all workspaces after pull()ing it up and down a number of times.
*
* Note that the "Always on top" property doesn't seem to go away, only this
* property (Show on all desktops) does... */
if (config_getbool ("pinned"))
gtk_window_stick (GTK_WINDOW (tw->window));
if (config_getbool ("animation"))
{
for (i=0; i<16; i++)
{
gtk_window_move (GTK_WINDOW(tw->window), posIV[2][i], posIV[0][i]);
gtk_window_resize (GTK_WINDOW(tw->window), posIV[3][i], posIV[1][i]);
process_all_pending_gtk_events ();
g_usleep (config_getint ("slide_sleep_usec"));
}
}
debug_printf ("pull(): MOVED DOWN\n");
tw->current_state = DOWN;
}
else if (state != PULL_DOWN)
{
if (config_getbool ("animation"))
{
for (i=15; i>=0; i--)
{
gtk_window_move (GTK_WINDOW(tw->window), posIV[2][i], posIV[0][i]);
gtk_window_resize (GTK_WINDOW(tw->window), posIV[3][i], posIV[1][i]);
process_all_pending_gtk_events ();
g_usleep (config_getint ("slide_sleep_usec"));
}
}
/* All we have to do at this point is hide the window.
* Case 1 - Animation on: The window has shrunk, just hide it
* Case 2 - Animation off: Just hide the window */
gtk_widget_hide (GTK_WIDGET(tw->window));
debug_printf ("pull(): MOVED UP\n");
tw->current_state = UP;
}
}
static void
do_simple_message_box(ESD_TYPE_E type, gboolean *notagain,
const char *secondary_msg, const char *msg_format,
va_list ap)
{
GtkMessageType gtk_message_type;
gchar *message;
GtkWidget *msg_dialog;
GtkWidget *checkbox = NULL;
if (notagain != NULL) {
if (*notagain) {
/*
* The user had checked the "Don't show this message again" checkbox
* in the past; don't bother showing it.
*/
return;
}
}
switch (type) {
case ESD_TYPE_INFO:
gtk_message_type = GTK_MESSAGE_INFO;
break;
case ESD_TYPE_WARN:
gtk_message_type = GTK_MESSAGE_WARNING;
break;
case ESD_TYPE_ERROR:
gtk_message_type = GTK_MESSAGE_ERROR;
break;
default:
g_assert_not_reached();
gtk_message_type = GTK_MESSAGE_INFO;
break;
}
/* Format the message. */
message = g_strdup_vprintf(msg_format, ap);
msg_dialog = gtk_message_dialog_new(GTK_WINDOW(top_level),
(GtkDialogFlags)(GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT),
gtk_message_type,
GTK_BUTTONS_OK,
"%s", message);
g_free(message);
if (secondary_msg != NULL)
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog),
"%s", secondary_msg);
if (notagain != NULL) {
checkbox = gtk_check_button_new_with_label("Don't show this message again.");
gtk_container_set_border_width(GTK_CONTAINER(checkbox), 12);
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(msg_dialog))),
checkbox, TRUE, TRUE, 0);
gtk_widget_show(checkbox);
}
gtk_dialog_run(GTK_DIALOG(msg_dialog));
if (notagain != NULL) {
/*
* OK, did they check the checkbox?
*/
*notagain = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox));
}
gtk_widget_destroy(msg_dialog);
}
VectorsImportDialog *
vectors_import_dialog_new (GimpImage *image,
GtkWidget *parent,
gboolean merge_vectors,
gboolean scale_vectors)
{
VectorsImportDialog *dialog;
GtkWidget *vbox;
GtkWidget *button;
GtkFileFilter *filter;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL);
dialog = g_slice_new0 (VectorsImportDialog);
dialog->image = image;
dialog->merge_vectors = merge_vectors;
dialog->scale_vectors = scale_vectors;
dialog->dialog =
gtk_file_chooser_dialog_new (_("Import Paths from SVG"), NULL,
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gtk_window_set_screen (GTK_WINDOW (dialog->dialog),
gtk_widget_get_screen (parent));
gtk_window_set_role (GTK_WINDOW (dialog->dialog), "gimp-vectors-import");
gtk_window_set_position (GTK_WINDOW (dialog->dialog), GTK_WIN_POS_MOUSE);
gtk_dialog_set_default_response (GTK_DIALOG (dialog->dialog),
GTK_RESPONSE_OK);
g_object_weak_ref (G_OBJECT (dialog->dialog),
(GWeakNotify) vectors_import_dialog_free, dialog);
g_signal_connect_object (image, "disconnect",
G_CALLBACK (gtk_widget_destroy),
dialog->dialog, 0);
g_signal_connect (dialog->dialog, "delete-event",
G_CALLBACK (gtk_true),
NULL);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("All files (*.*)"));
gtk_file_filter_add_pattern (filter, "*");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog->dialog), filter);
filter = gtk_file_filter_new ();
gtk_file_filter_set_name (filter, _("Scalable SVG image (*.svg)"));
gtk_file_filter_add_pattern (filter, "*.[Ss][Vv][Gg]");
gtk_file_filter_add_mime_type (filter, "image/svg+xml");
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog->dialog), filter);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog->dialog), filter);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog->dialog), vbox);
gtk_widget_show (vbox);
button = gtk_check_button_new_with_mnemonic (_("_Merge imported paths"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
dialog->merge_vectors);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&dialog->merge_vectors);
button = gtk_check_button_new_with_mnemonic (_("_Scale imported paths "
"to fit image"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
dialog->scale_vectors);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect (button, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&dialog->scale_vectors);
return dialog;
}
static GtkWidget *
display_simple_dialog(gint type, gint btn_mask, char *message)
{
GtkWidget *win, *main_vb, *top_hb, *msg_vb, *type_pm, *msg_label, *ask_cb,
*bbox, *ok_bt, *yes_bt, *bt, *save_bt, *dont_save_bt;
/* Main window */
switch (type) {
case ESD_TYPE_WARN :
type_pm = gtk_image_new_from_stock( GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
break;
case ESD_TYPE_CONFIRMATION:
type_pm = gtk_image_new_from_stock( GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
break;
case ESD_TYPE_ERROR:
type_pm = gtk_image_new_from_stock( GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG);
break;
case ESD_TYPE_STOP :
type_pm = gtk_image_new_from_stock( GTK_STOCK_STOP, GTK_ICON_SIZE_DIALOG);
break;
case ESD_TYPE_INFO :
default :
type_pm = gtk_image_new_from_stock( GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG);
break;
}
/*
* The GNOME HIG:
*
* http://developer.gnome.org/projects/gup/hig/1.0/windows.html#alert-windows
*
* says that the title should be empty for alert boxes, so there's "less
* visual noise and confounding text."
*
* The Windows HIG:
*
* http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnwue/html/ch09f.asp
*
* says it should
*
* ...appropriately identify the source of the message -- usually
* the name of the object. For example, if the message results
* from editing a document, the title text is the name of the
* document, optionally followed by the application name. If the
* message results from a non-document object, then use the
* application name."
*
* and notes that the title is important "because message boxes might
* not always the the result of current user interaction" (e.g., some
* app might randomly pop something up, e.g. some browser letting you
* know that it couldn't fetch something because of a timeout).
*
* It also says not to use "warning" or "caution", as there's already
* an icon that tells you what type of alert it is, and that you
* shouldn't say "error", as that provides no useful information.
*
* So we give it a title on Win32, and don't give it one on UN*X.
* For now, we give it a Win32 title of just "Wireshark"; we should
* arguably take an argument for the title.
*/
if(btn_mask == ESD_BTN_NONE) {
win = splash_window_new();
} else {
#ifdef _WIN32
win = dlg_window_new("Wireshark");
#else
win = dlg_window_new("");
#endif
}
gtk_window_set_modal(GTK_WINDOW(win), TRUE);
gtk_container_set_border_width(GTK_CONTAINER(win), 6);
/* Container for our rows */
main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 12, FALSE);
gtk_container_add(GTK_CONTAINER(win), main_vb);
gtk_widget_show(main_vb);
/* Top row: Icon and message text */
top_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(main_vb), 6);
gtk_box_pack_start(GTK_BOX(main_vb), top_hb, TRUE, TRUE, 0);
gtk_widget_show(top_hb);
gtk_misc_set_alignment (GTK_MISC (type_pm), 0.5f, 0.0f);
gtk_box_pack_start(GTK_BOX(top_hb), type_pm, TRUE, TRUE, 0);
gtk_widget_show(type_pm);
/* column for message and optional check button */
msg_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
gtk_box_set_spacing(GTK_BOX(msg_vb), 24);
gtk_box_pack_start(GTK_BOX(top_hb), msg_vb, TRUE, TRUE, 0);
gtk_widget_show(msg_vb);
/* message */
msg_label = gtk_label_new(message);
gtk_label_set_markup(GTK_LABEL(msg_label), message);
gtk_label_set_selectable(GTK_LABEL(msg_label), TRUE);
g_object_set(gtk_widget_get_settings(msg_label),
"gtk-label-select-on-focus", FALSE, NULL);
gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_FILL);
gtk_misc_set_alignment (GTK_MISC (type_pm), 0.5f, 0.0f);
gtk_box_pack_start(GTK_BOX(msg_vb), msg_label, TRUE, TRUE, 0);
gtk_label_set_line_wrap(GTK_LABEL(msg_label), TRUE);
gtk_widget_show(msg_label);
if(btn_mask == ESD_BTN_NONE) {
gtk_widget_show(win);
return win;
}
/* optional check button */
ask_cb = gtk_check_button_new_with_label("replace with text...");
gtk_box_pack_start(GTK_BOX(msg_vb), ask_cb, TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(win), CHECK_BUTTON, ask_cb);
/* Button row */
switch(btn_mask) {
case(ESD_BTN_OK):
bbox = dlg_button_row_new(GTK_STOCK_OK, NULL);
break;
case(ESD_BTN_OK | ESD_BTN_CANCEL):
bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL);
break;
case(ESD_BTN_CLEAR | ESD_BTN_CANCEL):
bbox = dlg_button_row_new(GTK_STOCK_CLEAR, GTK_STOCK_CANCEL, NULL);
break;
case(ESD_BTNS_YES_NO_CANCEL):
bbox = dlg_button_row_new(GTK_STOCK_YES, GTK_STOCK_NO, GTK_STOCK_CANCEL, NULL);
break;
case(ESD_BTNS_SAVE_DONTSAVE):
bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_DONT_SAVE, NULL);
break;
case(ESD_BTNS_SAVE_DONTSAVE_CANCEL):
bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_DONT_SAVE, GTK_STOCK_CANCEL, NULL);
break;
case(ESD_BTNS_SAVE_QUIT_DONTSAVE_CANCEL):
bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_QUIT_DONT_SAVE, GTK_STOCK_CANCEL, NULL);
break;
case (ESD_BTNS_QUIT_DONTSAVE_CANCEL):
bbox = dlg_button_row_new(WIRESHARK_STOCK_QUIT_DONT_SAVE, GTK_STOCK_CANCEL, NULL);
break;
case(ESD_BTNS_YES_NO):
bbox = dlg_button_row_new(GTK_STOCK_YES, GTK_STOCK_NO, NULL);
break;
default:
g_assert_not_reached();
bbox = NULL;
break;
}
gtk_box_pack_start(GTK_BOX(main_vb), bbox, TRUE, TRUE, 0);
gtk_widget_show(bbox);
ok_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
if(ok_bt) {
g_object_set_data(G_OBJECT(ok_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_OK));
g_signal_connect(ok_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win);
}
save_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_SAVE);
if (save_bt) {
g_object_set_data(G_OBJECT(save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_SAVE));
g_signal_connect(save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win);
}
dont_save_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_DONT_SAVE);
if (dont_save_bt) {
g_object_set_data(G_OBJECT(dont_save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_DONT_SAVE));
g_signal_connect(dont_save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win);
}
dont_save_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_QUIT_DONT_SAVE);
if (dont_save_bt) {
g_object_set_data(G_OBJECT(dont_save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_QUIT_DONT_SAVE));
g_signal_connect(dont_save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win);
}
bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLEAR);
if(bt) {
g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_CLEAR));
g_signal_connect(bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win);
}
yes_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_YES);
if(yes_bt) {
g_object_set_data(G_OBJECT(yes_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_YES));
g_signal_connect(yes_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win);
}
bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_NO);
if(bt) {
g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_NO));
g_signal_connect(bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win);
}
bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
if(bt) {
g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_CANCEL));
window_set_cancel_button(win, bt, simple_dialog_cancel_cb);
}
if(!bt) {
if(yes_bt) {
window_set_cancel_button(win, yes_bt, simple_dialog_cancel_cb);
} else {
window_set_cancel_button(win, ok_bt, simple_dialog_cancel_cb);
}
}
dlg_button_focus_nth(bbox, 0);
gtk_widget_show(win);
return win;
}
int main(int argc, char* argv[])
{
int persistent = 0;
// wipe away any previous err file
unlink("/tmp/err");
char histFile[256];
sprintf(histFile, "/home/%s/.obrun_history", getenv("USER"));
// open history file
FILE* logFp = fopen(histFile, "r");
gtk_init(NULL, NULL);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL); // main window
combo = gtk_combo_new(); // editable box with dropdown menu
GList* histLines = NULL;
char line[356];
gchar* newLine = NULL;
int lc = 0;
// add in the history items, if the file was found
if (logFp != NULL)
{
while (fgets(line, sizeof(line), logFp) != NULL) // read a line
{
line[strlen(line)-1] = '\0'; // almighty null-terminator
newLine = g_strdup(line); // g_list_append apparently cant just be run in a loop
#if DEBUG
printf("Adding line (%s) to lines...\n", newLine);
#endif
histLines = g_list_prepend(histLines, newLine);
lc++;
}
histLines = g_list_prepend(histLines, ""); // empty to start with
if (histLines != NULL)
{
#if DEBUG
printf("%d histLines found\n", lc);
#endif
gtk_combo_set_popdown_strings(GTK_COMBO(combo), histLines);
g_list_free(histLines);
}
}
else
{
// just create it
#if DEBUG
printf("Creating new history file...\n");
#endif
logFp = fopen(histFile, "w");
}
g_free(newLine);
// we're done with this file for now
fclose(logFp);
// how do we want to sort?
sort_mode = "size";
if (argc > 1)
{
int ai;
for (ai=0; ai<argc; ai++)
{
if (strcmp(argv[ai], "-a") == 0)
{
sort_mode = "alpha";
}
if (strcmp(argv[ai], "-p") == 0)
{
persistent = 1;
}
}
}
gtk_window_set_title(GTK_WINDOW(window), "Run...");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_add(GTK_CONTAINER(window), combo);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_widget_set_size_request(GTK_COMBO(combo)->entry, 200, 20);
gtk_combo_disable_activate(GTK_COMBO(combo)); // don't show dropdown when enter
// listen for X button
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(die), NULL);
// listen for key up events: for typing
g_signal_connect(window, "key_release_event", G_CALLBACK(check_key_up), NULL);
// listen for key down events: for autocomplete, esc
g_signal_connect(window, "key_press_event", G_CALLBACK(check_key_down), NULL);
// listen for enter
g_signal_connect(GTK_OBJECT(GTK_COMBO(combo)->entry), "activate", G_CALLBACK(gtk_main_quit), NULL);
G_START:
gtk_widget_show_all(window);
gtk_main();
gchar *orig_str = g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry)));
gchar *exec_str = g_strdup_printf("%s 2> /tmp/err &", gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(combo)->entry)));
if (strcmp(orig_str, "(null)") == 0 || strcmp(orig_str, "") == 0) // user didnt enter anything
{
die();
}
g_printf("Executing %s...\n", exec_str);
int result = system(exec_str);
// before anything else, has this comand already been recorded?
int already_present = in_file(histFile, orig_str, 0);
if (!already_present)
{
// now lets check our error file for a bash error "command not found"
char not_found_str[256];
sprintf(not_found_str, "sh: %s: command not found", orig_str);
int not_found = in_file("/tmp/err", not_found_str, 1);
#if DEBUG
printf("already_present: %d\n", already_present);
printf("not_found: %d\n", not_found);
#endif
if (not_found)
{
char* err_msg = malloc((strlen(orig_str) + strlen(": Command not found!") + 1) * sizeof(char));
sprintf(err_msg, "%s: Command not found!", orig_str);
display_error_dialog(err_msg);
// wipe out the entry field
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(combo)->entry), "");
free(err_msg);
goto G_START; // don't exit, move back up to where widgets are shown
}
if (result == 0 && !already_present && !not_found)
{
FILE* logFp = fopen(histFile, "a");
if (logFp == NULL)
{
logFp = fopen(histFile, "w");
}
#if DEBUG
printf("Adding %s to historyFile...\n", orig_str);
#endif
fprintf(logFp, "%s\n", orig_str);
fclose(logFp);
}
}
#if DEBUG
printf("persistent: %d\n", persistent);
#endif
if (persistent == 1)
{
goto G_START;
}
g_free(orig_str);
g_free(exec_str);
g_list_free(matches);
die();
return 0;
}
/**
* Shows a dialog to edit the given connection (or create a new one,
* if conn is NULL)
*/
static void
edit_connection (gpointer *parent, StrongswanConnection *conn)
{
GtkWidget *dialog;
dialog = gtk_dialog_new_with_buttons (
conn ? "Edit Connection" : "New Connection",
GTK_WINDOW (parent),
GTK_DIALOG_MODAL | GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE,
GTK_RESPONSE_OK,
NULL);
GtkWidget *vbox = GTK_DIALOG (dialog)->vbox;
GtkSizeGroup *group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
GtkWidget *name = hildon_entry_new (HILDON_SIZE_AUTO);
hildon_gtk_entry_set_placeholder_text (GTK_ENTRY (name), "Connection Name");
hildon_gtk_entry_set_input_mode (GTK_ENTRY (name),
HILDON_GTK_INPUT_MODE_AUTOCAP |
HILDON_GTK_INPUT_MODE_ALPHA |
HILDON_GTK_INPUT_MODE_NUMERIC);
GtkWidget *ncap = hildon_caption_new (group,
"Name",
name,
NULL,
HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox), ncap, TRUE, TRUE, 0);
GtkWidget *host = hildon_entry_new (HILDON_SIZE_AUTO);
hildon_gtk_entry_set_placeholder_text (GTK_ENTRY (host), "Hostname / IP");
hildon_gtk_entry_set_input_mode (GTK_ENTRY (host),
HILDON_GTK_INPUT_MODE_FULL);
GtkWidget *hcap = hildon_caption_new (group,
"Host",
host,
NULL,
HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox), hcap, TRUE, TRUE, 0);
GtkWidget *cert = hildon_button_new (HILDON_SIZE_FINGER_HEIGHT |
HILDON_SIZE_AUTO_WIDTH,
HILDON_BUTTON_ARRANGEMENT_VERTICAL);
hildon_button_set_text (HILDON_BUTTON (cert),
"Host or CA Certificate",
"None");
hildon_button_set_alignment (HILDON_BUTTON (cert), 0, 0.5, 1, 1);
g_signal_connect (cert, "clicked", G_CALLBACK (select_cert), dialog);
GtkWidget *ccap = hildon_caption_new (group,
"Certificate",
cert,
NULL,
HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox), ccap, TRUE, TRUE, 0);
GtkWidget *user = hildon_entry_new (HILDON_SIZE_AUTO);
hildon_gtk_entry_set_placeholder_text (GTK_ENTRY (user), "Username");
hildon_gtk_entry_set_input_mode (GTK_ENTRY (user),
HILDON_GTK_INPUT_MODE_FULL);
GtkWidget *ucap = hildon_caption_new (group,
"Username",
user,
NULL,
HILDON_CAPTION_OPTIONAL);
gtk_box_pack_start (GTK_BOX (vbox), ucap, TRUE, TRUE, 0);
if (conn)
{
gchar *c_name, *c_host, *c_cert, *c_user;
g_object_get (conn,
"name", &c_name,
"host", &c_host,
"cert", &c_cert,
"user", &c_user,
NULL);
gtk_entry_set_text (GTK_ENTRY (name), c_name);
gtk_entry_set_text (GTK_ENTRY (host), c_host);
hildon_button_set_value (HILDON_BUTTON (cert),
c_cert ? c_cert : "None");
gtk_entry_set_text (GTK_ENTRY (user), c_user);
g_free (c_name);
g_free (c_host);
g_free (c_cert);
g_free (c_user);
}
gtk_widget_show_all (dialog);
gint retval = gtk_dialog_run (GTK_DIALOG (dialog));
if (retval == GTK_RESPONSE_OK)
{
const gchar *c_name, *c_cert;
c_name = gtk_entry_get_text (GTK_ENTRY (name));
if (!conn)
{
conn = strongswan_connection_new (c_name);
}
c_cert = hildon_button_get_value (HILDON_BUTTON (cert));
c_cert = strcmp (c_cert, "None") ? c_cert : NULL;
g_object_set (conn,
"name", c_name,
"host", gtk_entry_get_text (GTK_ENTRY (host)),
"cert", c_cert,
"user", gtk_entry_get_text (GTK_ENTRY (user)),
NULL);
strongswan_connections_save_connection (ListDialog.conns, conn);
}
gtk_widget_destroy (dialog);
}
static void
action_about_nautilus_callback (GtkAction *action,
gpointer user_data)
{
const gchar *authors[] = {
"Alexander Larsson",
"Ali Abdin",
"Anders Carlsson",
"Andy Hertzfeld",
"Arlo Rose",
"Darin Adler",
"David Camp",
"Eli Goldberg",
"Elliot Lee",
"Eskil Heyn Olsen",
"Ettore Perazzoli",
"Gene Z. Ragan",
"George Lebl",
"Ian McKellar",
"J Shane Culpepper",
"James Willcox",
"Jan Arne Petersen",
"John Harper",
"John Sullivan",
"Josh Barrow",
"Maciej Stachowiak",
"Mark McLoughlin",
"Mathieu Lacage",
"Mike Engber",
"Mike Fleming",
"Pavel Cisler",
"Ramiro Estrugo",
"Raph Levien",
"Rebecca Schulman",
"Robey Pointer",
"Robin * Slomkowski",
"Seth Nickell",
"Susan Kare",
NULL
};
const gchar *documenters[] = {
"GNOME Documentation Team",
"Sun Microsystem",
NULL
};
const gchar *license[] = {
N_("Nautilus is free software; you can redistribute it and/or modify "
"it under the terms of the GNU General Public License as published by "
"the Free Software Foundation; either version 2 of the License, or "
"(at your option) any later version."),
N_("Nautilus is distributed in the hope that it will be useful, "
"but WITHOUT ANY WARRANTY; without even the implied warranty of "
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
"GNU General Public License for more details."),
N_("You should have received a copy of the GNU General Public License "
"along with Nautilus; if not, write to the Free Software Foundation, Inc., "
"59 Temple Place, Suite 330, Boston, MA 02111-1307 USA")
};
gchar *license_trans;
license_trans = g_strjoin ("\n\n", _(license[0]), _(license[1]),
_(license[2]), NULL);
gtk_show_about_dialog (GTK_WINDOW (user_data),
#if GTK_CHECK_VERSION (2, 11, 0)
"program-name", _("Nautilus"),
#else
"name", _("Nautilus"),
#endif /* GTK 2.11. 0 */
"version", VERSION,
"comments", _("Nautilus is a graphical shell "
"for GNOME that makes it "
"easy to manage your files "
"and the rest of your system."),
"copyright", _("Copyright \xC2\xA9 1999-2007 "
"The Nautilus authors"),
"license", license_trans,
"wrap-license", TRUE,
"authors", authors,
"documenters", documenters,
/* Translators should localize the following string
* which will be displayed at the bottom of the about
* box to give credit to the translator(s).
*/
"translator-credits", _("translator-credits"),
"logo-icon-name", "nautilus",
"website", "http://www.gnome.org/projects/nautilus",
"website-label", _("Nautilus Web Site"),
NULL);
g_free (license_trans);
}
int dt_gui_hist_dialog_new(dt_gui_hist_dialog_t *d, int imgid, gboolean iscopy)
{
int res;
GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
GtkDialog *dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(
_("select parts"), GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, _("_cancel"),
GTK_RESPONSE_CANCEL, _("select _all"), GTK_RESPONSE_YES, _("select _none"), GTK_RESPONSE_NONE, _("_ok"),
GTK_RESPONSE_OK, NULL));
#ifdef GDK_WINDOWING_QUARTZ
dt_osx_disallow_fullscreen(GTK_WIDGET(dialog));
#endif
GtkContainer *content_area = GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
GtkBox *box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 3));
gtk_widget_set_margin_start(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_end(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_top(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_widget_set_margin_bottom(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(5));
gtk_container_add(content_area, GTK_WIDGET(box));
/* create the list of items */
d->items = GTK_TREE_VIEW(gtk_tree_view_new());
GtkListStore *liststore
= gtk_list_store_new(DT_HIST_ITEMS_NUM_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT);
/* enabled */
GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(renderer), TRUE);
g_object_set_data(G_OBJECT(renderer), "column", (gint *)DT_HIST_ITEMS_COL_ENABLED);
g_signal_connect(renderer, "toggled", G_CALLBACK(_gui_hist_item_toggled), d);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(d->items), -1, _("include"), renderer, "active",
DT_HIST_ITEMS_COL_ENABLED, NULL);
/* name */
renderer = gtk_cell_renderer_text_new();
g_object_set_data(G_OBJECT(renderer), "column", (gint *)DT_HIST_ITEMS_COL_NAME);
g_object_set(renderer, "xalign", 0.0, (gchar *)0);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(d->items), -1, _("item"), renderer, "text",
DT_HIST_ITEMS_COL_NAME, NULL);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->items)), GTK_SELECTION_SINGLE);
gtk_tree_view_set_model(GTK_TREE_VIEW(d->items), GTK_TREE_MODEL(liststore));
gtk_box_pack_start(box, GTK_WIDGET(d->items), TRUE, TRUE, 0);
/* fill list with history items */
GtkTreeIter iter;
GList *items = dt_history_get_items(imgid, FALSE);
if(items)
{
do
{
dt_history_item_t *item = (dt_history_item_t *)items->data;
gtk_list_store_append(GTK_LIST_STORE(liststore), &iter);
gtk_list_store_set(GTK_LIST_STORE(liststore), &iter, DT_HIST_ITEMS_COL_ENABLED,
iscopy ? TRUE : _gui_is_set(d->selops, item->num), DT_HIST_ITEMS_COL_NAME,
item->name, DT_HIST_ITEMS_COL_NUM, (guint)item->num, -1);
} while((items = g_list_next(items)));
g_list_free_full(items, dt_history_item_free);
}
else
{
dt_control_log(_("can't copy history out of unaltered image"));
return GTK_RESPONSE_CANCEL;
}
g_object_unref(liststore);
g_signal_connect(dialog, "response", G_CALLBACK(_gui_hist_copy_response), d);
gtk_widget_show_all(GTK_WIDGET(dialog));
while(1)
{
res = gtk_dialog_run(GTK_DIALOG(dialog));
if(res == GTK_RESPONSE_CANCEL || res == GTK_RESPONSE_DELETE_EVENT || res == GTK_RESPONSE_OK) break;
}
gtk_widget_destroy(GTK_WIDGET(dialog));
return res;
}
