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; }