GtkWidget *
reader_window_new(GtkApplication *application,
CainteoirSettings *settings,
CainteoirSpeechSynthesizers *synthesizers,
const gchar *filename)
{
ReaderWindow *reader = READER_WINDOW(g_object_new(READER_TYPE_WINDOW,
"application", application,
nullptr));
ReaderWindowPrivate *priv = READER_WINDOW_PRIVATE(reader);
priv->self = GTK_WIDGET(reader);
priv->settings = CAINTEOIR_SETTINGS(g_object_ref(G_OBJECT(settings)));
priv->tts = CAINTEOIR_SPEECH_SYNTHESIZERS(g_object_ref(G_OBJECT(synthesizers)));
priv->application = READER_APPLICATION(application);
gtk_window_set_default_size(GTK_WINDOW(reader), INDEX_PANE_WIDTH + DOCUMENT_PANE_WIDTH + 5, 300);
gtk_window_set_title(GTK_WINDOW(reader), i18n("Cainteoir Text-to-Speech"));
GtkWidget *layout = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(reader), layout);
priv->header = gtk_header_bar_new();
gtk_header_bar_set_title(GTK_HEADER_BAR(priv->header), i18n("Cainteoir Text-to-Speech"));
if (cainteoir_settings_get_boolean(priv->settings, "window", "have-csd", TRUE))
{
// Use client-side decorations (e.g. on Gnome Shell and Unity) ...
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(priv->header), TRUE);
gtk_window_set_titlebar(GTK_WINDOW(reader), priv->header);
}
else
{
// Don't use client-side decorations (e.g. on KDE) ...
gtk_box_pack_start(GTK_BOX(layout), priv->header, FALSE, FALSE, 0);
}
priv->actions = create_action_group(priv);
gtk_widget_insert_action_group(GTK_WIDGET(reader), "cainteoir", G_ACTION_GROUP(priv->actions));
priv->view = reader_document_view_new(priv->settings);
gtk_box_pack_start(GTK_BOX(layout), priv->view, TRUE, TRUE, 0);
reader_document_view_set_index_pane_close_action_name(READER_DOCUMENT_VIEW(priv->view), "cainteoir.side-pane");
GtkWidget *bottombar = gtk_toolbar_new();
gtk_widget_set_size_request(bottombar, -1, 45);
gtk_style_context_add_class(gtk_widget_get_style_context(bottombar), "bottombar");
gtk_box_pack_start(GTK_BOX(layout), bottombar, FALSE, FALSE, 0);
GtkToolItem *record = gtk_tool_button_new(gtk_image_new_from_icon_name("media-record-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR), nullptr);
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), record, -1);
gtk_actionable_set_action_name(GTK_ACTIONABLE(record), "cainteoir.record");
priv->play_stop = gtk_tool_button_new(nullptr, nullptr);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(priv->play_stop), "media-playback-start-symbolic");
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), priv->play_stop, -1);
gtk_actionable_set_action_name(GTK_ACTIONABLE(priv->play_stop), "cainteoir.play-stop");
GtkToolItem *open = gtk_tool_button_new(gtk_image_new_from_icon_name("document-open-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR), nullptr);
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), open, -1);
gtk_actionable_set_action_name(GTK_ACTIONABLE(open), "cainteoir.open");
GtkToolItem *timebar = gtk_tool_item_new();
gtk_tool_item_set_expand(GTK_TOOL_ITEM(timebar), TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), timebar, -1);
priv->timebar = cainteoir_timebar_new();
gtk_style_context_add_class(gtk_widget_get_style_context(priv->timebar), "timebar");
gtk_container_add(GTK_CONTAINER(timebar), priv->timebar);
priv->previous = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(priv->previous), gtk_image_new_from_icon_name("go-previous-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_header_bar_pack_start(GTK_HEADER_BAR(priv->header), priv->previous);
gtk_actionable_set_action_name(GTK_ACTIONABLE(priv->previous), "cainteoir.view-previous");
GtkWidget *menu_button = gtk_menu_button_new();
gtk_button_set_image(GTK_BUTTON(menu_button), gtk_image_new_from_icon_name(HAMBURGER_MENU_ICON, GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(menu_button), create_main_menu());
gtk_header_bar_pack_end(GTK_HEADER_BAR(priv->header), menu_button);
g_signal_connect(reader, "window-state-event", G_CALLBACK(on_window_state_changed), priv->settings);
g_signal_connect(reader, "delete_event", G_CALLBACK(on_window_delete), priv);
g_signal_connect(reader, "show", G_CALLBACK(on_window_show), priv);
g_signal_connect(priv->tts, "speaking", G_CALLBACK(on_speaking), priv);
g_signal_connect(priv->tts, "text-range-changed", G_CALLBACK(on_text_range_changed), priv);
gtk_window_resize(GTK_WINDOW(reader),
cainteoir_settings_get_integer(priv->settings, "window", "width", 700),
cainteoir_settings_get_integer(priv->settings, "window", "height", 445));
gtk_window_move(GTK_WINDOW(reader),
cainteoir_settings_get_integer(priv->settings, "window", "left", 0),
cainteoir_settings_get_integer(priv->settings, "window", "top", 0));
if (cainteoir_settings_get_boolean(priv->settings, "window", "maximized", FALSE))
gtk_window_maximize(GTK_WINDOW(reader));
if (filename)
reader_window_load_document(reader, filename);
else
{
gchar *prev_filename = cainteoir_settings_get_string(priv->settings, "document", "filename", nullptr);
if (prev_filename)
{
reader_window_load_document(reader, prev_filename);
g_free(prev_filename);
}
}
gchar *anchor = cainteoir_settings_get_string(priv->settings, "highlight", "anchor", "none");
if (anchor)
{
if (!strcmp(anchor, "top"))
reader_window_set_highlight_anchor(reader, GTK_ALIGN_START);
else if (!strcmp(anchor, "middle"))
reader_window_set_highlight_anchor(reader, GTK_ALIGN_CENTER);
else if (!strcmp(anchor, "bottom"))
reader_window_set_highlight_anchor(reader, GTK_ALIGN_END);
g_free(anchor);
}
return GTK_WIDGET(reader);
}
int main(int argc, char *argv[])
{
setbuf(stdout, NULL);
setbuf(stderr, NULL);
setlocale(LC_ALL, "");
char* domain = textdomain(PACKAGE_NAME);
assert(domain != NULL);
bind_textdomain_codeset(PACKAGE_NAME, "UTF-8");
textdomain(PACKAGE_NAME);
gint update_rate = 100;
gint cell_size = 4;
gboolean print_version = FALSE;
GOptionEntry cmd_options[] = {
{"update-rate", 'u', 0, G_OPTION_ARG_INT, &update_rate, _C("Update rate in msec"), "100"},
{"cell_size", 'c', 0, G_OPTION_ARG_INT, &cell_size, _C("Cell size"), "8"},
{"version", 'v', 0, G_OPTION_ARG_NONE, &print_version, _C("Print version"), NULL},
{NULL}
};
GError *error = NULL;
GOptionContext *cmd_context = g_option_context_new(NULL);
g_option_context_set_help_enabled(cmd_context, TRUE);
g_option_context_add_main_entries(cmd_context, cmd_options, NULL);
gchar **cmd_line = g_strdupv(argv);
gint cmd_count = argc;
if(g_option_context_parse(cmd_context, &cmd_count, &cmd_line, &error) == FALSE)
{
fprintf(stderr, _C("ERROR: %s\n\n"), error->message);
g_error_free(error);
}
else
{
if(print_version == TRUE)
{
printf("game-life: %s\n", PACKAGE_VERSION);
}
else
{
gtk_init(&argc, &argv);
GdkScreen* default_screen = gdk_screen_get_default();
gint screen_height = gdk_screen_get_height(default_screen);
gint screen_width = gdk_screen_get_width(default_screen);
size_t world_height = screen_height / (cell_size +1);
size_t world_width = screen_width / (cell_size +1);
game_universe_t* universe = NULL;
game_init_universe(&universe, world_width, world_height, cell_size);
game_set_random(universe);
GtkWidget* main_wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GdkWindow* root_wnd = gdk_screen_get_root_window(default_screen);
gtk_widget_set_window(main_wnd, root_wnd);
//gtk_window_fullscreen(GTK_WINDOW(main_wnd));
gtk_widget_set_app_paintable(main_wnd, TRUE);
g_signal_connect(main_wnd, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(main_wnd, "event", G_CALLBACK(event_cb), NULL);
g_signal_connect(main_wnd, "draw", G_CALLBACK(draw_cb), universe);
const char* remote_wnd_env = getenv("XSCREENSAVER_WINDOW");
if(remote_wnd_env != NULL) // FIXME what is this shit? i dont know
{
char* end = NULL;
Window remote_wnd = (Window)strtol(remote_wnd_env, &end, 0);
GdkDisplay* default_display = gdk_display_get_default();
GdkWindow* window = gdk_x11_window_foreign_new_for_display(default_display, remote_wnd);
//GtkStyle* main_wnd_style = gtk_widget_get_style(main_wnd);
//gtk_style_set_background(main_wnd_style, window, GTK_STATE_NORMAL);
gtk_widget_set_window(main_wnd, window);
gtk_widget_set_realized(main_wnd, TRUE);
gtk_window_resize(GTK_WINDOW(main_wnd), screen_width, screen_height);
}
gtk_widget_show_all(main_wnd);
g_timeout_add(update_rate, update_image, main_wnd);
gtk_main();
}
}
g_option_context_free(cmd_context);
g_strfreev(cmd_line);
return 0;
}
GtkWidget*
CreateHelpWindow (void)
{
GtkWidget *main_vbox;
GtkWidget *main_view_scroller;
GtkWidget *contents_view_scroller;
GtkWidget *content_hpane;
int width;
int height;
int x, y;
int w = 0, h = 0;
const char *pref;
char title[100];
wHelpWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
width = gdk_screen_get_width( gtk_window_get_screen( (GtkWindow *)wHelpWindow ));
height = gdk_screen_get_height( gtk_window_get_screen( (GtkWindow *)wHelpWindow ));
pref = wPrefGetString( HTMLHELPSECTION, WINDOWSIZEPREFNAME );
if( pref ) {
sscanf( pref, "%d %d", &w, &h );
if( w > width )
w = width;
if( h > height )
h = height;
}
else {
w = ( width * 2 )/ 5;
h = height - 100;
}
pref = wPrefGetString( HTMLHELPSECTION, WINDOWPOSPREFNAME );
if( pref ) {
sscanf( pref, "%d %d", &x, &y );
if( y > height - h )
y = height - h;
if( x > width - w )
x = width - w;
}
else {
x = ( width * 3 ) / 5 - 10;
y = 70;
}
gtk_window_resize( (GtkWindow *)wHelpWindow, w, h );
gtk_window_move( (GtkWindow *)wHelpWindow, x, y );
gtk_window_set_title (GTK_WINDOW (wHelpWindow), "XTrkCad Help");
g_signal_connect( G_OBJECT( wHelpWindow ), "delete-event", G_CALLBACK( DestroyHelpWindow ), NULL );
main_view_scroller = gtk_scrolled_window_new(NULL, NULL);
contents_view_scroller = gtk_scrolled_window_new(NULL, NULL);
main_view = webkit_web_view_new();
contents_view = webkit_web_view_new();
// must be done here as it gets locked down later
load_into_view ("contents.html", CONTENTS_VIEW);
gtk_widget_set_size_request(GTK_WIDGET(wHelpWindow), x, y);
main_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER(wHelpWindow), main_vbox);
gtk_container_add(GTK_CONTAINER(main_view_scroller), main_view);
gtk_container_add(GTK_CONTAINER(contents_view_scroller), contents_view);
content_hpane = gtk_hpaned_new();
initialize_buttons(main_vbox, content_hpane);
gtk_container_add(GTK_CONTAINER(content_hpane), contents_view_scroller);
gtk_container_add(GTK_CONTAINER(content_hpane), main_view_scroller);
gtk_box_pack_start(GTK_BOX(main_vbox), content_hpane, TRUE, TRUE, 0);
gtk_paned_set_position(GTK_PANED(content_hpane), 370);
g_signal_connect(contents_view, "navigation-policy-decision-requested", G_CALLBACK(contents_click_handler), G_OBJECT(main_view));
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (wHelpWindow, wHelpWindow, "wHelpWindow");
GLADE_HOOKUP_OBJECT (wHelpWindow, content_hpane, PANED );
GLADE_HOOKUP_OBJECT (wHelpWindow, contents_view, TOCVIEW );
GLADE_HOOKUP_OBJECT (wHelpWindow, main_view, CONTENTSVIEW );
return wHelpWindow;
}
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;
GMenuItem *item;
label = g_strdup_printf ("Item _%d", i);
item = g_menu_item_new (label, NULL);
if (i == 3)
g_menu_item_set_attribute (item, "icon", "s", "preferences-desktop-locale-symbolic");
g_menu_insert_item (menu, i - 1, item);
g_object_unref (item);
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;
}
static void minimize_win_anthy()
{
if (!win_anthy)
return;
gtk_window_resize(GTK_WINDOW(win_anthy), 32, 12);
}
void PlatformWebView::resizeTo(unsigned width, unsigned height)
{
gtk_window_resize(GTK_WINDOW(m_window), width, height);
}
static GObject * main_window_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) {
GObject * obj;
GObjectClass * parent_class;
MainWindow * self;
GdkEventMask _tmp0_;
GdkEventMask _tmp1_;
GtkAccelGroup* _tmp2_;
GtkAccelGroup* accel_group;
GtkAccelGroup* _tmp3_;
GdkRGBA bg_color = {0};
gchar* _tmp4_ = NULL;
gchar* _tmp5_;
GdkRGBA _tmp6_;
AtkObject* _tmp7_ = NULL;
const gchar* _tmp8_ = NULL;
GdkWindow* _tmp9_ = NULL;
cairo_t* _tmp10_ = NULL;
cairo_t* _tmp11_;
cairo_surface_t* _tmp12_ = NULL;
Background* _tmp13_;
Background* _tmp14_;
gboolean _tmp15_ = FALSE;
Background* _tmp16_;
gchar* _tmp17_ = NULL;
gchar* _tmp18_;
Background* _tmp19_;
gchar* _tmp20_ = NULL;
gchar* _tmp21_;
gchar* _tmp22_ = NULL;
gchar* _tmp23_;
Background* _tmp24_;
Background* _tmp25_;
Background* _tmp26_;
GtkBox* _tmp27_;
GtkBox* _tmp28_;
Background* _tmp29_;
GtkBox* _tmp30_;
GtkEventBox* _tmp31_;
GtkEventBox* menubox;
GtkAlignment* _tmp32_;
GtkAlignment* menualign;
gchar* _tmp33_ = NULL;
gchar* shadow_path;
gchar* _tmp34_;
gchar* shadow_style;
const gchar* _tmp35_;
gboolean _tmp36_ = FALSE;
GtkEventBox* _tmp51_;
GtkEventBox* _tmp52_;
GtkAlignment* _tmp53_;
GtkEventBox* _tmp54_;
GtkAlignment* _tmp55_;
GtkBox* _tmp56_;
GtkEventBox* _tmp57_;
GtkAlignment* _tmp58_;
GtkEventBox* _tmp59_;
Background* _tmp60_;
GtkAccelGroup* _tmp61_;
MenuBar* _tmp62_;
MenuBar* _tmp63_;
GtkAlignment* _tmp64_;
MenuBar* _tmp65_;
MenuBar* _tmp66_;
GtkBox* _tmp67_;
GtkBox* _tmp68_;
GtkBox* _tmp69_;
GtkBox* _tmp70_;
GtkBox* _tmp71_;
GtkAlignment* _tmp72_;
GtkAlignment* align;
GtkAlignment* _tmp73_;
GtkAlignment* _tmp74_;
GtkAlignment* _tmp75_;
GtkBox* _tmp76_;
GtkAlignment* _tmp77_;
FlatButton* _tmp78_;
GtkButton* _tmp79_;
gchar* _tmp80_ = NULL;
gchar* _tmp81_;
GtkImage* _tmp82_;
GtkImage* _tmp83_;
GtkImage* image;
GtkImage* _tmp84_;
GtkButton* _tmp85_;
GtkButton* _tmp86_;
GtkImage* _tmp87_;
GtkButton* _tmp88_;
GtkAlignment* _tmp89_;
GtkButton* _tmp90_;
GtkAlignment* _tmp91_;
GtkAlignment* _tmp92_;
GtkBox* _tmp93_;
GtkAlignment* _tmp94_;
ListStack* _tmp95_;
ListStack* _tmp96_;
GtkAlignment* _tmp97_;
ListStack* _tmp98_;
UnityGreeter* _tmp99_;
gboolean _tmp100_;
GError * _inner_error_ = NULL;
parent_class = G_OBJECT_CLASS (main_window_parent_class);
obj = parent_class->constructor (type, n_construct_properties, construct_properties);
self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_MAIN_WINDOW, MainWindow);
_tmp0_ = gtk_widget_get_events ((GtkWidget*) self);
_tmp1_ = _tmp0_;
gtk_widget_set_events ((GtkWidget*) self, _tmp1_ | GDK_POINTER_MOTION_MASK);
_tmp2_ = gtk_accel_group_new ();
accel_group = _tmp2_;
_tmp3_ = accel_group;
gtk_window_add_accel_group ((GtkWindow*) self, _tmp3_);
memset (&bg_color, 0, sizeof (GdkRGBA));
_tmp4_ = ug_settings_get_string (UG_SETTINGS_KEY_BACKGROUND_COLOR);
_tmp5_ = _tmp4_;
gdk_rgba_parse (&bg_color, _tmp5_);
_g_free0 (_tmp5_);
_tmp6_ = bg_color;
gtk_widget_override_background_color ((GtkWidget*) self, GTK_STATE_FLAG_NORMAL, &_tmp6_);
_tmp7_ = gtk_widget_get_accessible ((GtkWidget*) self);
_tmp8_ = _ ("Login Screen");
atk_object_set_name (_tmp7_, _tmp8_);
gtk_window_set_has_resize_grip ((GtkWindow*) self, FALSE);
unity_greeter_add_style_class ((GtkWidget*) self);
gtk_widget_realize ((GtkWidget*) self);
_tmp9_ = gtk_widget_get_window ((GtkWidget*) self);
_tmp10_ = gdk_cairo_create (_tmp9_);
_tmp11_ = _tmp10_;
_tmp12_ = cairo_get_target (_tmp11_);
_tmp13_ = background_new (_tmp12_);
g_object_ref_sink (_tmp13_);
_g_object_unref0 (self->priv->background);
self->priv->background = _tmp13_;
_cairo_destroy0 (_tmp11_);
_tmp14_ = self->priv->background;
_tmp15_ = ug_settings_get_boolean (UG_SETTINGS_KEY_DRAW_GRID);
background_set_draw_grid (_tmp14_, _tmp15_);
_tmp16_ = self->priv->background;
_tmp17_ = ug_settings_get_string (UG_SETTINGS_KEY_BACKGROUND);
_tmp18_ = _tmp17_;
background_set_default_background (_tmp16_, _tmp18_);
_g_free0 (_tmp18_);
_tmp19_ = self->priv->background;
_tmp20_ = ug_settings_get_string (UG_SETTINGS_KEY_LOGO);
_tmp21_ = _tmp20_;
_tmp22_ = ug_settings_get_string (UG_SETTINGS_KEY_BACKGROUND_LOGO);
_tmp23_ = _tmp22_;
background_set_logo (_tmp19_, _tmp21_, _tmp23_);
_g_free0 (_tmp23_);
_g_free0 (_tmp21_);
_tmp24_ = self->priv->background;
gtk_widget_show ((GtkWidget*) _tmp24_);
_tmp25_ = self->priv->background;
gtk_container_add ((GtkContainer*) self, (GtkWidget*) _tmp25_);
_tmp26_ = self->priv->background;
unity_greeter_add_style_class ((GtkWidget*) _tmp26_);
_tmp27_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
g_object_ref_sink (_tmp27_);
_g_object_unref0 (self->priv->login_box);
self->priv->login_box = _tmp27_;
_tmp28_ = self->priv->login_box;
gtk_widget_show ((GtkWidget*) _tmp28_);
_tmp29_ = self->priv->background;
_tmp30_ = self->priv->login_box;
gtk_container_add ((GtkContainer*) _tmp29_, (GtkWidget*) _tmp30_);
_tmp31_ = (GtkEventBox*) gtk_event_box_new ();
g_object_ref_sink (_tmp31_);
menubox = _tmp31_;
_tmp32_ = (GtkAlignment*) gtk_alignment_new (0.0f, 0.0f, 1.0f, 0.0f);
g_object_ref_sink (_tmp32_);
menualign = _tmp32_;
_tmp33_ = g_build_filename (PKGDATADIR, "shadow.png", NULL, NULL);
shadow_path = _tmp33_;
_tmp34_ = g_strdup ("");
shadow_style = _tmp34_;
_tmp35_ = shadow_path;
_tmp36_ = g_file_test (_tmp35_, G_FILE_TEST_EXISTS);
if (_tmp36_) {
const gchar* _tmp37_;
gchar* _tmp38_ = NULL;
_tmp37_ = shadow_path;
_tmp38_ = g_strdup_printf ("background-image: url('%s');\n" \
" background-repeat: repeat;", _tmp37_);
_g_free0 (shadow_style);
shadow_style = _tmp38_;
}
{
GtkCssProvider* _tmp39_;
GtkCssProvider* style;
GtkCssProvider* _tmp40_;
const gchar* _tmp41_;
gchar* _tmp42_ = NULL;
gchar* _tmp43_;
GtkEventBox* _tmp44_;
GtkStyleContext* _tmp45_ = NULL;
GtkStyleContext* _tmp46_;
GtkStyleContext* context;
GtkStyleContext* _tmp47_;
GtkCssProvider* _tmp48_;
_tmp39_ = gtk_css_provider_new ();
style = _tmp39_;
_tmp40_ = style;
_tmp41_ = shadow_style;
_tmp42_ = g_strdup_printf ("* {background-color: transparent;\n" \
" %s\n" \
" }", _tmp41_);
_tmp43_ = _tmp42_;
gtk_css_provider_load_from_data (_tmp40_, _tmp43_, (gssize) (-1), &_inner_error_);
_g_free0 (_tmp43_);
if (_inner_error_ != NULL) {
_g_object_unref0 (style);
goto __catch11_g_error;
}
_tmp44_ = menubox;
_tmp45_ = gtk_widget_get_style_context ((GtkWidget*) _tmp44_);
_tmp46_ = _g_object_ref0 (_tmp45_);
context = _tmp46_;
_tmp47_ = context;
_tmp48_ = style;
gtk_style_context_add_provider (_tmp47_, (GtkStyleProvider*) _tmp48_, (guint) GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
_g_object_unref0 (context);
_g_object_unref0 (style);
}
goto __finally11;
__catch11_g_error:
{
GError* e = NULL;
GError* _tmp49_;
const gchar* _tmp50_;
e = _inner_error_;
_inner_error_ = NULL;
_tmp49_ = e;
_tmp50_ = _tmp49_->message;
g_debug ("main-window.vala:87: Internal error loading menubox style: %s", _tmp50_);
_g_error_free0 (e);
}
__finally11:
if (_inner_error_ != NULL) {
_g_free0 (shadow_style);
_g_free0 (shadow_path);
_g_object_unref0 (menualign);
_g_object_unref0 (menubox);
_g_object_unref0 (accel_group);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
}
_tmp51_ = menubox;
gtk_widget_set_size_request ((GtkWidget*) _tmp51_, -1, MAIN_WINDOW_MENUBAR_HEIGHT);
_tmp52_ = menubox;
gtk_widget_show ((GtkWidget*) _tmp52_);
_tmp53_ = menualign;
gtk_widget_show ((GtkWidget*) _tmp53_);
_tmp54_ = menubox;
_tmp55_ = menualign;
gtk_container_add ((GtkContainer*) _tmp54_, (GtkWidget*) _tmp55_);
_tmp56_ = self->priv->login_box;
_tmp57_ = menubox;
gtk_container_add ((GtkContainer*) _tmp56_, (GtkWidget*) _tmp57_);
_tmp58_ = menualign;
unity_greeter_add_style_class ((GtkWidget*) _tmp58_);
_tmp59_ = menubox;
unity_greeter_add_style_class ((GtkWidget*) _tmp59_);
_tmp60_ = self->priv->background;
_tmp61_ = accel_group;
_tmp62_ = menu_bar_new (_tmp60_, _tmp61_);
g_object_ref_sink (_tmp62_);
_g_object_unref0 (self->menubar);
self->menubar = _tmp62_;
_tmp63_ = self->menubar;
gtk_widget_show ((GtkWidget*) _tmp63_);
_tmp64_ = menualign;
_tmp65_ = self->menubar;
gtk_container_add ((GtkContainer*) _tmp64_, (GtkWidget*) _tmp65_);
_tmp66_ = self->menubar;
unity_greeter_add_style_class ((GtkWidget*) _tmp66_);
_tmp67_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
g_object_ref_sink (_tmp67_);
_g_object_unref0 (self->priv->hbox);
self->priv->hbox = _tmp67_;
_tmp68_ = self->priv->hbox;
g_object_set ((GtkWidget*) _tmp68_, "expand", TRUE, NULL);
_tmp69_ = self->priv->hbox;
gtk_widget_show ((GtkWidget*) _tmp69_);
_tmp70_ = self->priv->login_box;
_tmp71_ = self->priv->hbox;
gtk_container_add ((GtkContainer*) _tmp70_, (GtkWidget*) _tmp71_);
_tmp72_ = (GtkAlignment*) gtk_alignment_new (0.5f, 0.5f, 0.0f, 0.0f);
g_object_ref_sink (_tmp72_);
align = _tmp72_;
_tmp73_ = align;
gtk_widget_set_size_request ((GtkWidget*) _tmp73_, grid_size, -1);
_tmp74_ = align;
gtk_widget_set_margin_bottom ((GtkWidget*) _tmp74_, MAIN_WINDOW_MENUBAR_HEIGHT);
_tmp75_ = align;
gtk_widget_show ((GtkWidget*) _tmp75_);
_tmp76_ = self->priv->hbox;
_tmp77_ = align;
gtk_container_add ((GtkContainer*) _tmp76_, (GtkWidget*) _tmp77_);
_tmp78_ = flat_button_new ();
g_object_ref_sink (_tmp78_);
_g_object_unref0 (self->priv->back_button);
self->priv->back_button = (GtkButton*) _tmp78_;
_tmp79_ = self->priv->back_button;
gtk_button_set_focus_on_click (_tmp79_, FALSE);
_tmp80_ = g_build_filename (PKGDATADIR, "arrow_left.png", NULL, NULL);
_tmp81_ = _tmp80_;
_tmp82_ = (GtkImage*) gtk_image_new_from_file (_tmp81_);
g_object_ref_sink (_tmp82_);
_tmp83_ = _tmp82_;
_g_free0 (_tmp81_);
image = _tmp83_;
_tmp84_ = image;
gtk_widget_show ((GtkWidget*) _tmp84_);
_tmp85_ = self->priv->back_button;
gtk_widget_set_size_request ((GtkWidget*) _tmp85_, grid_size - (GREETER_LIST_BORDER * 2), grid_size - (GREETER_LIST_BORDER * 2));
_tmp86_ = self->priv->back_button;
_tmp87_ = image;
gtk_container_add ((GtkContainer*) _tmp86_, (GtkWidget*) _tmp87_);
_tmp88_ = self->priv->back_button;
g_signal_connect_object (_tmp88_, "clicked", (GCallback) _main_window_pop_list_gtk_button_clicked, self, 0);
_tmp89_ = align;
_tmp90_ = self->priv->back_button;
gtk_container_add ((GtkContainer*) _tmp89_, (GtkWidget*) _tmp90_);
_tmp91_ = (GtkAlignment*) gtk_alignment_new (0.0f, 0.5f, 0.0f, 1.0f);
g_object_ref_sink (_tmp91_);
_g_object_unref0 (align);
align = _tmp91_;
_tmp92_ = align;
gtk_widget_show ((GtkWidget*) _tmp92_);
_tmp93_ = self->priv->hbox;
_tmp94_ = align;
gtk_container_add ((GtkContainer*) _tmp93_, (GtkWidget*) _tmp94_);
_tmp95_ = list_stack_new ();
g_object_ref_sink (_tmp95_);
_g_object_unref0 (self->stack);
self->stack = _tmp95_;
_tmp96_ = self->stack;
gtk_widget_show ((GtkWidget*) _tmp96_);
_tmp97_ = align;
_tmp98_ = self->stack;
gtk_container_add ((GtkContainer*) _tmp97_, (GtkWidget*) _tmp98_);
main_window_add_user_list (self);
_tmp99_ = unity_greeter_singleton;
_tmp100_ = _tmp99_->test_mode;
if (_tmp100_) {
Monitor* _tmp101_;
Monitor* _tmp102_;
Background* _tmp103_;
GList* _tmp104_;
GList* _tmp105_;
gconstpointer _tmp106_ = NULL;
__g_list_free__monitor_unref0_0 (self->priv->monitors);
self->priv->monitors = NULL;
_tmp101_ = monitor_new (0, 0, 800, 600);
self->priv->monitors = g_list_append (self->priv->monitors, _tmp101_);
_tmp102_ = monitor_new (800, 120, 640, 480);
self->priv->monitors = g_list_append (self->priv->monitors, _tmp102_);
_tmp103_ = self->priv->background;
_tmp104_ = self->priv->monitors;
background_set_monitors (_tmp103_, _tmp104_);
_tmp105_ = self->priv->monitors;
_tmp106_ = g_list_nth_data (_tmp105_, (guint) 0);
main_window_move_to_monitor (self, (Monitor*) _tmp106_);
gtk_window_resize ((GtkWindow*) self, 800 + 640, 600);
} else {
GdkScreen* _tmp107_ = NULL;
GdkScreen* _tmp108_;
GdkScreen* screen;
GdkScreen* _tmp109_;
GdkScreen* _tmp110_;
_tmp107_ = gtk_window_get_screen ((GtkWindow*) self);
_tmp108_ = _g_object_ref0 (_tmp107_);
screen = _tmp108_;
_tmp109_ = screen;
g_signal_connect_object (_tmp109_, "monitors-changed", (GCallback) _main_window_monitors_changed_cb_gdk_screen_monitors_changed, self, 0);
_tmp110_ = screen;
main_window_monitors_changed_cb (self, _tmp110_);
_g_object_unref0 (screen);
}
_g_object_unref0 (image);
_g_object_unref0 (align);
_g_free0 (shadow_style);
_g_free0 (shadow_path);
_g_object_unref0 (menualign);
_g_object_unref0 (menubox);
_g_object_unref0 (accel_group);
return obj;
}
int main(int argc, char ** argv)
{
GtkWidget * vbox;
GtkWidget * hpaned;
GtkWidget * sc_win, * sc_buffer;
GtkWidget * menu_bar;
GtkWidget * file_menu, * file_item, * open_item, * save_item, * quit_item, * exp_img_item, * save_raw_data_item;
GtkWidget * generate_menu, * generate_item, * mandelbrot_item, * julia_item, * palette_item, * random_noise_item, * from_clipboard_item;
GtkWidget * settings_menu, * settings_item;
GtkWidget * zoom_box, * zoom_button;
//init general
colors = (color_t *)malloc(56 * sizeof(color_t));
memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *));
memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *));
memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *));
mdata[current_buffer] = (unsigned char *)malloc(128 * 128);
char * templine = malloc(13);
FILE * fcolors = fopen("colors", "r");
int i, r, g, b;
for(i = 0; fgets(templine, 13, fcolors) == templine; i++)
{
sscanf(templine, "%i,%i,%i", &r, &g, &b);
color_t color = {r, g, b};
colors[i] = color;
}
free(templine);
fclose(fcolors);
save_colors(colors, "colors.bin");
//load_colors(colors, "colors.bin");
srand(time(NULL));
config = config_new();
//init gtk
gtk_init(&argc, &argv);
//window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER);
g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL);
//vbox
#ifdef GTK2
vbox = gtk_vbox_new(FALSE, 0);
#else
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
gtk_container_add(GTK_CONTAINER (window), vbox);
gtk_widget_show(vbox);
//////menu_bar
menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0);
gtk_widget_show(menu_bar);
////////file_menu
file_menu = gtk_menu_new();
//////////open_item
open_item = gtk_menu_item_new_with_label("Open");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), open_item);
gtk_widget_show(open_item);
g_signal_connect_swapped (open_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.open");
//////////save_item
save_item = gtk_menu_item_new_with_label("Save");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_item);
gtk_widget_show(save_item);
g_signal_connect_swapped (save_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.save");
//////////save_raw_data_item
save_raw_data_item = gtk_menu_item_new_with_label("Save Raw Map");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_raw_data_item);
gtk_widget_show(save_raw_data_item);
g_signal_connect_swapped (save_raw_data_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.save_rm");
//////////exp_img_item
exp_img_item = gtk_menu_item_new_with_label("Export Image");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), exp_img_item);
gtk_widget_show(exp_img_item);
g_signal_connect_swapped(exp_img_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.exp_img");
//////////quit_item
quit_item = gtk_menu_item_new_with_label("Quit");
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), quit_item);
gtk_widget_show(quit_item);
g_signal_connect_swapped (quit_item, "activate",
G_CALLBACK(kill_window),
(gpointer)"button.quit");
/////////file_item
file_item = gtk_menu_item_new_with_label("File");
gtk_widget_show(file_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item);
////////generate_menu
generate_menu = gtk_menu_new();
//////////mandelbrot_item
mandelbrot_item = gtk_menu_item_new_with_label("Mandelbrot");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), mandelbrot_item);
gtk_widget_show(mandelbrot_item);
g_signal_connect_swapped(mandelbrot_item, "activate",
G_CALLBACK(button_click),
(gpointer) "button.mandelbrot");
//////////julia_item
julia_item = gtk_menu_item_new_with_label("Julia");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), julia_item);
gtk_widget_show(julia_item);
g_signal_connect_swapped(julia_item, "activate",
G_CALLBACK (button_click),
(gpointer) "button.julia");
//////////palette_item
palette_item = gtk_menu_item_new_with_label("Palette");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), palette_item);
gtk_widget_show(palette_item);
g_signal_connect_swapped(palette_item, "activate",
G_CALLBACK(button_click),
(gpointer)"button.palette");
//////////random_noise_item
random_noise_item = gtk_menu_item_new_with_label("Random Noise");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), random_noise_item);
gtk_widget_show(random_noise_item);
g_signal_connect_swapped(random_noise_item, "activate",
G_CALLBACK(button_click),
(gpointer)"button.random_noise");
//////////from_clipboard_item
from_clipboard_item = gtk_menu_item_new_with_label("From Clipboard");
gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), from_clipboard_item);
gtk_widget_show(from_clipboard_item);
g_signal_connect_swapped(from_clipboard_item, "activate",
G_CALLBACK(button_click),
(gpointer)"button.from_clipboard");
/////////generate_item
generate_item = gtk_menu_item_new_with_label("Generate");
gtk_widget_show(generate_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item);
////////settings_menu
settings_menu = gtk_menu_new();
////////settings_item
settings_item = gtk_menu_item_new_with_label("Settings");
gtk_widget_show(settings_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item);
//////////FSD_checkbox
FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering");
gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox);
gtk_widget_show(FSD_checkbox);
//drop_down_menu
init_drop_down_menu();
//hpaned
#ifdef GTK2
hpaned = gtk_hpaned_new();
#else
hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
#endif
gtk_widget_set_size_request (hpaned, 220, -1);
gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show(hpaned);
////sc_buffer
sc_buffer = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
gtk_widget_set_size_request(sc_buffer, 128 + 32, 512);
#else
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512);
#endif
gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE);
gtk_widget_show(sc_buffer);
//////list_vbox
#ifdef GTK2
list_vbox = gtk_vbox_new(FALSE, 0);
#else
list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox);
gtk_widget_show(list_vbox);
////sc_win
sc_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4);
gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70);
#else
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
#endif
gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE);
gtk_widget_show(sc_win);
//////image
dimage = gdk_pixbuf_new_from_file("start.png", NULL);
image = gtk_image_new();
gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image);
gtk_widget_show(image);
////zoom_box
#ifdef GTK2
zoom_box = gtk_hbox_new(FALSE, 0);
#else
zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0);
gtk_widget_show(zoom_box);
//////zoom_button (+)
zoom_button = gtk_button_new_with_label("+");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp");
gtk_widget_show(zoom_button);
//////zoom_button (|)
zoom_button = gtk_button_new_with_label("|");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome");
gtk_widget_show(zoom_button);
//////zoom_button (-)
zoom_button = gtk_button_new_with_label("-");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm");
gtk_widget_show(zoom_button);
//icon
gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico"));
//display window
gtk_widget_show (window);
gtk_main();
//clean up
free(colors);
for(i = 0; i < BUFFER_COUNT; i++)
free(mdata[i]);
config_free(config);
return 0;
}
static void
popup_menu_show_layout ()
{
static GkbdKeyboardDrawingGroupLevel groupsLevels[] = { {
0, 1}, {
0,
3},
{
0, 0}, {
0, 2}
};
static GkbdKeyboardDrawingGroupLevel *pGroupsLevels[] = {
groupsLevels, groupsLevels + 1, groupsLevels + 2,
groupsLevels + 3
};
GtkBuilder *builder;
GtkWidget *dialog, *kbdraw;
XkbComponentNamesRec component_names;
XklConfigRec *xkl_data;
GdkRectangle *rect;
GError *error = NULL;
XklEngine *engine = xkl_engine_get_instance (GDK_DISPLAY ());
XklState *xkl_state = xkl_engine_get_current_state (engine);
gchar **group_names = gkbd_status_get_group_names ();
gpointer p = g_hash_table_lookup (preview_dialogs,
GINT_TO_POINTER
(xkl_state->group));
if (p != NULL) {
/* existing window */
gtk_window_present (GTK_WINDOW (p));
return;
}
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, DATADIR "/show-layout.ui",
&error);
if (error) {
g_error ("building ui from %s failed: %s",
DATADIR "/show-layout.ui", error->message);
g_clear_error (&error);
}
dialog =
GTK_WIDGET (gtk_builder_get_object
(builder, "gswitchit_layout_view"));
kbdraw = gkbd_keyboard_drawing_new ();
if (xkl_state->group >= 0 &&
xkl_state->group < g_strv_length (group_names)) {
char title[128] = "";
snprintf (title, sizeof (title),
_("Keyboard Layout \"%s\""),
group_names[xkl_state->group]);
gtk_window_set_title (GTK_WINDOW (dialog), title);
g_object_set_data_full (G_OBJECT (dialog), "group_name",
g_strdup (group_names
[xkl_state->group]),
g_free);
}
gkbd_keyboard_drawing_set_groups_levels (GKBD_KEYBOARD_DRAWING
(kbdraw), pGroupsLevels);
xkl_data = xkl_config_rec_new ();
if (xkl_config_rec_get_from_server (xkl_data, engine)) {
int num_layouts = g_strv_length (xkl_data->layouts);
int num_variants = g_strv_length (xkl_data->variants);
if (xkl_state->group >= 0 &&
xkl_state->group < num_layouts &&
xkl_state->group < num_variants) {
char *l =
g_strdup (xkl_data->layouts[xkl_state->group]);
char *v =
g_strdup (xkl_data->variants
[xkl_state->group]);
char **p;
int i;
if ((p = xkl_data->layouts) != NULL)
for (i = num_layouts; --i >= 0;)
g_free (*p++);
if ((p = xkl_data->variants) != NULL)
for (i = num_variants; --i >= 0;)
g_free (*p++);
xkl_data->layouts =
g_realloc (xkl_data->layouts,
sizeof (char *) * 2);
xkl_data->variants =
g_realloc (xkl_data->variants,
sizeof (char *) * 2);
xkl_data->layouts[0] = l;
xkl_data->variants[0] = v;
xkl_data->layouts[1] = xkl_data->variants[1] =
NULL;
}
if (xkl_xkb_config_native_prepare
(engine, xkl_data, &component_names)) {
gkbd_keyboard_drawing_set_keyboard
(GKBD_KEYBOARD_DRAWING (kbdraw),
&component_names);
xkl_xkb_config_native_cleanup (engine,
&component_names);
}
}
g_object_unref (G_OBJECT (xkl_data));
g_object_set_data (G_OBJECT (dialog), "builderData", builder);
g_signal_connect (GTK_OBJECT (dialog),
"destroy", G_CALLBACK (show_layout_destroy),
GINT_TO_POINTER (xkl_state->group));
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (show_layout_response), NULL);
rect = gkbd_preview_load_position ();
if (rect != NULL) {
gtk_window_move (GTK_WINDOW (dialog), rect->x, rect->y);
gtk_window_resize (GTK_WINDOW (dialog), rect->width,
rect->height);
g_free (rect);
} else
gtk_window_resize (GTK_WINDOW (dialog), 700, 400);
gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
gtk_container_add (GTK_CONTAINER
(gtk_builder_get_object
(builder, "preview_vbox")), kbdraw);
g_object_set_data (G_OBJECT (dialog), "kbdraw", kbdraw);
g_hash_table_insert (preview_dialogs,
GINT_TO_POINTER (xkl_state->group), dialog);
gtk_widget_show_all (GTK_WIDGET (dialog));
}
gchar*
tags_dialog (GtkWidget *win, JamAccountLJ *acc, gchar *journal, gchar *typed)
{
GtkWidget *dlg, *sw, *tv;
GSList *list = NULL;
gchar *taglist = NULL;
GSList *prev;
if (acc == NULL) return NULL;
load_tags (GTK_WINDOW (win), acc, journal, &list);
dlg = gtk_dialog_new_with_buttons (_("Select tags"),
GTK_WINDOW (win),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), sw, TRUE, TRUE, 0);
prev = tags_split(typed);
tv = taglist_create (list, &prev);
gtk_container_add (GTK_CONTAINER (sw), tv);
gtk_window_resize(dlg, 60, 210);
gtk_widget_show_all (sw);
if (gtk_dialog_run (GTK_DIALOG (dlg)) == GTK_RESPONSE_OK)
{
taglist = g_strdup ("");
gtk_tree_model_foreach (gtk_tree_view_get_model (tv),
create_tag_string,
&taglist);
if (g_ascii_strcasecmp (taglist, "") == 0)
{
g_free (taglist);
taglist = NULL;
}
}
gtk_widget_destroy (dlg);
/* free rest of prev list */
if (prev) {
GSList *p;
for (p = prev; p; p = g_slist_next(p)) {
g_free(p->data);
}
g_slist_free(prev);
}
return taglist;
}
void update_win_kbm()
{
if (!current_CS || !gwin_kbm)
return;
clear_kbm();
if (current_CS->im_state != GCIN_STATE_CHINESE) {
if (current_CS->im_state == GCIN_STATE_DISABLED) {
int i;
for(i=0;i<keysN;i++) {
int j;
for(j=0;j<COLN;j++) {
char kstr[2];
kstr[1]=0;
kstr[0] = keys[i][j].shift_key;
if (keys[i][j].laben) {
if (kstr[0])
gtk_label_set_text(GTK_LABEL(keys[i][j].laben), kstr);
set_label_font_size(keys[i][j].laben, gcin_font_size_win_kbm_en);
}
if (keys[i][j].lab) {
if (kstr[0])
gtk_label_set_text(GTK_LABEL(keys[i][j].lab), _(keys[i][j].enkey));
set_label_font_size(keys[i][j].lab, gcin_font_size_win_kbm_en);
}
}
}
}
goto ret;
}
int i;
switch (current_method_type()) {
case method_type_PHO:
case method_type_TSIN:
for(i=0; i < 128; i++) {
int j;
char tt[64];
int ttN=0;
for(j=0;j<3; j++) {
int num = phkbm.phokbm[i][j].num;
int typ = phkbm.phokbm[i][j].typ;
if (!num)
continue;
ttN+= utf8cpy(&tt[ttN], &pho_chars[typ][num * 3]);
}
if (!ttN)
continue;
set_kbm_key(i, tt);
}
disp_shift_keys();
break;
case method_type_MODULE:
break;
default:
if (!cur_inmd || !cur_inmd->DefChars)
return;
int loop;
for(loop=0;loop<2;loop++)
for(i=127; i > 0; i--) {
char tt[64];
char k=cur_inmd->keymap[i];
if (!k)
continue;
char *keyname = &cur_inmd->keyname[k * CH_SZ];
if (!keyname[0])
continue;
#if 0
if (loop==0 && !(keyname[0]&0x80))
#else
if (loop==0 && !(keyname[0]&0x80) && toupper(i)==toupper(keyname[0]))
#endif
continue;
if (loop==1) {
KEY *p = get_keys_ent(i);
char *t = (char *)gtk_label_get_text(GTK_LABEL(p->lab));
if (t && t[0]) {
continue;
}
}
tt[0]=0;
if (keyname[0] & 128)
utf8cpy(tt, keyname);
else {
tt[1]=0;
memcpy(tt, keyname, 2);
tt[2]=0;
}
// dbg("%c '%s'\n", i, tt);
set_kbm_key(i, tt);
}
disp_shift_keys();
break;
}
ret:
gtk_window_resize(GTK_WINDOW(gwin_kbm), 1, 1);
move_win_kbm();
}
static void qq_chatwindow_init(QQChatWindow *win)
{
QQChatWindowPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE(win
, qq_chatwindow_get_type()
, QQChatWindowPriv);
gchar buf[500];
priv -> body_vbox = gtk_vbox_new(FALSE, 0);
GtkWidget *header_hbox = gtk_hbox_new(FALSE, 0);
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
QQBuddy *bdy = qq_info_lookup_buddy_by_uin(info, priv -> uin);
GdkPixbuf *pb = NULL;
g_snprintf(buf, 500, IMGDIR"%s", "avatar.gif");
pb = gdk_pixbuf_new_from_file(buf, NULL);
gtk_window_set_icon(GTK_WINDOW(win), pb);
g_object_unref(pb);
g_snprintf(buf, 500, "Talking with %s", bdy == NULL ? priv -> uin
: bdy -> nick -> str);
gtk_window_set_title(GTK_WINDOW(win), buf);
//create header
g_snprintf(buf, 500, IMGDIR"%s", "avatar.gif");
pb= gdk_pixbuf_new_from_file_at_size(buf, 35, 35, NULL);
priv -> faceimage = gtk_image_new_from_pixbuf(pb);
g_object_unref(pb);
priv -> name_label = gtk_label_new("");
priv -> lnick_label = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(header_hbox), priv -> faceimage
, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), priv -> name_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), priv -> lnick_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header_hbox), vbox, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(priv -> body_vbox), header_hbox
, FALSE, FALSE, 5);
// message text view
priv -> chat_widget = qq_chatwidget_new();
gtk_box_pack_start(GTK_BOX(priv -> body_vbox), priv -> chat_widget
, TRUE, TRUE, 0);
// buttons
GtkWidget *buttonbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(buttonbox), 5);
priv -> close_btn = gtk_button_new_with_label("Close");
g_signal_connect(G_OBJECT(priv -> close_btn), "clicked",
G_CALLBACK(qq_chatwindow_on_close_clicked), win);
priv -> send_btn = gtk_button_new_with_label("Send");
g_signal_connect(G_OBJECT(priv -> send_btn), "clicked",
G_CALLBACK(qq_chatwindow_on_send_clicked), win);
gtk_container_add(GTK_CONTAINER(buttonbox), priv -> close_btn);
gtk_container_add(GTK_CONTAINER(buttonbox), priv -> send_btn);
gtk_box_pack_start(GTK_BOX(priv -> body_vbox), buttonbox, FALSE, FALSE, 3);
GtkWidget *w = GTK_WIDGET(win);
gtk_window_resize(GTK_WINDOW(w), 500, 450);
gtk_container_add(GTK_CONTAINER(win), priv -> body_vbox);
gtk_widget_show_all(priv -> body_vbox);
gtk_widget_grab_focus(qq_chatwidget_get_input_textview(
priv -> chat_widget));
g_signal_connect(G_OBJECT(win), "delete-event"
, G_CALLBACK(qq_chatwindow_delete_event)
, priv);
g_signal_connect(G_OBJECT(win), "focus-in-event"
, G_CALLBACK(qq_chatwindow_focus_in_event)
, priv);
g_signal_connect(G_OBJECT(win), "key-press-event"
, G_CALLBACK(qq_chatwindow_key_press), priv);
g_signal_connect(G_OBJECT(qq_chatwidget_get_input_textview(
priv -> chat_widget))
, "key-press-event"
, G_CALLBACK(qq_input_textview_key_press), win);
}
Installer::Installer(
std::string app_name,
std::string confirm_title,
std::string message) :
app_name(app_name),
confirm_title(confirm_title),
message(message),
current_job(NULL),
cancel(false),
error("")
{
this->download_finished = false;
this->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(this->window), 10);
gtk_window_set_default_size(GTK_WINDOW(this->window), WINDOW_WIDTH, WINDOW_HEIGHT);
gtk_window_resize(GTK_WINDOW(this->window), WINDOW_WIDTH, WINDOW_HEIGHT);
gtk_window_set_gravity(GTK_WINDOW(this->window), GDK_GRAVITY_CENTER);
std::string title = this->app_name + " - Installer";
gtk_window_set_title(GTK_WINDOW(this->window), title.c_str());
g_signal_connect (
G_OBJECT(this->window),
"destroy",
G_CALLBACK(destroy_cb),
(gpointer) this);
gtk_window_move(
GTK_WINDOW(this->window),
gdk_screen_width()/2 - WINDOW_WIDTH/2,
gdk_screen_height()/2 - WINDOW_HEIGHT/2);
GdkColormap* colormap = gtk_widget_get_colormap(this->window);
GdkBitmap *mask = NULL;
GdkPixmap* icon = gdk_pixmap_colormap_create_from_xpm_d(
NULL,
colormap,
&mask,
NULL,
(gchar**) titanium_xpm);
GtkWidget* image = gtk_image_new_from_pixmap(icon, mask);
this->label = gtk_label_new("Downloading packages..");
GtkWidget* hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), this->label, FALSE, FALSE, 0);
this->bar = gtk_progress_bar_new();
GtkWidget* hbox2 = gtk_hbox_new(FALSE, 0);
GtkWidget* cancel_but = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_box_pack_start(GTK_BOX(hbox2), cancel_but, TRUE, FALSE, 0);
g_signal_connect (
G_OBJECT(cancel_but),
"clicked",
G_CALLBACK(cancel_cb),
(gpointer) this);
GtkWidget* vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), this->bar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 10);
gtk_container_add(GTK_CONTAINER(this->window), vbox);
}
/*!
\brief Creates a group of 2D Table Editors packed into a GtkNotebook
\param button is a pointer to the widget the user click on, which has bound
to is a list of the TE Table ID's which we need to create on-screen
representations for
\returns TRUE on success, FALSE otherwise
*/
G_MODULE_EXPORT gboolean create_2d_table_editor_group(GtkWidget *button)
{
GladeXML *main_xml = NULL;
GladeXML *xml = NULL;
GtkWidget *widget = NULL;
GtkWidget *window = NULL;
GtkWidget *notebook = NULL;
GtkWidget *curve = NULL;
GtkWidget *x_parent = NULL;
GtkWidget *y_parent = NULL;
GtkWidget *x_table = NULL;
GtkWidget *y_table = NULL;
GtkWidget *label = NULL;
GtkWidget *entry = NULL;
GtkWidget *dummy = NULL;
GtkWidget *gauge = NULL;
GtkWidget *parent = NULL;
GtkWidget *curve_parent = NULL;
CurveData *cdata = NULL;
GArray *x_entries = NULL;
GArray *y_entries = NULL;
GList *widget_list = NULL;
GList *curve_list = NULL;
GList *gauge_list = NULL;
gchar * tmpbuf = NULL;
gchar * filename = NULL;
gchar **vector = NULL;
GList ***ecu_widgets = NULL;
gint num_tabs = 0;
gint x_mult = 0;
gint y_mult = 0;
gint page = 0;
gint offset = 0;
gint i = 0;
gint j = 0;
gfloat tmpf = 0.0;
guint32 id = 0;
gint rows = 0;
gint table_num = 0;
Firmware_Details *firmware = NULL;
firmware = DATA_GET(global_data,"firmware");
ecu_widgets = DATA_GET(global_data,"ecu_widgets");
main_xml = (GladeXML *)DATA_GET(global_data,"main_xml");
if (!main_xml)
return FALSE;
xml = glade_xml_new(main_xml->filename,"table_editor_window",NULL);
window = glade_xml_get_widget(xml,"table_editor_window");
glade_xml_signal_autoconnect(xml);
g_signal_connect(G_OBJECT(window),"destroy_event",
G_CALLBACK(close_2d_editor),NULL);
g_signal_connect(G_OBJECT(window),"delete_event",
G_CALLBACK(close_2d_editor),NULL);
gtk_window_set_title(GTK_WINDOW(window),_("2D Table Group Editor"));
gtk_window_resize(GTK_WINDOW(window),800,530);
widget = glade_xml_get_widget(xml,"2d_close_button");
g_signal_connect_swapped(G_OBJECT(widget),"clicked",
G_CALLBACK(close_2d_editor),window);
widget = glade_xml_get_widget(xml,"get_data_button");
OBJ_SET(widget,"handler",GINT_TO_POINTER(READ_VE_CONST));
OBJ_SET_FULL(widget,"bind_to_list",g_strdup("get_data_buttons"),g_free);
bind_to_lists_f(widget,"get_data_buttons");
widget_list = g_list_prepend(widget_list,(gpointer)widget);
widget = glade_xml_get_widget(xml,"burn_data_button");
OBJ_SET(widget,"handler",GINT_TO_POINTER(BURN_FLASH));
OBJ_SET_FULL(widget,"bind_to_list",g_strdup("burners"),g_free);
bind_to_lists_f(widget,"burners");
widget_list = g_list_prepend(widget_list,(gpointer)widget);
/*
widget = glade_xml_get_widget(xml,"curve_editor_menuitem");
gtk_widget_set_sensitive(GTK_WIDGET(widget), FALSE);
*/
widget = glade_xml_get_widget(xml,"close_menuitem");
OBJ_SET(widget,"window",(gpointer)window);
widget = glade_xml_get_widget(xml,"te_layout_hbox1");
gtk_widget_destroy(widget);
widget = glade_xml_get_widget(xml,"te_layout_vbox");
tmpbuf = OBJ_GET(button,"te_tables");
vector = parse_keys_f(tmpbuf,&num_tabs,",");
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook),GTK_POS_LEFT);
gtk_box_pack_start(GTK_BOX(widget),notebook,TRUE,TRUE,0);
for (j = 0;j < num_tabs;j++)
{
table_num = (gint)strtod(vector[j],NULL);
if (table_num >= firmware->total_te_tables)
{
warn_user_f("Requested to create 2D table editor window for an undefined (out of range) table ID");
return FALSE;
}
if (!firmware->te_params)
{
warn_user_f("No 2D table Editor tables (te_tables) defined in interrogation profile, yet told to create a graph for a table... BUG detected!");
continue;
}
if (!firmware->te_params[table_num])
{
warn_user_f("Requested to create a 2D table editor window for an undefined table!");
continue;
}
xml = glade_xml_new(main_xml->filename,"te_layout_hbox1",NULL);
widget = glade_xml_get_widget(xml,"te_layout_hbox1");
label = gtk_label_new(firmware->te_params[table_num]->title);
gtk_misc_set_alignment(GTK_MISC(label),0,0.5);
if (firmware->te_params[table_num]->bind_to_list)
{
OBJ_SET_FULL(widget,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free);
OBJ_SET(widget,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type));
bind_to_lists_f(widget,firmware->te_params[table_num]->bind_to_list);
widget_list = g_list_prepend(widget_list,(gpointer)widget);
OBJ_SET_FULL(label,"bind_to_list", g_strdup(firmware->te_params[table_num]->bind_to_list),g_free);
OBJ_SET(label,"match_type", GINT_TO_POINTER(firmware->te_params[table_num]->match_type));
bind_to_lists_f(label,firmware->te_params[table_num]->bind_to_list);
widget_list = g_list_prepend(widget_list,(gpointer)label);
}
if (firmware->te_params[table_num]->gauge ||
firmware->te_params[table_num]->c_gauge ||
firmware->te_params[table_num]->f_gauge)
{
parent = glade_xml_get_widget(xml,"te_gaugeframe");
gauge = mtx_gauge_face_new();
gauge_list = g_list_prepend(gauge_list,(gpointer)gauge);
OBJ_SET(window,"gauge",gauge);
if (firmware->te_params[table_num]->gauge_temp_dep)
{
if ((GINT)DATA_GET(global_data,"mtx_temp_units") == CELSIUS)
tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/');
else if ((GINT)DATA_GET(global_data,"mtx_temp_units") == KELVIN)
tmpbuf = g_strdelimit(firmware->te_params[table_num]->c_gauge,"\\",'/');
else
tmpbuf = g_strdelimit(firmware->te_params[table_num]->f_gauge,"\\",'/');
}
else
tmpbuf = g_strdelimit(firmware->te_params[table_num]->gauge,"\\",'/');
filename = get_file(g_strconcat(GAUGES_DATA_DIR,PSEP,tmpbuf,NULL),NULL);
mtx_gauge_face_import_xml(MTX_GAUGE_FACE(gauge),filename);
lookup_current_value_f(firmware->te_params[table_num]->gauge_datasource, &tmpf);
mtx_gauge_face_set_value(MTX_GAUGE_FACE(gauge),tmpf);
g_free(filename);
id = create_rtv_value_change_watch_f(firmware->te_params[table_num]->gauge_datasource,FALSE,"update_misc_gauge",(gpointer)gauge);
OBJ_SET(gauge,"gauge_id",GINT_TO_POINTER(id));
gtk_container_add(GTK_CONTAINER(parent),gauge);
}
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),widget,label);
curve_parent = glade_xml_get_widget(xml,"te_right_frame");
curve = mtx_curve_new();
curve_list = g_list_prepend(curve_list,(gpointer)curve);
mtx_curve_set_title(MTX_CURVE(curve),_(firmware->te_params[table_num]->title));
mtx_curve_set_x_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->x_axis_label));
mtx_curve_set_y_axis_label(MTX_CURVE(curve),_(firmware->te_params[table_num]->y_axis_label));
cdata = g_new0(CurveData, 1);
cdata->curve = curve;
cdata->axis = _X_;
cdata->source = firmware->te_params[table_num]->x_source;
id = create_rtv_value_change_watch_f(cdata->source,FALSE,"update_curve_marker",(gpointer)cdata);
mtx_curve_set_show_x_marker(MTX_CURVE(curve),TRUE);
OBJ_SET(curve,"cdata",(gpointer)cdata);
OBJ_SET(curve,"marker_id",GINT_TO_POINTER(id));
mtx_curve_set_auto_hide_vertexes(MTX_CURVE(curve),TRUE);
g_signal_connect(G_OBJECT(curve),"coords-changed",
G_CALLBACK(coords_changed), NULL);
g_signal_connect(G_OBJECT(curve),"vertex-proximity",
G_CALLBACK(vertex_proximity), NULL);
g_signal_connect(G_OBJECT(curve),"marker-proximity",
G_CALLBACK(marker_proximity), NULL);
label = glade_xml_get_widget(xml,"x_units");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_units);
label = glade_xml_get_widget(xml,"y_units");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_units);
label = glade_xml_get_widget(xml,"x_title");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->x_name);
label = glade_xml_get_widget(xml,"y_title");
gtk_label_set_markup(GTK_LABEL(label),firmware->te_params[table_num]->y_name);
rows = firmware->te_params[table_num]->bincount;
mtx_curve_set_empty_array(MTX_CURVE(curve),rows);
x_table = gtk_table_new(rows+1,1,FALSE);
y_table = gtk_table_new(rows+1,1,FALSE);
x_parent = glade_xml_get_widget(xml,"te_x_frame");
y_parent = glade_xml_get_widget(xml,"te_y_frame");
gtk_container_set_border_width(GTK_CONTAINER(x_table),5);
gtk_container_set_border_width(GTK_CONTAINER(y_table),5);
gtk_container_add(GTK_CONTAINER(x_parent),x_table);
gtk_container_add(GTK_CONTAINER(y_parent),y_table);
x_mult = get_multiplier_f(firmware->te_params[table_num]->x_size);
y_mult = get_multiplier_f(firmware->te_params[table_num]->y_size);
x_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *));
y_entries = g_array_new(FALSE,TRUE,sizeof(GtkWidget *));
for (i=0;i<rows;i++)
{
/* X Column */
entry = gtk_entry_new();
OBJ_SET(entry,"last_value",GINT_TO_POINTER(-G_MAXINT));
gtk_entry_set_width_chars(GTK_ENTRY(entry),7);
OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i));
g_array_insert_val(x_entries,i,entry);
OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_X_));
OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE));
OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC));
OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_lower)),g_free);
OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->x_raw_upper)),g_free);
OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->x_fromecu_mult);
OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->x_fromecu_add);
OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->x_precision));
OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->x_size));
OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->x_page));
OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->x_temp_dep));
OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->x_use_color));
if(firmware->te_params[table_num]->x_temp_dep)
{
OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
OBJ_SET_FULL(entry,"bind_to_list", g_strdup("temperature"),g_free);
bind_to_lists_f(entry,"temperature");
}
offset = (i*x_mult) + firmware->te_params[table_num]->x_base;
OBJ_SET(entry,"offset",GINT_TO_POINTER(offset));
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(update_2d_curve),curve);
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(entry_changed_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_press_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_release_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"focus_out_event",
G_CALLBACK(focus_out_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"activate",
G_CALLBACK(std_entry_handler_f),NULL);
if (firmware->te_params[table_num]->reversed)
gtk_table_attach(GTK_TABLE(x_table),entry,
0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0);
else
gtk_table_attach(GTK_TABLE(x_table),entry,
0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0);
page = firmware->te_params[table_num]->x_page;
ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry);
widget_list = g_list_prepend(widget_list,(gpointer)entry);
update_widget(G_OBJECT(entry),NULL);
/* Y Column */
entry = gtk_entry_new();
OBJ_SET(entry,"last_value",GINT_TO_POINTER(-G_MAXINT));
gtk_entry_set_width_chars(GTK_ENTRY(entry),7);
OBJ_SET(entry,"curve_index",GINT_TO_POINTER(i));
g_array_insert_val(y_entries,i,entry);
OBJ_SET(entry,"curve_axis",GINT_TO_POINTER(_Y_));
OBJ_SET(entry,"dl_type",GINT_TO_POINTER(IMMEDIATE));
OBJ_SET(entry,"handler",GINT_TO_POINTER(GENERIC));
OBJ_SET_FULL(entry,"raw_lower",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_lower)),g_free);
OBJ_SET_FULL(entry,"raw_upper",g_strdup_printf("%i",(firmware->te_params[table_num]->y_raw_upper)),g_free);
OBJ_SET(entry,"fromecu_mult",firmware->te_params[table_num]->y_fromecu_mult);
OBJ_SET(entry,"fromecu_add",firmware->te_params[table_num]->y_fromecu_add);
OBJ_SET(entry,"precision",GINT_TO_POINTER(firmware->te_params[table_num]->y_precision));
OBJ_SET(entry,"size",GINT_TO_POINTER(firmware->te_params[table_num]->y_size));
OBJ_SET(entry,"page",GINT_TO_POINTER(firmware->te_params[table_num]->y_page));
OBJ_SET(entry,"temp_dep",GINT_TO_POINTER(firmware->te_params[table_num]->y_temp_dep));
OBJ_SET(entry,"use_color",GINT_TO_POINTER(firmware->te_params[table_num]->y_use_color));
if(firmware->te_params[table_num]->y_temp_dep)
{
OBJ_SET(entry,"widget_temp",DATA_GET(global_data,"mtx_temp_units"));
OBJ_SET_FULL(entry,"bind_to_list", g_strdup("temperature"),g_free);
bind_to_lists_f(entry,"temperature");
}
offset = (i*y_mult) + firmware->te_params[table_num]->y_base;
OBJ_SET(entry,"offset",GINT_TO_POINTER(offset));
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(update_2d_curve),curve);
g_signal_connect(G_OBJECT(entry),"changed",
G_CALLBACK(entry_changed_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_press_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"key_release_event",
G_CALLBACK(key_event_f),NULL);
g_signal_connect(G_OBJECT(entry),"focus_out_event",
G_CALLBACK(focus_out_handler_f),NULL);
g_signal_connect(G_OBJECT(entry),"activate",
G_CALLBACK(std_entry_handler_f),NULL);
if (firmware->te_params[table_num]->reversed)
gtk_table_attach(GTK_TABLE(y_table),entry,
0,1,rows-i-1,rows-i, GTK_SHRINK,GTK_SHRINK,0,0);
else
gtk_table_attach(GTK_TABLE(y_table),entry,
0,1,i,i+1, GTK_SHRINK,GTK_SHRINK,0,0);
page = firmware->te_params[table_num]->y_page;
ecu_widgets[page][offset] = g_list_prepend(ecu_widgets[page][offset],(gpointer)entry);
widget_list = g_list_prepend(widget_list,(gpointer)entry);
update_widget(G_OBJECT(entry),NULL);
}
/* Create the "LOCK" buttons */
dummy = gtk_toggle_button_new_with_label("Unlocked");
OBJ_SET(dummy,"axis",GINT_TO_POINTER(_X_));
g_signal_connect(G_OBJECT(dummy),"toggled",
G_CALLBACK(set_axis_locking),curve);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->x_lock);
gtk_table_attach(GTK_TABLE(x_table),dummy,
0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0);
dummy = gtk_toggle_button_new_with_label("Unlocked");
OBJ_SET(dummy,"axis",GINT_TO_POINTER(_Y_));
g_signal_connect(G_OBJECT(dummy),"toggled",
G_CALLBACK(set_axis_locking),curve);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(dummy),firmware->te_params[table_num]->y_lock);
gtk_table_attach(GTK_TABLE(y_table),dummy,
0,1,i,i+1, GTK_EXPAND|GTK_FILL,0,0,0);
mtx_curve_set_x_precision(MTX_CURVE(curve),firmware->te_params[table_num]->x_precision);
mtx_curve_set_y_precision(MTX_CURVE(curve),firmware->te_params[table_num]->y_precision);
mtx_curve_set_hard_limits(MTX_CURVE(curve),
(gfloat)firmware->te_params[table_num]->x_raw_lower,
(gfloat)firmware->te_params[table_num]->x_raw_upper,
(gfloat)firmware->te_params[table_num]->y_raw_lower,
(gfloat)firmware->te_params[table_num]->y_raw_upper);
OBJ_SET(curve,"x_entries",x_entries);
OBJ_SET(curve,"y_entries",y_entries);
if (firmware->te_params[table_num]->bind_to_list)
g_list_foreach(get_list_f(firmware->te_params[table_num]->bind_to_list),alter_widget_state_f,NULL);
create_rtv_value_change_watch_f(cdata->source,TRUE,"update_curve_marker",(gpointer)cdata);
gtk_container_add(GTK_CONTAINER(curve_parent),curve);
}
OBJ_SET(window,"widget_list",widget_list);
OBJ_SET(window,"curve_list",curve_list);
OBJ_SET(window,"gauge_list",gauge_list);
gtk_widget_show_all(window);
return TRUE;
}
GummiGui* gui_init(GtkBuilder* builder)
{
g_return_val_if_fail(GTK_IS_BUILDER(builder), NULL);
GtkWidget* hpaned;
gint i = 0, wx = 0, wy = 0, width = 0, height = 0;
GummiGui* g = g_new0(GummiGui, 1);
g->builder = builder;
g->mainwindow =
GTK_WINDOW(gtk_builder_get_object(builder, "mainwindow"));
g->toolbar =
GTK_WIDGET(gtk_builder_get_object(builder, "maintoolbar"));
g->statusbar =
GTK_STATUSBAR(gtk_builder_get_object(builder, "statusbar"));
g->rightpane =
GTK_BOX(gtk_builder_get_object(builder, "rightpanebox"));
g->previewoff = GTK_TOGGLE_TOOL_BUTTON(
gtk_builder_get_object(builder, "tool_previewoff"));
g->errorview =
GTK_TEXT_VIEW(gtk_builder_get_object(builder, "errorview"));
g->errorbuff =
gtk_text_view_get_buffer(GTK_TEXT_VIEW(g->errorview));
g_object_ref(g->errorbuff);
g->menu_spelling =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_spelling"));
g->menu_snippets =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_snippets"));
g->menu_toolbar =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_toolbar"));
g->menu_statusbar =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_statusbar"));
g->menu_rightpane =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_rightpane"));
g->statusid =
gtk_statusbar_get_context_id(GTK_STATUSBAR(g->statusbar), "Gummi");
g->recent[0] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent1"));
g->recent[1] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent2"));
g->recent[2] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent3"));
g->recent[3] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent4"));
g->recent[4] =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_recent5"));
g->docstatswindow =
GTK_WIDGET(gtk_builder_get_object(builder, "docstatswindow"));
g->menu_runbibtex =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_runbibtex"));
g->menu_runmakeindex =
GTK_MENU_ITEM(gtk_builder_get_object(builder, "menu_runmakeindex"));
g->bibcompile =
GTK_WIDGET(gtk_builder_get_object(builder, "bibcompile"));
g->insens_widget_size = sizeof(insens_widgets_str) / sizeof(gchar*);
g->insens_widgets = g_new0(GtkWidget*, g->insens_widget_size);
for (i = 0; i < g->insens_widget_size; ++i)
g->insens_widgets[i] =
GTK_WIDGET(gtk_builder_get_object(builder, insens_widgets_str[i]));
g->menugui = menugui_init(builder);
g->importgui = importgui_init(builder);
g->previewgui = previewgui_init(builder);
g->searchgui = searchgui_init(builder);
g->prefsgui = prefsgui_init(g->mainwindow);
g->snippetsgui = snippetsgui_init(g->mainwindow);
g->tabmanagergui = tabmanagergui_init(builder);
g->infoscreengui = infoscreengui_init(builder);
g->projectgui = projectgui_init(builder);
gchar* icon_file = g_build_filename(GUMMI_DATA, "icons", "icon.png", NULL);
gtk_window_set_icon_from_file(g->mainwindow, icon_file, NULL);
g_free(icon_file);
if (config_get_value("window_maximized")) {
gtk_window_maximize(g->mainwindow);
} else {
gtk_window_resize(g->mainwindow,
atoi(config_get_value("mainwindow_w")),
atoi(config_get_value("mainwindow_h")));
}
gtk_window_set_default_size(g->mainwindow,
atoi(config_get_value("mainwindow_w")),
atoi(config_get_value("mainwindow_h")));
wx = atoi(config_get_value("mainwindow_x"));
wy = atoi(config_get_value("mainwindow_y"));
if (wx && wy)
gtk_window_move(g->mainwindow, wx, wy);
else
gtk_window_set_position(g->mainwindow, GTK_WIN_POS_CENTER);
/* Set errorview font */
GtkCssProvider* css = gtk_css_provider_new();
GtkStyleContext* context = gtk_widget_get_style_context(
GTK_WIDGET(g->errorview));
gtk_style_context_add_provider(context,
GTK_STYLE_PROVIDER(css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
const gchar* style = "* { font: Monospace 8; }";
gtk_css_provider_load_from_data(css, style, -1, NULL);
/* Set pane size */
gtk_window_get_size(g->mainwindow, &width, &height);
hpaned = GTK_WIDGET(gtk_builder_get_object(builder, "hpaned"));
gtk_paned_set_position(GTK_PANED(hpaned), (width / 2));
#ifndef USE_GTKSPELL
gtk_widget_set_sensitive(GTK_WIDGET(g->menu_spelling), FALSE);
#else
if (config_get_value("spelling"))
gtk_check_menu_item_set_active(g->menu_spelling, TRUE);
#endif
if (config_get_value("snippets")) {
gtk_check_menu_item_set_active(g->menu_snippets, TRUE);
gtk_widget_show(GTK_WIDGET(g->menu_snippets));
}
if (config_get_value("toolbar")) {
gtk_check_menu_item_set_active(g->menu_toolbar, TRUE);
gtk_widget_show(g->toolbar);
} else {
config_set_value("toolbar", "False");
gtk_check_menu_item_set_active(g->menu_toolbar, FALSE);
gtk_widget_hide(g->toolbar);
}
if (config_get_value("statusbar")) {
gtk_check_menu_item_set_active(g->menu_statusbar, TRUE);
gtk_widget_show(GTK_WIDGET(g->statusbar));
} else {
config_set_value("statusbar", "False");
gtk_check_menu_item_set_active(g->menu_statusbar, FALSE);
gtk_widget_hide(GTK_WIDGET(g->statusbar));
}
if (config_get_value("rightpane")) {
gtk_check_menu_item_set_active(g->menu_rightpane, TRUE);
gtk_widget_show(GTK_WIDGET(g->rightpane));
} else {
config_set_value("compile_status", "False");
gtk_toggle_tool_button_set_active(g->previewoff, FALSE);
gtk_widget_hide(GTK_WIDGET(g->rightpane));
}
g->menu_autosync =
GTK_CHECK_MENU_ITEM(gtk_builder_get_object(builder, "menu_autosync"));
if (latex_can_synctex() && config_get_value("synctex")) {
gtk_widget_set_sensitive(GTK_WIDGET(g->menu_autosync), TRUE);
gboolean async = latex_use_synctex();
gtk_check_menu_item_set_active(g->menu_autosync, (async ? TRUE : FALSE));
}
if (!config_get_value("compile_status"))
gtk_toggle_tool_button_set_active(g->previewoff, TRUE);
g->recent_list[0] = g_strdup(config_get_value("recent1"));
g->recent_list[1] = g_strdup(config_get_value("recent2"));
g->recent_list[2] = g_strdup(config_get_value("recent3"));
g->recent_list[3] = g_strdup(config_get_value("recent4"));
g->recent_list[4] = g_strdup(config_get_value("recent5"));
display_recent_files(g);
return g;
}
int main (int argc, char *argv[])
{
GtkWidget *main_window;
GOptionContext *context;
GError *option_error;
gchar *config_file_name, *dir;
gboolean show_version = FALSE;
GOptionEntry options[] =
{
{
"version",
'v',
0,
G_OPTION_ARG_NONE,
&show_version,
_("Show version information"),
NULL
},
{NULL}
};
#ifdef WITH_HILDON
HildonProgram *hildon_program;
#endif
#ifdef ENABLE_NLS
bindtextdomain (PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (PACKAGE, "UTF-8");
textdomain (PACKAGE);
gtk_set_locale();
#endif
/* Parse command line options */
context = g_option_context_new (NULL);
g_option_context_set_summary(context,
_("Carry out simple and scientific calculations"));
#ifdef ENABLE_NLS
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
#else
g_option_context_add_main_entries (context, options, NULL);
#endif
g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &option_error))
{
if (option_error)
g_print ("%s\n", option_error->message);
return EXIT_FAILURE;
}
g_option_context_free (context);
if(show_version == TRUE)
{
g_print(_("%s v%s, (c) 2002-2010 Simon Floery\n"),
PACKAGE, VERSION);
return EXIT_SUCCESS;
}
gtk_init (&argc, &argv);
/* at first, get config file */
dir = g_build_filename (g_get_user_config_dir (), PACKAGE, NULL);
g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR);
config_file_name = g_build_filename (dir, CONFIG_FILE_NAME, NULL);
g_free(dir);
prefs = config_file_read (config_file_name);
constant = config_file_get_constants();
user_function = config_file_get_user_functions();
g_free (config_file_name);
current_status.notation = prefs.def_notation;
#ifdef WITH_HILDON
gtkbuilder_register_widget (HILDON_TYPE_WINDOW, gtkbuilder_hildon_window_new, gtkbuilder_standard_build_children, NULL);
hildon_program = HILDON_PROGRAM(hildon_program_get_instance());
#endif
/* at first get the main frame */
/* sth like ui_launch_up_ui for splitting into first time wizard? */
main_window = ui_main_window_create();
#ifdef WITH_HILDON
hildon_program_add_window(hildon_program, HILDON_WINDOW(main_window));
g_set_application_name(PACKAGE_NAME);
create_hildon_menu(HILDON_WINDOW(main_window));
#endif
/* set the window title */
#ifndef WITH_DEFCALC
gtk_window_set_title ((GtkWindow *)main_window, PACKAGE_NAME);
#else
gtk_window_set_title ((GtkWindow *)main_window, "Calculator");
#endif
/* set the window's icon */
#ifndef WITH_DEFCALC
gtk_window_set_default_icon_name (PACKAGE);
#else
gtk_window_set_default_icon_name ("utilities-calculator");
#endif
/* usually, only Shift, CTRL and ALT modifiers are paid attention to by
* accelerator code. add MOD2 (NUMLOCK allover the world?) to the list.
* We have to do this for a working keypad.
*/
gtk_accelerator_set_default_mod_mask (gtk_accelerator_get_default_mod_mask () | GDK_MOD2_MASK);
/* prepare calc_basic */
main_alg = alg_init (0);
rpn_init (prefs.stack_size, 0);
/* apply changes */
apply_preferences (prefs);
memory.data = NULL;
memory.len = 0;
/* see function key_snooper for details */
gtk_key_snooper_install (key_snooper, NULL);
gtk_window_resize ((GtkWindow *)main_window, 1, 1);
/* gtk_widget_show main window as late as possible */
gtk_widget_show (main_window);
gtk_main ();
/* save changes to file */
dir = g_build_filename (g_get_user_config_dir (), PACKAGE, NULL);
g_mkdir_with_parents (dir, S_IRUSR | S_IWUSR | S_IXUSR);
config_file_name = g_build_filename (dir, CONFIG_FILE_NAME, NULL);
g_free(dir);
config_file_write (config_file_name, prefs, constant, user_function);
g_free (config_file_name);
return EXIT_SUCCESS;
}
/******************************************************************************
* Name
* create_parallel_dialog
*
* Synopsis
* #include "parallel_dialog.h"
*
* GtkWidget *create_parallel_dialog(void)
*
* Description
*
*
*
* Return value
* GtkWidget *
*/
static GtkWidget *create_parallel_dialog(void)
{
GtkWidget *box_parallel_labels;
GtkWidget *dialog_vbox25;
GtkWidget *toolbar29;
GtkWidget *dialog_action_area25;
GtkWidget *hbuttonbox4;
GtkWidget *btnDockInt;
#ifndef USE_WEBKIT2
GtkWidget *scrolled_window;
#endif
gchar title[256];
sprintf(title, "%s - %s", settings.program_title, _("Parallel"));
dialog_parallel = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog_parallel), title);
g_object_set_data(G_OBJECT(dialog_parallel),
"dialog_parallel", dialog_parallel);
gtk_window_resize(GTK_WINDOW(dialog_parallel),
settings.parallel_width,
settings.parallel_height);
gtk_window_set_resizable(GTK_WINDOW(dialog_parallel), TRUE);
dialog_vbox25 =
gtk_dialog_get_content_area(GTK_DIALOG(dialog_parallel));
g_object_set_data(G_OBJECT(dialog_parallel), "dialog_vbox25",
dialog_vbox25);
gtk_widget_show(dialog_vbox25);
UI_VBOX(vboxInt, FALSE, 0);
gtk_widget_show(vboxInt);
gtk_box_pack_start(GTK_BOX(dialog_vbox25), vboxInt, TRUE, TRUE, 0);
toolbar29 = create_nav_toolbar();
gtk_widget_show(toolbar29);
gtk_box_pack_start(GTK_BOX(vboxInt), toolbar29, FALSE, FALSE, 0);
UI_HBOX(box_parallel_labels, TRUE, 2);
gtk_widget_show(box_parallel_labels);
gtk_box_pack_start(GTK_BOX(vboxInt), box_parallel_labels, FALSE,
TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(box_parallel_labels),
2);
#if 0
if (settings.parallel_list) {
GtkWidget *plabel;
gchar *label;
gint modidx;
for (modidx = 0; settings.parallel_list[modidx]; ++modidx) {
plabel = gtk_label_new(NULL);
gtk_widget_show(plabel);
gtk_box_pack_start(GTK_BOX(box_parallel_labels),
plabel, FALSE, FALSE, 0);
gtk_label_set_use_markup(GTK_LABEL(plabel), TRUE);
label =
g_strdup_printf
("<span color='%s' weight='bold'>%s</span>",
settings.bible_verse_num_color,
settings.parallel_list[modidx]);
gtk_label_set_markup(GTK_LABEL(plabel), label);
g_free(label);
}
}
#endif /* 0 */
#ifndef USE_WEBKIT2
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolled_window);
gtk_box_pack_start(GTK_BOX(vboxInt), scrolled_window, TRUE, TRUE,
0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow *)
scrolled_window,
settings.shadow_type);
#endif
widgets.html_parallel_dialog =
GTK_WIDGET(XIPHOS_HTML_NEW(NULL, FALSE, PARALLEL_TYPE));
gtk_widget_show(widgets.html_parallel_dialog);
#ifdef USE_WEBKIT2
gtk_box_pack_start(GTK_BOX(vboxInt), widgets.html_parallel_dialog, TRUE, TRUE, 0);
#else
gtk_container_add(GTK_CONTAINER(scrolled_window),
widgets.html_parallel_dialog);
#endif
g_signal_connect((gpointer)widgets.html_parallel_dialog,
"popupmenu_requested",
G_CALLBACK(_popupmenu_requested_cb), NULL);
dialog_action_area25 =
#ifdef HAVE_GTK_312
gtk_dialog_get_content_area(GTK_DIALOG(dialog_parallel));
#else
gtk_dialog_get_action_area(GTK_DIALOG(dialog_parallel));
#endif
g_object_set_data(G_OBJECT(dialog_parallel),
"dialog_action_area25", dialog_action_area25);
gtk_widget_show(dialog_action_area25);
gtk_container_set_border_width(GTK_CONTAINER(dialog_action_area25), 10);
#ifdef USE_GTK_3
hbuttonbox4 = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
#else
hbuttonbox4 = gtk_hbutton_box_new();
#endif
gtk_widget_show(hbuttonbox4);
#ifdef HAVE_GTK_312
gtk_box_pack_start(GTK_BOX(dialog_action_area25), hbuttonbox4,
FALSE, TRUE, 3);
#else
gtk_box_pack_start(GTK_BOX(dialog_action_area25), hbuttonbox4,
TRUE, TRUE, 0);
#endif
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox4),
GTK_BUTTONBOX_END);
btnDockInt =
#ifdef HAVE_GTK_310
gtk_button_new_from_icon_name("window-close",
GTK_ICON_SIZE_BUTTON);
#else
gtk_button_new_from_stock(GTK_STOCK_CLOSE);
#endif
gtk_widget_show(btnDockInt);
gtk_container_add(GTK_CONTAINER(hbuttonbox4), btnDockInt);
gtk_widget_set_can_default(btnDockInt, 1);
g_signal_connect(G_OBJECT(dialog_parallel), "destroy",
G_CALLBACK(on_dlgparallel_destroy), NULL);
g_signal_connect(G_OBJECT(btnDockInt), "clicked",
G_CALLBACK(gui_btnDockInt_clicked), NULL);
g_signal_connect((gpointer)dialog_parallel,
"configure_event",
G_CALLBACK(on_parallel_configure_event), NULL);
settings.display_parallel = 1;
xml_set_value("Xiphos", "layout", "parallelopen", "1");
set_window_icon(GTK_WINDOW(dialog_parallel));
/*
* (from xiphos.c)
* a little paranoia:
* clamp geometry values to a reasonable bound.
* sometimes xiphos gets insane reconfig events as it dies,
* especially if it's due to just shutting linux down.
*/
if ((settings.parallel_x < 0) || (settings.parallel_x > 2000))
settings.parallel_x = 40;
if ((settings.parallel_y < 0) || (settings.parallel_y > 2000))
settings.parallel_y = 40;
gtk_window_move(GTK_WINDOW(dialog_parallel), settings.parallel_x,
settings.parallel_y);
return dialog_parallel;
}
extern void settings_read (qinfo_t *app)
{
GKeyFile *cfg = g_key_file_new ();
gchar *file = g_build_filename (g_get_user_config_dir (), "qinfo", NULL);
if (g_key_file_load_from_file (cfg, file, G_KEY_FILE_NONE, &app->error) ==
FALSE)
{
g_warning (app->error->message);
}
g_free (file);
FREE_GERROR (app->error);
app->x = g_key_file_get_integer (cfg, "window", "x", &app->error);
if (app->error != NULL)
app->x = 100;
FREE_GERROR (app->error);
app->y = g_key_file_get_integer (cfg, "window", "y", &app->error);
if (app->error != NULL)
app->y = 100;
FREE_GERROR (app->error);
app->width = g_key_file_get_integer (cfg, "window", "width", &app->error);
if (app->error != NULL)
app->width = 500;
FREE_GERROR (app->error);
app->height = g_key_file_get_integer (cfg, "window", "height", &app->error);
if (app->error != NULL)
app->height = 600;
FREE_GERROR (app->error);
gtk_window_resize (GTK_WINDOW (app->window), app->width, app->height);
gtk_window_move (GTK_WINDOW (app->window), app->x, app->y);
gchar *str = g_key_file_get_string (cfg, "textview", "font", &app->error);
if (app->error != NULL)
str = g_strdup ("Terminus 8");
app->font = pango_font_description_from_string (str);
FREE_GERROR (app->error);
str = g_key_file_get_string (cfg, "textview", "text_color", &app->error);
if (app->error != NULL)
str = g_strdup ("#000000");
gdk_color_parse (str, &app->fg);
gdk_colormap_alloc_color (gdk_colormap_get_system (), &app->fg, FALSE,
TRUE);
g_free (str);
FREE_GERROR (app->error);
str = g_key_file_get_string (cfg, "textview", "background_color",
&app->error);
if (app->error != NULL)
str = g_strdup ("#FFFFFF");
gdk_color_parse (str, &app->bg);
gdk_colormap_alloc_color (gdk_colormap_get_system (), &app->bg, FALSE,
TRUE);
g_free (str);
FREE_GERROR (app->error);
str = g_key_file_get_string (cfg, "textview", "link_color", &app->error);
if (app->error != NULL)
app->link = g_strdup ("#0000ff");
else
app->link = str;
FREE_GERROR(app->error);
str = g_key_file_get_string (cfg, "textview", "browser", &app->error);
if (app->error == NULL)
app->browser = str;
else
app->browser = g_strdup ("xdg-open \"%s\"");
FREE_GERROR(app->error);
gtk_widget_modify_font (app->view, app->font);
gtk_widget_modify_text (app->view, GTK_STATE_NORMAL, &app->fg);
gtk_widget_modify_base (app->view, GTK_STATE_NORMAL, &app->bg);
g_object_set (app->tag, "foreground", app->link, NULL);
gint value = g_key_file_get_integer (cfg, "textview", "word_wrap",
&app->error);
if (app->error == NULL)
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (app->view), value);
FREE_GERROR (app->error);
value = g_key_file_get_integer (cfg, "textview", "left_margin",
&app->error);
if (app->error == NULL)
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (app->view), value);
FREE_GERROR (app->error);
value = g_key_file_get_integer (cfg, "textview", "right_margin",
&app->error);
if (app->error == NULL)
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (app->view), value);
FREE_GERROR (app->error);
value = g_key_file_get_integer (cfg, "textview", "pixels_above_lines",
&app->error);
if (app->error == NULL)
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (app->view), value);
FREE_GERROR (app->error);
value = g_key_file_get_integer (cfg, "textview", "pixels_below_lines",
&app->error);
if (app->error == NULL)
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (app->view), value);
FREE_GERROR (app->error);
g_key_file_free (cfg);
}
static void main_window_monitors_changed_cb (MainWindow* self, GdkScreen* screen) {
GdkScreen* _tmp0_;
gint _tmp1_ = 0;
GdkScreen* _tmp2_;
gint _tmp3_ = 0;
Background* _tmp34_;
GList* _tmp35_;
GdkScreen* _tmp36_;
gint _tmp37_ = 0;
GdkScreen* _tmp38_;
gint _tmp39_ = 0;
GList* _tmp40_;
gconstpointer _tmp41_ = NULL;
g_return_if_fail (self != NULL);
g_return_if_fail (screen != NULL);
_tmp0_ = screen;
_tmp1_ = gdk_screen_get_width (_tmp0_);
_tmp2_ = screen;
_tmp3_ = gdk_screen_get_height (_tmp2_);
g_debug ("main-window.vala:181: Screen is %dx%d pixels", _tmp1_, _tmp3_);
__g_list_free__monitor_unref0_0 (self->priv->monitors);
self->priv->monitors = NULL;
{
gint i;
i = 0;
{
gboolean _tmp4_;
_tmp4_ = TRUE;
while (TRUE) {
gboolean _tmp5_;
gint _tmp7_;
GdkScreen* _tmp8_;
gint _tmp9_ = 0;
GdkRectangle geometry = {0};
GdkScreen* _tmp10_;
gint _tmp11_;
GdkRectangle _tmp12_ = {0};
gint _tmp13_;
GdkRectangle _tmp14_;
gint _tmp15_;
GdkRectangle _tmp16_;
gint _tmp17_;
GdkRectangle _tmp18_;
gint _tmp19_;
GdkRectangle _tmp20_;
gint _tmp21_;
GdkScreen* _tmp22_;
gint _tmp23_;
gboolean _tmp24_ = FALSE;
_tmp5_ = _tmp4_;
if (!_tmp5_) {
gint _tmp6_;
_tmp6_ = i;
i = _tmp6_ + 1;
}
_tmp4_ = FALSE;
_tmp7_ = i;
_tmp8_ = screen;
_tmp9_ = gdk_screen_get_n_monitors (_tmp8_);
if (!(_tmp7_ < _tmp9_)) {
break;
}
_tmp10_ = screen;
_tmp11_ = i;
gdk_screen_get_monitor_geometry (_tmp10_, _tmp11_, &_tmp12_);
geometry = _tmp12_;
_tmp13_ = i;
_tmp14_ = geometry;
_tmp15_ = _tmp14_.width;
_tmp16_ = geometry;
_tmp17_ = _tmp16_.height;
_tmp18_ = geometry;
_tmp19_ = _tmp18_.x;
_tmp20_ = geometry;
_tmp21_ = _tmp20_.y;
g_debug ("main-window.vala:187: Monitor %d is %dx%d pixels at %d,%d", _tmp13_, _tmp15_, _tmp17_, _tmp19_, _tmp21_);
_tmp22_ = screen;
_tmp23_ = i;
_tmp24_ = main_window_monitor_is_unique_position (self, _tmp22_, _tmp23_);
if (_tmp24_) {
GdkRectangle _tmp25_;
gint _tmp26_;
GdkRectangle _tmp27_;
gint _tmp28_;
GdkRectangle _tmp29_;
gint _tmp30_;
GdkRectangle _tmp31_;
gint _tmp32_;
Monitor* _tmp33_;
_tmp25_ = geometry;
_tmp26_ = _tmp25_.x;
_tmp27_ = geometry;
_tmp28_ = _tmp27_.y;
_tmp29_ = geometry;
_tmp30_ = _tmp29_.width;
_tmp31_ = geometry;
_tmp32_ = _tmp31_.height;
_tmp33_ = monitor_new (_tmp26_, _tmp28_, _tmp30_, _tmp32_);
self->priv->monitors = g_list_append (self->priv->monitors, _tmp33_);
}
}
}
}
_tmp34_ = self->priv->background;
_tmp35_ = self->priv->monitors;
background_set_monitors (_tmp34_, _tmp35_);
_tmp36_ = screen;
_tmp37_ = gdk_screen_get_width (_tmp36_);
_tmp38_ = screen;
_tmp39_ = gdk_screen_get_height (_tmp38_);
gtk_window_resize ((GtkWindow*) self, _tmp37_, _tmp39_);
gtk_window_move ((GtkWindow*) self, 0, 0);
_tmp40_ = self->priv->monitors;
_tmp41_ = g_list_nth_data (_tmp40_, (guint) 0);
main_window_move_to_monitor (self, (Monitor*) _tmp41_);
}
void minimize_win_pho()
{
gtk_window_resize(GTK_WINDOW(gwin_pho), 1, 1);
}
static void
gimp_tag_popup_constructed (GObject *object)
{
GimpTagPopup *popup = GIMP_TAG_POPUP (object);
GimpTaggedContainer *container;
GtkWidget *entry;
GtkAllocation entry_allocation;
GtkStyle *frame_style;
gint x;
gint y;
gint width;
gint height;
gint popup_height;
GHashTable *tag_hash;
GList *tag_list;
GList *tag_iterator;
gint i;
gint max_height;
gint screen_height;
gchar **current_tags;
gint current_count;
GdkRectangle popup_rects[2]; /* variants of popup placement */
GdkRectangle popup_rect; /* best popup rect in screen coordinates */
if (G_OBJECT_CLASS (parent_class)->constructed)
G_OBJECT_CLASS (parent_class)->constructed (object);
entry = GTK_WIDGET (popup->combo_entry);
gtk_window_set_screen (GTK_WINDOW (popup), gtk_widget_get_screen (entry));
popup->context = gtk_widget_create_pango_context (GTK_WIDGET (popup));
popup->layout = pango_layout_new (popup->context);
gtk_widget_get_allocation (entry, &entry_allocation);
gtk_widget_style_get (GTK_WIDGET (popup),
"scroll-arrow-vlength", &popup->scroll_arrow_height,
NULL);
pango_layout_set_attributes (popup->layout,
popup->combo_entry->normal_item_attr);
current_tags = gimp_tag_entry_parse_tags (GIMP_TAG_ENTRY (popup->combo_entry));
current_count = g_strv_length (current_tags);
container = GIMP_TAG_ENTRY (popup->combo_entry)->container;
tag_hash = container->tag_ref_counts;
tag_list = g_hash_table_get_keys (tag_hash);
tag_list = g_list_sort (tag_list, gimp_tag_compare_func);
popup->tag_count = g_list_length (tag_list);
popup->tag_data = g_new0 (PopupTagData, popup->tag_count);
for (i = 0, tag_iterator = tag_list;
i < popup->tag_count;
i++, tag_iterator = g_list_next (tag_iterator))
{
PopupTagData *tag_data = &popup->tag_data[i];
gint j;
tag_data->tag = tag_iterator->data;
tag_data->state = GTK_STATE_NORMAL;
for (j = 0; j < current_count; j++)
{
if (! gimp_tag_compare_with_string (tag_data->tag, current_tags[j]))
{
tag_data->state = GTK_STATE_SELECTED;
break;
}
}
}
g_list_free (tag_list);
g_strfreev (current_tags);
if (GIMP_TAG_ENTRY (popup->combo_entry)->mode == GIMP_TAG_ENTRY_MODE_QUERY)
{
for (i = 0; i < popup->tag_count; i++)
{
if (popup->tag_data[i].state != GTK_STATE_SELECTED)
{
popup->tag_data[i].state = GTK_STATE_INSENSITIVE;
}
}
gimp_container_foreach (GIMP_CONTAINER (container),
(GFunc) gimp_tag_popup_check_can_toggle,
popup);
}
frame_style = gtk_widget_get_style (popup->frame);
width = (entry_allocation.width -
2 * frame_style->xthickness);
height = (gimp_tag_popup_layout_tags (popup, width) +
2 * frame_style->ythickness);
gdk_window_get_origin (gtk_widget_get_window (entry), &x, &y);
max_height = entry_allocation.height * 10;
screen_height = gdk_screen_get_height (gtk_widget_get_screen (entry));
popup_height = MIN (height, max_height);
popup_rects[0].x = x;
popup_rects[0].y = 0;
popup_rects[0].width = entry_allocation.width;
popup_rects[0].height = y + entry_allocation.height;
popup_rects[1].x = x;
popup_rects[1].y = y;
popup_rects[1].width = popup_rects[0].width;
popup_rects[1].height = screen_height - popup_rects[0].height;
if (popup_rects[0].height >= popup_height)
{
popup_rect = popup_rects[0];
popup_rect.y += popup_rects[0].height - popup_height;
popup_rect.height = popup_height;
}
else if (popup_rects[1].height >= popup_height)
{
popup_rect = popup_rects[1];
popup_rect.height = popup_height;
}
else
{
if (popup_rects[0].height >= popup_rects[1].height)
{
popup_rect = popup_rects[0];
popup_rect.y += popup->scroll_arrow_height + frame_style->ythickness;
}
else
{
popup_rect = popup_rects[1];
popup_rect.y -= popup->scroll_arrow_height + frame_style->ythickness;
}
popup_height = popup_rect.height;
}
if (popup_height < height)
{
popup->arrows_visible = TRUE;
popup->upper_arrow_state = GTK_STATE_INSENSITIVE;
gtk_alignment_set_padding (GTK_ALIGNMENT (popup->alignment),
popup->scroll_arrow_height + 2,
popup->scroll_arrow_height + 2, 0, 0);
popup_height -= 2 * popup->scroll_arrow_height + 4;
popup->scroll_height = height - popup_rect.height;
popup->scroll_y = 0;
popup->scroll_step = 0;
}
gtk_widget_set_size_request (popup->tag_area, width, popup_height);
gtk_window_move (GTK_WINDOW (popup), popup_rect.x, popup_rect.y);
gtk_window_resize (GTK_WINDOW (popup), popup_rect.width, popup_rect.height);
}
/*
* GUI initialization
* args:
* width - window width
* height - window height
*
* asserts:
* none
*
* returns: error code (0 -OK)
*/
int gui_attach_gtk3(int width, int height)
{
if(!gtk_init_called)
{
if(!gtk_init_check(NULL, NULL))
{
fprintf(stderr, "GUVCVIEW: (GUI) Gtk3 can't open display\n");
return -1;
}
gtk_init_called = 1;
}
/*check for device errors*/
//if(!device)
//{
// gui_error("Guvcview error", "no video device found", 1);
// return -1;
//}
g_set_application_name(_("Guvcview Video Capture"));
#if !GTK_VER_AT_LEAST(3,12)
/* make sure the type is realized so that we can change the properties*/
g_type_class_unref (g_type_class_ref (GTK_TYPE_BUTTON));
/* make sure gtk-button-images property is set to true (defaults to false in karmic)*/
g_object_set (gtk_settings_get_default (), "gtk-button-images", TRUE, NULL);
#endif
/* Create a main window */
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (main_window), _("Guvcview"));
gtk_widget_show (main_window);
/* get screen resolution */
GdkScreen* screen = NULL;
screen = gtk_window_get_screen(GTK_WINDOW(main_window));
int desktop_width = gdk_screen_get_width(screen);
int desktop_height = gdk_screen_get_height(screen);
if(debug_level > 0)
printf("GUVCVIEW: (GUI) Screen resolution is (%d x %d)\n", desktop_width, desktop_height);
if((width > desktop_width) && (desktop_width > 0))
width = desktop_width;
if((height > desktop_height) && (desktop_height > 0))
height = desktop_height;
gtk_window_resize(GTK_WINDOW(main_window), width, height);
/* Add delete event handler */
g_signal_connect(GTK_WINDOW(main_window), "delete_event", G_CALLBACK(delete_event), NULL);
/*window icon*/
char* icon1path = g_strconcat (PACKAGE_DATA_DIR, "/pixmaps/guvcview/guvcview.png", NULL);
if (g_file_test(icon1path, G_FILE_TEST_EXISTS))
gtk_window_set_icon_from_file(GTK_WINDOW (main_window), icon1path, NULL);
g_free(icon1path);
/*---------------------------- Main table ---------------------------------*/
GtkWidget *maintable = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (maintable);
/*----------------------------- Top Menu ----------------------------------*/
gui_attach_gtk3_menu(maintable);
/*----------------------------- Buttons -----------------------------------*/
GtkWidget *HButtonBox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_widget_set_halign (HButtonBox, GTK_ALIGN_FILL);
gtk_widget_set_hexpand (HButtonBox, TRUE);
gtk_button_box_set_layout(GTK_BUTTON_BOX(HButtonBox),GTK_BUTTONBOX_SPREAD);
gtk_box_set_homogeneous(GTK_BOX(HButtonBox),TRUE);
gtk_widget_show(HButtonBox);
/*photo button*/
if(check_photo_timer())
{
CapImageButt = gtk_button_new_with_mnemonic (_("Stop Cap. (I)"));
g_object_set_data (G_OBJECT (CapImageButt), "control_info",
GINT_TO_POINTER(1));
}
else
{
CapImageButt = gtk_button_new_with_mnemonic (_("Cap. Image (I)"));
g_object_set_data (G_OBJECT (CapImageButt), "control_info",
GINT_TO_POINTER(0));
}
char *pix2path = g_strconcat (PACKAGE_DATA_DIR, "/pixmaps/guvcview/camera.png",NULL);
if (g_file_test(pix2path, G_FILE_TEST_EXISTS))
{
GtkWidget *ImgButton_Img = gtk_image_new_from_file (pix2path);
#if GTK_VER_AT_LEAST(3,12)
gtk_button_set_always_show_image(GTK_BUTTON(CapImageButt), TRUE);
#endif
gtk_button_set_image(GTK_BUTTON(CapImageButt), ImgButton_Img);
gtk_button_set_image_position(GTK_BUTTON(CapImageButt), GTK_POS_TOP);
}
g_free(pix2path);
gtk_box_pack_start(GTK_BOX(HButtonBox), CapImageButt, TRUE, TRUE, 2);
gtk_widget_show (CapImageButt);
g_signal_connect (GTK_BUTTON(CapImageButt), "clicked",
G_CALLBACK (capture_image_clicked), NULL);
/*video button*/
CapVideoButt = gtk_toggle_button_new_with_mnemonic (_("Cap. Video (V)"));
gui_set_video_capture_button_status_gtk3(get_encoder_status());
char *pix3path = g_strconcat (PACKAGE_DATA_DIR, "/pixmaps/guvcview/movie.png",NULL);
if (g_file_test(pix3path, G_FILE_TEST_EXISTS))
{
GtkWidget *VideoButton_Img = gtk_image_new_from_file (pix3path);
#if GTK_VER_AT_LEAST(3,12)
gtk_button_set_always_show_image(GTK_BUTTON(CapVideoButt), TRUE);
#endif
gtk_button_set_image(GTK_BUTTON(CapVideoButt), VideoButton_Img);
gtk_button_set_image_position(GTK_BUTTON(CapVideoButt), GTK_POS_TOP);
}
g_free(pix3path);
gtk_box_pack_start(GTK_BOX(HButtonBox), CapVideoButt, TRUE, TRUE, 2);
gtk_widget_show (CapVideoButt);
g_signal_connect (GTK_BUTTON(CapVideoButt), "clicked",
G_CALLBACK (capture_video_clicked), NULL);
/*quit button*/
//GtkWidget *quitButton = gtk_button_new_from_stock(GTK_STOCK_QUIT);
GtkWidget *quitButton = gtk_button_new_with_mnemonic (_("Quit"));
char* pix4path = g_strconcat (PACKAGE_DATA_DIR, "/pixmaps/guvcview/close.png", NULL);
if (g_file_test(pix4path,G_FILE_TEST_EXISTS))
{
GtkWidget *QButton_Img = gtk_image_new_from_file (pix4path);
#if GTK_VER_AT_LEAST(3,12)
gtk_button_set_always_show_image(GTK_BUTTON(quitButton), TRUE);
#endif
gtk_button_set_image(GTK_BUTTON(quitButton), QButton_Img);
gtk_button_set_image_position(GTK_BUTTON(quitButton), GTK_POS_TOP);
}
/*must free path strings*/
g_free(pix4path);
gtk_box_pack_start(GTK_BOX(HButtonBox), quitButton, TRUE, TRUE, 2);
gtk_widget_show_all (quitButton);
g_signal_connect (GTK_BUTTON(quitButton), "clicked",
G_CALLBACK (quit_button_clicked), NULL);
gtk_box_pack_start(GTK_BOX(maintable), HButtonBox, FALSE, TRUE, 2);
/*--------------------------- Tab container -------------------------------*/
GtkWidget *tab_box = gtk_notebook_new();
gtk_widget_show (tab_box);
/*------------------------ Image controls Tab -----------------------------*/
GtkWidget *scroll_1 = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(scroll_1), GTK_CORNER_TOP_LEFT);
gtk_widget_show(scroll_1);
/*
* viewport is only needed for gtk < 3.8
* for 3.8 and above controls tab can be directly added to scroll1
*/
GtkWidget* viewport = gtk_viewport_new(NULL,NULL);
gtk_widget_show(viewport);
gtk_container_add(GTK_CONTAINER(scroll_1), viewport);
gui_attach_gtk3_v4l2ctrls(viewport);
GtkWidget *tab_1 = gtk_grid_new();
gtk_widget_show (tab_1);
GtkWidget *tab_1_label = gtk_label_new(_("Image Controls"));
gtk_widget_show (tab_1_label);
/** check for files */
gchar *tab_1_icon_path = g_strconcat (PACKAGE_DATA_DIR,"/pixmaps/guvcview/image_controls.png",NULL);
/** don't test for file - use default empty image if load fails */
/** get icon image*/
GtkWidget *tab_1_icon = gtk_image_new_from_file(tab_1_icon_path);
gtk_widget_show (tab_1_icon);
g_free(tab_1_icon_path);
gtk_grid_attach (GTK_GRID(tab_1), tab_1_icon, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID(tab_1), tab_1_label, 1, 0, 1, 1);
gtk_notebook_append_page(GTK_NOTEBOOK(tab_box), scroll_1, tab_1);
/*----------------------------H264 Controls Tab --------------------------*/
if(v4l2core_get_h264_unit_id(get_v4l2_device_handler()) > 0)
{
GtkWidget *scroll_2 = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(scroll_2), GTK_CORNER_TOP_LEFT);
gtk_widget_show(scroll_2);
/*
* viewport is only needed for gtk < 3.8
* for 3.8 and above controls tab can be directly added to scroll1
*/
GtkWidget* viewport2 = gtk_viewport_new(NULL,NULL);
gtk_widget_show(viewport2);
gtk_container_add(GTK_CONTAINER(scroll_2), viewport2);
gui_attach_gtk3_h264ctrls(viewport2);
GtkWidget *tab_2 = gtk_grid_new();
gtk_widget_show (tab_2);
GtkWidget *tab_2_label = gtk_label_new(_("H264 Controls"));
gtk_widget_show (tab_2_label);
/** check for files */
gchar *tab_2_icon_path = g_strconcat (PACKAGE_DATA_DIR,"/pixmaps/guvcview/image_controls.png",NULL);
/** don't test for file - use default empty image if load fails */
/** get icon image*/
GtkWidget *tab_2_icon = gtk_image_new_from_file(tab_2_icon_path);
gtk_widget_show (tab_2_icon);
g_free(tab_2_icon_path);
gtk_grid_attach (GTK_GRID(tab_2), tab_2_icon, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID(tab_2), tab_2_label, 1, 0, 1, 1);
gtk_notebook_append_page(GTK_NOTEBOOK(tab_box), scroll_2, tab_2);
}
/*exclude video and audio tabs if we are in control panel mode*/
if(!is_control_panel)
{
/*----------------------- Video controls Tab ------------------------------*/
GtkWidget *scroll_3 = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(scroll_3), GTK_CORNER_TOP_LEFT);
gtk_widget_show(scroll_3);
/*
* viewport is only needed for gtk < 3.8
* for 3.8 and above controls tab can be directly added to scroll1
*/
GtkWidget* viewport3 = gtk_viewport_new(NULL,NULL);
gtk_widget_show(viewport3);
gtk_container_add(GTK_CONTAINER(scroll_3), viewport3);
gui_attach_gtk3_videoctrls(viewport3);
GtkWidget *tab_3 = gtk_grid_new();
gtk_widget_show (tab_3);
GtkWidget *tab_3_label = gtk_label_new(_("Video Controls"));
gtk_widget_show (tab_3_label);
/** check for files */
gchar *tab_3_icon_path = g_strconcat (PACKAGE_DATA_DIR,"/pixmaps/guvcview/video_controls.png",NULL);
/** don't test for file - use default empty image if load fails */
/** get icon image*/
GtkWidget *tab_3_icon = gtk_image_new_from_file(tab_3_icon_path);
gtk_widget_show (tab_3_icon);
g_free(tab_3_icon_path);
gtk_grid_attach (GTK_GRID(tab_3), tab_3_icon, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID(tab_3), tab_3_label, 1, 0, 1, 1);
gtk_notebook_append_page(GTK_NOTEBOOK(tab_box), scroll_3, tab_3);
/*----------------------- Audio controls Tab ------------------------------*/
GtkWidget *scroll_4 = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_placement(GTK_SCROLLED_WINDOW(scroll_4), GTK_CORNER_TOP_LEFT);
gtk_widget_show(scroll_4);
/*
* viewport is only needed for gtk < 3.8
* for 3.8 and above controls tab can be directly added to scroll1
*/
GtkWidget* viewport4 = gtk_viewport_new(NULL,NULL);
gtk_widget_show(viewport4);
gtk_container_add(GTK_CONTAINER(scroll_4), viewport4);
gui_attach_gtk3_audioctrls(viewport4);
GtkWidget *tab_4 = gtk_grid_new();
gtk_widget_show (tab_4);
GtkWidget *tab_4_label = gtk_label_new(_("Audio Controls"));
gtk_widget_show (tab_4_label);
/** check for files */
gchar *tab_4_icon_path = g_strconcat (PACKAGE_DATA_DIR,"/pixmaps/guvcview/audio_controls.png",NULL);
/** don't test for file - use default empty image if load fails */
/** get icon image*/
GtkWidget *tab_4_icon = gtk_image_new_from_file(tab_4_icon_path);
gtk_widget_show (tab_4_icon);
g_free(tab_4_icon_path);
gtk_grid_attach (GTK_GRID(tab_4), tab_4_icon, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID(tab_4), tab_4_label, 1, 0, 1, 1);
gtk_notebook_append_page(GTK_NOTEBOOK(tab_box), scroll_4, tab_4);
}
/* Attach the notebook (tabs) */
gtk_box_pack_start(GTK_BOX(maintable), tab_box, TRUE, TRUE, 2);
/*-------------------------- Status bar ------------------------------------*/
status_bar = gtk_statusbar_new();
status_warning_id = gtk_statusbar_get_context_id (GTK_STATUSBAR(status_bar), "warning");
gtk_widget_show(status_bar);
/* add the status bar*/
gtk_box_pack_start(GTK_BOX(maintable), status_bar, FALSE, FALSE, 2);
/* attach to main window container */
gtk_container_add (GTK_CONTAINER (main_window), maintable);
/* add key events*/
gtk_widget_add_events (GTK_WIDGET (main_window), GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
g_signal_connect (GTK_WINDOW(main_window), "key_press_event", G_CALLBACK(window_key_pressed), NULL);
/* add update timers:
* devices
*/
gtk_devices_timer_id = g_timeout_add( 1000, check_device_events, NULL);
/*controls*/
gtk_control_events_timer_id = g_timeout_add(1000, check_control_events, NULL);
return 0;
}
/* surfer_resize */
void surfer_resize(Surfer * surfer, gint width, gint height)
{
HTMLApp * htmlapp = surfer;
gtk_window_resize(GTK_WINDOW(htmlapp->window), width, height);
}
int
main(int argc, char *argv[])
{
signal_user_data_t *ud;
GError *error = NULL;
GOptionContext *context;
#if defined(_WIN32)
// Tell gdk pixbuf where it's loader config file is.
_putenv_s("GDK_PIXBUF_MODULE_FILE", "ghb.exe.local/loaders.cache");
_putenv_s("GST_PLUGIN_PATH", "lib/gstreamer-1.0");
#endif
hb_global_init();
#ifdef ENABLE_NLS
bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
#endif
context = g_option_context_new(_("- Transcode media formats"));
g_option_context_add_main_entries(context, entries, GETTEXT_PACKAGE);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
#if defined(_ENABLE_GST)
g_option_context_add_group(context, gst_init_get_option_group());
#endif
g_option_context_parse(context, &argc, &argv, &error);
if (error != NULL)
{
g_warning("%s: %s", G_STRFUNC, error->message);
g_clear_error(&error);
}
g_option_context_free(context);
#if defined(_WIN32)
if (win32_console)
{
// Enable console logging
if(AttachConsole(ATTACH_PARENT_PROCESS) || AllocConsole()){
close(STDOUT_FILENO);
freopen("CONOUT$", "w", stdout);
close(STDERR_FILENO);
freopen("CONOUT$", "w", stderr);
}
}
else
{
// Non-console windows apps do not have a stderr->_file
// assigned properly
stderr->_file = STDERR_FILENO;
stdout->_file = STDOUT_FILENO;
}
#endif
if (argc > 1 && dvd_device == NULL && argv[1][0] != '-')
{
dvd_device = argv[1];
}
gtk_init(&argc, &argv);
GtkCssProvider *css = gtk_css_provider_new();
error = NULL;
gtk_css_provider_load_from_data(css, MyCSS, -1, &error);
if (error == NULL)
{
GdkScreen *ss = gdk_screen_get_default();
gtk_style_context_add_provider_for_screen(ss, GTK_STYLE_PROVIDER(css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
else
{
g_warning("%s: %s", G_STRFUNC, error->message);
g_clear_error(&error);
}
#if !defined(_WIN32)
notify_init("HandBrake");
#endif
ghb_resource_init();
ghb_load_icons();
#if !defined(_WIN32)
dbus_g_thread_init();
#endif
ghb_udev_init();
ghb_write_pid_file();
ud = g_malloc0(sizeof(signal_user_data_t));
ud->debug = ghb_debug;
g_log_set_handler(NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud);
g_log_set_handler("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud);
//g_log_set_handler("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud);
ud->globals = ghb_dict_new();
ud->prefs = ghb_dict_new();
ud->settings_array = ghb_array_new();
ud->settings = ghb_dict_new();
ghb_array_append(ud->settings_array, ud->settings);
ud->builder = create_builder_or_die(BUILDER_NAME);
// Enable events that alert us to media change events
watch_volumes(ud);
//GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom");
//gtk_entry_set_inner_border(widget, 2);
// Since GtkBuilder no longer assigns object ids to widget names
// Assign a few that are necessary for style overrides to work
#if defined(_NO_UPDATE_CHECK)
GtkWidget *widget;
widget = GHB_WIDGET(ud->builder, "check_updates_box");
gtk_widget_hide(widget);
#endif
// Must set the names of the widgets that I want to modify
// style for.
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_hud"), "preview_hud");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_frame"), "preview_frame");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_preview_play"), "live_preview_play");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_preview_progress"), "live_preview_progress");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_encode_progress"), "live_encode_progress");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "live_duration"), "live_duration");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_show_crop"), "preview_show_crop");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "preview_fullscreen"), "preview_fullscreen");
gtk_widget_set_name(GHB_WIDGET(ud->builder, "activity_view"), "activity_view");
// Redirect stderr to the activity window
ghb_preview_init(ud);
IoRedirect(ud);
ghb_log( "%s - %s - %s",
HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE );
ghb_init_dep_map();
// Need to connect x264_options textview buffer to the changed signal
// since it can't be done automatically
GtkTextView *textview;
GtkTextBuffer *buffer;
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "x264Option"));
buffer = gtk_text_view_get_buffer(textview);
g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud);
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "VideoOptionExtra"));
buffer = gtk_text_view_get_buffer(textview);
g_signal_connect(buffer, "changed", (GCallback)video_option_changed_cb, ud);
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "MetaLongDescription"));
buffer = gtk_text_view_get_buffer(textview);
g_signal_connect(buffer, "changed", (GCallback)plot_changed_cb, ud);
ghb_combo_init(ud);
g_debug("ud %p\n", ud);
g_debug("ud->builder %p\n", ud->builder);
bind_audio_tree_model(ud);
bind_subtitle_tree_model(ud);
bind_presets_tree_model(ud);
bind_queue_tree_model(ud);
bind_chapter_tree_model(ud);
// Connect up the signals to their callbacks
// I wrote my own connector so that I could pass user data
// to the callbacks. Builder's standard autoconnect doesn't all this.
gtk_builder_connect_signals_full(ud->builder, MyConnect, ud);
ghb_init_audio_defaults_ui(ud);
ghb_init_subtitle_defaults_ui(ud);
// Parsing x264 options "" initializes x264 widgets to proper defaults
ghb_x264_init(ud);
// Load prefs before presets. Some preset defaults may depend
// on preference settings.
// First load default values
ghb_settings_init(ud->prefs, "Preferences");
ghb_settings_init(ud->globals, "Globals");
ghb_settings_init(ud->settings, "Initialization");
ghb_settings_init(ud->settings, "OneTimeInitialization");
// Load user preferences file
ghb_prefs_load(ud);
// Store user preferences into ud->prefs
ghb_prefs_to_settings(ud->prefs);
int logLevel = ghb_dict_get_int(ud->prefs, "LoggingLevel");
ghb_backend_init(logLevel);
// Load the presets files
ghb_presets_load(ud);
// Note that ghb_preset_to_settings(ud->settings) is called when
// the default preset is selected.
ghb_settings_to_ui(ud, ud->globals);
ghb_settings_to_ui(ud, ud->prefs);
// Note that ghb_settings_to_ui(ud->settings) happens when initial
// empty title is initialized.
if (ghb_dict_get_bool(ud->prefs, "hbfd"))
{
ghb_hbfd(ud, TRUE);
}
const gchar *source = ghb_dict_get_string(ud->prefs, "default_source");
ghb_dvd_set_current(source, ud);
// Populate the presets tree view
ghb_presets_list_init(ud, NULL);
// Get the first preset name
if (arg_preset != NULL)
{
ghb_select_preset(ud->builder, arg_preset);
}
else
{
ghb_select_default_preset(ud->builder);
}
// Grey out widgets that are dependent on a disabled feature
ghb_check_all_depencencies(ud);
if (dvd_device != NULL)
{
// Source overridden from command line option
ghb_dict_set_string(ud->globals, "scan_source", dvd_device);
g_idle_add((GSourceFunc)ghb_idle_scan, ud);
}
else
{
GhbValue *gval = ghb_dict_get_value(ud->prefs, "default_source");
ghb_dict_set(ud->globals, "scan_source", ghb_value_dup(gval));
}
// Reload and check status of the last saved queue
g_idle_add((GSourceFunc)ghb_reload_queue, ud);
// Start timer for monitoring libhb status, 500ms
g_timeout_add(200, ghb_timer_cb, (gpointer)ud);
// Add dvd devices to File menu
ghb_volname_cache_init();
GHB_THREAD_NEW("Cache Volume Names", (GThreadFunc)ghb_cache_volnames, ud);
GtkWidget *ghb_window = GHB_WIDGET(ud->builder, "hb_window");
gint window_width, window_height;
GdkGeometry geo = {
-1, -1, 1920, 768, -1, -1, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST
};
GdkWindowHints geo_mask;
geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE;
gtk_window_set_geometry_hints(GTK_WINDOW(ghb_window), ghb_window,
&geo, geo_mask);
window_width = ghb_dict_get_int(ud->prefs, "window_width");
window_height = ghb_dict_get_int(ud->prefs, "window_height");
/*
* Filter objects in GtkBuilder xml
* Unfortunately, GtkFilter is poorly supported by GtkBuilder,
* so a lot of the setup must happen in code.
SourceFilterAll
SourceFilterVideo
SourceFilterTS
SourceFilterMPG
SourceFilterEVO
SourceFilterVOB
SourceFilterMKV
SourceFilterMP4
SourceFilterAVI
SourceFilterMOV
SourceFilterOGG
SourceFilterFLV
SourceFilterWMV
*/
// Add filters to source chooser
GtkFileFilter *filter;
GtkFileChooser *chooser;
chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "source_dialog"));
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_filter_set_name(filter, _("All"));
gtk_file_filter_add_pattern(filter, "*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVideo"));
gtk_file_filter_set_name(filter, _("Video"));
gtk_file_filter_add_mime_type(filter, "video/*");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterTS"));
gtk_file_filter_set_name(filter, "TS");
gtk_file_filter_add_pattern(filter, "*.ts");
gtk_file_filter_add_pattern(filter, "*.TS");
gtk_file_filter_add_pattern(filter, "*.m2ts");
gtk_file_filter_add_pattern(filter, "*.M2TS");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMPG"));
gtk_file_filter_set_name(filter, "MPG");
gtk_file_filter_add_pattern(filter, "*.mpg");
gtk_file_filter_add_pattern(filter, "*.MPG");
gtk_file_filter_add_pattern(filter, "*.mepg");
gtk_file_filter_add_pattern(filter, "*.MEPG");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterEVO"));
gtk_file_filter_set_name(filter, "EVO");
gtk_file_filter_add_pattern(filter, "*.evo");
gtk_file_filter_add_pattern(filter, "*.EVO");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterVOB"));
gtk_file_filter_set_name(filter, "VOB");
gtk_file_filter_add_pattern(filter, "*.vob");
gtk_file_filter_add_pattern(filter, "*.VOB");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMKV"));
gtk_file_filter_set_name(filter, "MKV");
gtk_file_filter_add_pattern(filter, "*.mkv");
gtk_file_filter_add_pattern(filter, "*.MKV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMP4"));
gtk_file_filter_set_name(filter, "MP4");
gtk_file_filter_add_pattern(filter, "*.mp4");
gtk_file_filter_add_pattern(filter, "*.MP4");
gtk_file_filter_add_pattern(filter, "*.m4v");
gtk_file_filter_add_pattern(filter, "*.M4V");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterMOV"));
gtk_file_filter_set_name(filter, "MOV");
gtk_file_filter_add_pattern(filter, "*.mov");
gtk_file_filter_add_pattern(filter, "*.MOV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAVI"));
gtk_file_filter_set_name(filter, "AVI");
gtk_file_filter_add_pattern(filter, "*.avi");
gtk_file_filter_add_pattern(filter, "*.AVI");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterOGG"));
gtk_file_filter_set_name(filter, "OGG");
gtk_file_filter_add_pattern(filter, "*.ogg");
gtk_file_filter_add_pattern(filter, "*.OGG");
gtk_file_filter_add_pattern(filter, "*.ogv");
gtk_file_filter_add_pattern(filter, "*.OGV");
gtk_file_filter_add_pattern(filter, "*.ogm");
gtk_file_filter_add_pattern(filter, "*.OGM");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterFLV"));
gtk_file_filter_set_name(filter, "FLV");
gtk_file_filter_add_pattern(filter, "*.flv");
gtk_file_filter_add_pattern(filter, "*.FLV");
gtk_file_chooser_add_filter(chooser, filter);
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterWMV"));
gtk_file_filter_set_name(filter, "WMV");
gtk_file_filter_add_pattern(filter, "*.wmv");
gtk_file_filter_add_pattern(filter, "*.WMV");
gtk_file_chooser_add_filter(chooser, filter);
// Gtk has a really stupid bug. If the file chooser is showing
// hidden files AND there is no filter set, it will not select
// the filename when gtk_file_chooser_set_filename is called.
// So add a completely unnessary filter to prevent this behavior.
filter = GTK_FILE_FILTER(GHB_OBJECT(ud->builder, "SourceFilterAll"));
gtk_file_chooser_set_filter(chooser, filter);
#if !GTK_CHECK_VERSION(3, 16, 0)
PangoFontDescription *font_desc;
font_desc = pango_font_description_from_string("monospace 10");
textview = GTK_TEXT_VIEW(GHB_WIDGET(ud->builder, "activity_view"));
gtk_widget_override_font(GTK_WIDGET(textview), font_desc);
pango_font_description_free(font_desc);
#endif
// Grrrr! Gtk developers !!!hard coded!!! the width of the
// radio buttons in GtkStackSwitcher to 100!!!
//
// Thankfully, GtkStackSwitcher is a regular container object
// and we can access the buttons to change their width.
GList *stack_switcher_children, *link;
GtkContainer * stack_switcher = GTK_CONTAINER(
GHB_WIDGET(ud->builder, "SettingsStackSwitcher"));
link = stack_switcher_children = gtk_container_get_children(stack_switcher);
while (link != NULL)
{
GtkWidget *widget = link->data;
gtk_widget_set_size_request(widget, -1, -1);
gtk_widget_set_hexpand(widget, TRUE);
gtk_widget_set_halign(widget, GTK_ALIGN_FILL);
link = link->next;
}
g_list_free(stack_switcher_children);
gtk_window_resize(GTK_WINDOW(ghb_window), window_width, window_height);
gtk_widget_show(ghb_window);
// Everything should be go-to-go. Lets rock!
gtk_main();
ghb_backend_close();
ghb_value_free(&ud->queue);
ghb_value_free(&ud->settings_array);
ghb_value_free(&ud->prefs);
ghb_value_free(&ud->globals);
ghb_value_free(&ud->x264_priv);
g_io_channel_unref(ud->activity_log);
ghb_settings_close();
ghb_resource_free();
#if !defined(_WIN32)
notify_uninit();
#endif
g_object_unref(ud->builder);
g_free(ud->current_dvd_device);
g_free(ud);
return 0;
}
void unmaximize() {
gtk_window_unmaximize(GTK_WINDOW(window));
gtk_window_unfullscreen(GTK_WINDOW(window));
gtk_window_set_decorated(GTK_WINDOW(window), TRUE);
gtk_window_resize(GTK_WINDOW(window), 1280, 768);
}
int main (int argc,
char *argv[])
{
gchar *defaultfile = NULL;
GOptionContext *ctx;
GError *err = NULL;
GOptionEntry entries[] = {
{ NULL }
};
GtkWidget * recent_menu = NULL;
gchar * size_str = NULL;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
g_set_application_name (PACKAGE);
g_set_prgname (PACKAGE);
tls_init ();
g_thread_init (NULL);
gtk_init (&argc, &argv);
preferences_gui_set_csr_visible_callback (ca_update_csr_view);
preferences_gui_set_revoked_visible_callback (ca_update_revoked_view);
preferences_init (argc, argv);
ctx = g_option_context_new (_("- A graphical Certification Authority manager"));
g_option_context_add_main_entries (ctx, entries, GETTEXT_PACKAGE);
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print (_("Failed to initialize: %s\n"), err->message);
g_error_free (err);
return 1;
}
main_window_gtkb = gtk_builder_new();
gtk_builder_add_from_file (main_window_gtkb,
g_build_filename (PACKAGE_DATA_DIR, "gnomint", "main_window.ui", NULL),
NULL);
csr_popup_menu_gtkb = gtk_builder_new();
gtk_builder_add_from_file (csr_popup_menu_gtkb,
g_build_filename (PACKAGE_DATA_DIR, "gnomint", "csr_popup_menu.ui", NULL),
NULL);
cert_popup_menu_gtkb = gtk_builder_new();
gtk_builder_add_from_file (cert_popup_menu_gtkb,
g_build_filename (PACKAGE_DATA_DIR, "gnomint", "certificate_popup_menu.ui", NULL),
NULL);
size_str = preferences_get_size ();
if (size_str) {
gchar ** result = NULL;
guint width, height;
result = g_strsplit_set (size_str, "(,)", -1);
if (result[0] && result[1]) {
width = atoi (result[1]);
if (result[2]) {
height = atoi (result[2]);
gtk_window_resize (GTK_WINDOW(gtk_builder_get_object(main_window_gtkb, "main_window1")), width, height);
}
}
g_free (size_str);
g_strfreev (result);
}
ca_update_revoked_view (preferences_get_revoked_visible(), FALSE);
ca_update_csr_view (preferences_get_crq_visible(), FALSE);
gtk_builder_connect_signals (main_window_gtkb, NULL);
gtk_builder_connect_signals (cert_popup_menu_gtkb, NULL);
gtk_builder_connect_signals (csr_popup_menu_gtkb, NULL);
recent_manager = gtk_recent_manager_get_default ();
recent_menu = __recent_create_menu();
g_signal_connect (G_OBJECT (recent_menu), "item-activated",
G_CALLBACK (on_open_recent_activate), NULL);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_builder_get_object (main_window_gtkb, "openrecentsmenuitem")), recent_menu);
__disable_widget ("new_certificate1");
__disable_widget ("save_as1");
__disable_widget ("properties1");
__disable_widget ("preferences1");
dialog_establish_refresh_function (ca_refresh_model_callback);
if (argc >= 2 && ca_open (g_strdup(argv[1]), TRUE)) {
/* The file has opened OK */
__recent_add_utf8_filename (argv[1]);
} else {
/* No arguments, or failure when opening file */
defaultfile = g_build_filename (g_get_home_dir(), ".gnomint", "default.gnomint", NULL);
__recent_add_utf8_filename (defaultfile);
ca_open (defaultfile, TRUE);
}
gtk_main ();
return 0;
}
static gboolean timeout_minimize_main_window(gpointer data)
{
gtk_window_resize(GTK_WINDOW(main_window), 32, 32);
return FALSE;
}
static void
rejilla_tool_dialog_init (RejillaToolDialog *obj)
{
GtkWidget *title;
GtkWidget *content_area;
gchar *title_str;
RejillaToolDialogPrivate *priv;
priv = REJILLA_TOOL_DIALOG_PRIVATE (obj);
/* upper part */
priv->upper_box = gtk_vbox_new (FALSE, 0);
gtk_widget_show (GTK_WIDGET (priv->upper_box));
priv->selector = rejilla_medium_selection_new ();
gtk_widget_show (GTK_WIDGET (priv->selector));
title_str = g_strdup_printf ("<b>%s</b>", _("Select a disc"));
gtk_box_pack_start (GTK_BOX (priv->upper_box),
rejilla_utils_pack_properties (title_str,
priv->selector,
NULL),
FALSE, FALSE, 0);
g_free (title_str);
rejilla_medium_selection_show_media_type (REJILLA_MEDIUM_SELECTION (priv->selector),
REJILLA_MEDIA_TYPE_REWRITABLE|
REJILLA_MEDIA_TYPE_WRITABLE|
REJILLA_MEDIA_TYPE_AUDIO|
REJILLA_MEDIA_TYPE_DATA);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (obj));
gtk_box_pack_start (GTK_BOX (content_area),
priv->upper_box,
FALSE,
FALSE,
0);
/* lower part */
priv->lower_box = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (priv->lower_box), 12);
gtk_widget_set_sensitive (priv->lower_box, FALSE);
gtk_widget_show (priv->lower_box);
gtk_box_pack_start (GTK_BOX (content_area),
priv->lower_box,
FALSE,
FALSE,
0);
title_str = g_strdup_printf ("<b>%s</b>", _("Progress"));
title = gtk_label_new (title_str);
g_free (title_str);
gtk_label_set_use_markup (GTK_LABEL (title), TRUE);
gtk_misc_set_alignment (GTK_MISC (title), 0.0, 0.5);
gtk_misc_set_padding(GTK_MISC (title), 0, 6);
gtk_widget_show (title);
gtk_box_pack_start (GTK_BOX (priv->lower_box),
title,
FALSE,
FALSE,
0);
priv->progress = rejilla_burn_progress_new ();
gtk_widget_show (priv->progress);
g_object_set (G_OBJECT (priv->progress),
"show-info", FALSE,
NULL);
gtk_box_pack_start (GTK_BOX (content_area),
priv->progress,
FALSE,
FALSE,
0);
/* buttons */
priv->cancel = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_widget_show (priv->cancel);
gtk_dialog_add_action_widget (GTK_DIALOG (obj),
priv->cancel,
GTK_RESPONSE_CANCEL);
g_signal_connect (G_OBJECT (priv->selector),
"medium-changed",
G_CALLBACK (rejilla_tool_dialog_drive_changed_cb),
obj);
g_signal_connect (obj,
"response",
G_CALLBACK (rejilla_tool_dialog_response),
NULL);
gtk_window_resize (GTK_WINDOW (obj), 10, 10);
}
int iupdrvDialogSetPlacement(Ihandle* ih)
{
char* placement;
int old_state = ih->data->show_state;
ih->data->show_state = IUP_SHOW;
if (iupAttribGetBoolean(ih, "FULLSCREEN"))
{
gtk_window_fullscreen((GtkWindow*)ih->handle);
return 1;
}
placement = iupAttribGet(ih, "PLACEMENT");
if (!placement)
{
if (old_state == IUP_MAXIMIZE || old_state == IUP_MINIMIZE)
ih->data->show_state = IUP_RESTORE;
gtk_window_unmaximize((GtkWindow*)ih->handle);
gtk_window_deiconify((GtkWindow*)ih->handle);
return 0;
}
if (iupStrEqualNoCase(placement, "MINIMIZED"))
{
ih->data->show_state = IUP_MINIMIZE;
gtk_window_iconify((GtkWindow*)ih->handle);
}
else if (iupStrEqualNoCase(placement, "MAXIMIZED"))
{
ih->data->show_state = IUP_MAXIMIZE;
gtk_window_maximize((GtkWindow*)ih->handle);
}
else if (iupStrEqualNoCase(placement, "FULL"))
{
int width, height, x, y;
int border, caption, menu;
iupdrvDialogGetDecoration(ih, &border, &caption, &menu);
/* position the decoration outside the screen */
x = -(border);
y = -(border+caption+menu);
/* the dialog client area will cover the task bar */
iupdrvGetFullSize(&width, &height);
height += menu; /* menu is inside the client area. */
/* set the new size and position */
/* The resize evt will update the layout */
gtk_window_move((GtkWindow*)ih->handle, x, y);
gtk_window_resize((GtkWindow*)ih->handle, width, height);
if (old_state == IUP_MAXIMIZE || old_state == IUP_MINIMIZE)
ih->data->show_state = IUP_RESTORE;
}
iupAttribSetStr(ih, "PLACEMENT", NULL); /* reset to NORMAL */
return 1;
}
/* Create a new (empty) Sticky Note at a specific position
and with specific size */
static StickyNote *
stickynote_new_aux (GdkScreen *screen, gint x, gint y, gint w, gint h)
{
StickyNote *note;
GtkBuilder *builder;
note = g_new (StickyNote, 1);
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, BUILDER_PATH, NULL);
note->w_window = GTK_WIDGET (gtk_builder_get_object (builder, "stickynote_window"));
gtk_window_set_screen(GTK_WINDOW(note->w_window),screen);
gtk_window_set_decorated (GTK_WINDOW (note->w_window), FALSE);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (note->w_window), TRUE);
gtk_window_set_skip_pager_hint (GTK_WINDOW (note->w_window), TRUE);
gtk_widget_add_events (note->w_window, GDK_BUTTON_PRESS_MASK);
note->w_title = GTK_WIDGET (gtk_builder_get_object (builder, "title_label"));
note->w_body = GTK_WIDGET (gtk_builder_get_object (builder, "body_text"));
note->w_scroller = GTK_WIDGET (gtk_builder_get_object (builder, "body_scroller"));
note->w_lock = GTK_WIDGET (gtk_builder_get_object (builder, "lock_button"));
gtk_widget_add_events (note->w_lock, GDK_BUTTON_PRESS_MASK);
note->buffer = GTK_SOURCE_BUFFER(gtk_text_view_get_buffer(GTK_TEXT_VIEW(note->w_body)));
note->w_close = GTK_WIDGET (gtk_builder_get_object (builder, "close_button"));
gtk_widget_add_events (note->w_close, GDK_BUTTON_PRESS_MASK);
note->w_resize_se = GTK_WIDGET (gtk_builder_get_object (builder, "resize_se_box"));
gtk_widget_add_events (note->w_resize_se, GDK_BUTTON_PRESS_MASK);
note->w_resize_sw = GTK_WIDGET (gtk_builder_get_object (builder, "resize_sw_box"));
gtk_widget_add_events (note->w_resize_sw, GDK_BUTTON_PRESS_MASK);
note->img_lock = GTK_IMAGE (gtk_builder_get_object (builder,
"lock_img"));
note->img_close = GTK_IMAGE (gtk_builder_get_object (builder,
"close_img"));
note->img_resize_se = GTK_IMAGE (gtk_builder_get_object (builder,
"resize_se_img"));
note->img_resize_sw = GTK_IMAGE (gtk_builder_get_object (builder,
"resize_sw_img"));
/* deal with RTL environments */
gtk_widget_set_direction (GTK_WIDGET (gtk_builder_get_object (builder, "resize_bar")),
GTK_TEXT_DIR_LTR);
note->w_menu = GTK_WIDGET (gtk_builder_get_object (builder, "stickynote_menu"));
note->ta_lock_toggle_item = GTK_TOGGLE_ACTION (gtk_builder_get_object (builder,
"popup_toggle_lock"));
note->w_properties = GTK_WIDGET (gtk_builder_get_object (builder,
"stickynote_properties"));
gtk_window_set_screen (GTK_WINDOW (note->w_properties), screen);
note->w_entry = GTK_WIDGET (gtk_builder_get_object (builder, "title_entry"));
note->w_color = GTK_WIDGET (gtk_builder_get_object (builder, "note_color"));
note->w_color_label = GTK_WIDGET (gtk_builder_get_object (builder, "color_label"));
note->w_font_color = GTK_WIDGET (gtk_builder_get_object (builder, "font_color"));
note->w_font_color_label = GTK_WIDGET (gtk_builder_get_object (builder,
"font_color_label"));
note->w_font = GTK_WIDGET (gtk_builder_get_object (builder, "note_font"));
note->w_font_label = GTK_WIDGET (gtk_builder_get_object (builder, "font_label"));
note->w_def_color = GTK_WIDGET (>K_CHECK_BUTTON (
gtk_builder_get_object (builder,
"def_color_check"))->toggle_button);
note->w_def_font = GTK_WIDGET (>K_CHECK_BUTTON (
gtk_builder_get_object (builder,
"def_font_check"))->toggle_button);
note->color = NULL;
note->font_color = NULL;
note->font = NULL;
note->locked = FALSE;
note->x = x;
note->y = y;
note->w = w;
note->h = h;
/* Customize the window */
if (g_settings_get_boolean (stickynotes->settings, "sticky"))
gtk_window_stick(GTK_WINDOW(note->w_window));
if (w == 0 || h == 0)
gtk_window_resize (GTK_WINDOW(note->w_window),
g_settings_get_int (stickynotes->settings, "default-width"),
g_settings_get_int (stickynotes->settings, "default-height"));
else
gtk_window_resize (GTK_WINDOW(note->w_window),
note->w,
note->h);
if (x != -1 && y != -1)
gtk_window_move (GTK_WINDOW(note->w_window),
note->x,
note->y);
/* Set the button images */
gtk_image_set_from_icon_name (note->img_close, STICKYNOTES_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_image_set_pixel_size (note->img_close, STICKYNOTES_ICON_SIZE);
gtk_image_set_from_icon_name (note->img_resize_se, STICKYNOTES_STOCK_RESIZE_SE, GTK_ICON_SIZE_MENU);
gtk_image_set_pixel_size (note->img_resize_se, STICKYNOTES_ICON_SIZE);
gtk_image_set_from_icon_name (note->img_resize_sw, STICKYNOTES_STOCK_RESIZE_SW, GTK_ICON_SIZE_MENU);
gtk_image_set_pixel_size (note->img_resize_sw, STICKYNOTES_ICON_SIZE);
gtk_widget_show(note->w_lock);
gtk_widget_show(note->w_close);
gtk_widget_show(GTK_WIDGET (gtk_builder_get_object (builder, "resize_bar")));
/* Customize the title and colors, hide and unlock */
stickynote_set_title(note, NULL);
stickynote_set_color(note, NULL, NULL, TRUE);
stickynote_set_font(note, NULL, TRUE);
stickynote_set_locked(note, FALSE);
gtk_widget_realize (note->w_window);
/* Connect a popup menu to all buttons and title */
/* GtkBuilder holds and drops the references to all the widgets it
* creates for as long as it exist (GtkBuilder). Hence in our callback
* we would have an invalid GtkMenu. We need to ref it.
*/
g_object_ref (note->w_menu);
g_signal_connect (G_OBJECT (note->w_window), "button-press-event",
G_CALLBACK (stickynote_show_popup_menu), note->w_menu);
g_signal_connect (G_OBJECT (note->w_lock), "button-press-event",
G_CALLBACK (stickynote_show_popup_menu), note->w_menu);
g_signal_connect (G_OBJECT (note->w_close), "button-press-event",
G_CALLBACK (stickynote_show_popup_menu), note->w_menu);
g_signal_connect (G_OBJECT (note->w_resize_se), "button-press-event",
G_CALLBACK (stickynote_show_popup_menu), note->w_menu);
g_signal_connect (G_OBJECT (note->w_resize_sw), "button-press-event",
G_CALLBACK (stickynote_show_popup_menu), note->w_menu);
/* Connect a properties dialog to the note */
gtk_window_set_transient_for (GTK_WINDOW(note->w_properties),
GTK_WINDOW(note->w_window));
gtk_dialog_set_default_response (GTK_DIALOG(note->w_properties),
GTK_RESPONSE_CLOSE);
g_signal_connect (G_OBJECT (note->w_properties), "response",
G_CALLBACK (response_cb), note);
/* Connect signals to the sticky note */
g_signal_connect (G_OBJECT (note->w_lock), "clicked",
G_CALLBACK (stickynote_toggle_lock_cb), note);
g_signal_connect (G_OBJECT (note->w_close), "clicked",
G_CALLBACK (stickynote_close_cb), note);
g_signal_connect (G_OBJECT (note->w_resize_se), "button-press-event",
G_CALLBACK (stickynote_resize_cb), note);
g_signal_connect (G_OBJECT (note->w_resize_sw), "button-press-event",
G_CALLBACK (stickynote_resize_cb), note);
g_signal_connect (G_OBJECT (note->w_window), "button-press-event",
G_CALLBACK (stickynote_move_cb), note);
g_signal_connect (G_OBJECT (note->w_window), "configure-event",
G_CALLBACK (stickynote_configure_cb), note);
g_signal_connect (G_OBJECT (note->w_window), "delete-event",
G_CALLBACK (stickynote_delete_cb), note);
g_signal_connect (gtk_builder_get_object (builder,
"popup_create"), "activate",
G_CALLBACK (popup_create_cb), note);
g_signal_connect (gtk_builder_get_object (builder,
"popup_destroy"), "activate",
G_CALLBACK (popup_destroy_cb), note);
g_signal_connect (gtk_builder_get_object (builder,
"popup_toggle_lock"), "toggled",
G_CALLBACK (popup_toggle_lock_cb), note);
g_signal_connect (gtk_builder_get_object (builder,
"popup_properties"), "activate",
G_CALLBACK (popup_properties_cb), note);
g_signal_connect_swapped (G_OBJECT (note->w_entry), "changed",
G_CALLBACK (properties_apply_title_cb), note);
g_signal_connect (G_OBJECT (note->w_color), "color-set",
G_CALLBACK (properties_color_cb), note);
g_signal_connect (G_OBJECT (note->w_font_color), "color-set",
G_CALLBACK (properties_color_cb), note);
g_signal_connect_swapped (G_OBJECT (note->w_def_color), "toggled",
G_CALLBACK (properties_apply_color_cb), note);
g_signal_connect (G_OBJECT (note->w_font), "font-set",
G_CALLBACK (properties_font_cb), note);
g_signal_connect_swapped (G_OBJECT (note->w_def_font), "toggled",
G_CALLBACK (properties_apply_font_cb), note);
g_signal_connect (G_OBJECT (note->w_entry), "activate",
G_CALLBACK (properties_activate_cb), note);
g_signal_connect (G_OBJECT (note->w_properties), "delete-event",
G_CALLBACK (gtk_widget_hide), note);
g_object_unref(builder);
g_signal_connect_after (note->w_body, "button-press-event",
G_CALLBACK (gtk_true), note);
g_signal_connect (gtk_text_view_get_buffer(GTK_TEXT_VIEW(note->w_body)),
"changed",
G_CALLBACK (buffer_changed), note);
return note;
}
