void wxTopLevelWindowGTK::GTKHandleRealized() { wxNonOwnedWindow::GTKHandleRealized(); GdkWindow* window = gtk_widget_get_window(m_widget); gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); const wxIconBundle& icons = GetIcons(); if (icons.GetIconCount()) SetIcons(icons); GdkCursor* cursor = g_globalCursor.GetCursor(); if (wxIsBusy() && !gtk_window_get_modal(GTK_WINDOW(m_widget))) cursor = g_busyCursor.GetCursor(); if (cursor) gdk_window_set_cursor(window, cursor); #ifdef __WXGTK3__ if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget))) { // Grip window can end up obscured, probably due to deferred show. // Reset grip to ensure it is visible. gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false); gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true); } #endif }
void wxTopLevelWindowGTK::GTKHandleRealized() { wxNonOwnedWindow::GTKHandleRealized(); gdk_window_set_decorations(gtk_widget_get_window(m_widget), (GdkWMDecoration)m_gdkDecor); gdk_window_set_functions(gtk_widget_get_window(m_widget), (GdkWMFunction)m_gdkFunc); // GTK's shrinking/growing policy if ( !(m_gdkFunc & GDK_FUNC_RESIZE) ) gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE); #ifndef __WXGTK3__ else gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1); #endif const wxIconBundle& icons = GetIcons(); if (icons.GetIconCount()) SetIcons(icons); #ifdef __WXGTK3__ if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget))) { // Grip window can end up obscured, probably due to deferred show. // Reset grip to ensure it is visible. gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false); gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true); } #endif }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkWindow_gtk_1window_1set_1has_1resize_1grip ( JNIEnv* env, jclass cls, jlong _self, jboolean _value ) { GtkWindow* self; gboolean value; // convert parameter self self = (GtkWindow*) _self; // convert parameter value value = (gboolean) _value; // call function gtk_window_set_has_resize_grip(self, value); // cleanup parameter self // cleanup parameter value }
void create_win1() { if (gwin1) return; gwin1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(gwin1), FALSE); #if UNIX gtk_window_set_resizable(GTK_WINDOW(gwin1), FALSE); #endif #if WIN32 set_no_focus(gwin1); #endif gtk_widget_realize (gwin1); #if UNIX set_no_focus(gwin1); #else win32_init_win(gwin1); #endif g_signal_connect (G_OBJECT (gwin1), "scroll-event", G_CALLBACK (button_scroll_event_tsin), NULL); }
void create_stat_win() { gwin_stat = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(gwin_stat), FALSE); #if WIN32 set_no_focus(gwin_stat); #endif gtk_container_set_border_width (GTK_CONTAINER (gwin_stat), 0); gtk_widget_realize (gwin_stat); #if UNIX GdkWindow *gdkwin0 = gtk_widget_get_window(gwin_stat); set_no_focus(gwin_stat); #else win32_init_win(gwin_stat); #endif GtkWidget *vbox = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (gwin_stat), vbox); label_disp = gtk_label_new(NULL); gtk_box_pack_start (GTK_BOX (vbox), label_disp, TRUE, TRUE, 0); gtk_widget_show_all(gwin_stat); timeout_handle = g_timeout_add(3000, timeout_update_stat, NULL); }
void android_gtk_window_class_constructed(GObject *object) { GtkWindow *w = GTK_WINDOW(object); if (default_gtk_window_class_constructed) (*default_gtk_window_class_constructed)(object); gtk_window_set_has_resize_grip(w, FALSE); }
/** * gva_main_progress_bar_hide: * * Hides the progress bar in the main window's status bar and sets the * mouse cursor back to normal. Generally useful after completing a * long-running foreground task. **/ void gva_main_progress_bar_hide (void) { GtkWindow *window; window = GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW); gtk_window_set_has_resize_grip (window, TRUE); gtk_widget_hide (GVA_WIDGET_MAIN_PROGRESS_BAR); gva_main_cursor_normal (); }
void statusbar_update_state(DebugState state) { static DebugState last_state = DS_INACTIVE; if (thread_state == THREAD_AT_ASSEMBLER) state = DS_EXTRA_1; if (state != last_state) { static const char *const states[] = { N_("Busy"), N_("Ready"), N_("Debug"), N_("Hang"), N_("Assem"), N_("Load"), NULL }; guint i; for (i = 0; states[i]; i++) if (state & (DS_BUSY << i)) break; gtk_label_set_text(debug_state_label, _(states[i])); if (state == DS_INACTIVE) { gtk_widget_hide(debug_statusbar); #if GTK_CHECK_VERSION(3, 0, 0) gtk_window_set_has_resize_grip(GTK_WINDOW(geany->main_widgets->window), TRUE); #else gtk_statusbar_set_has_resize_grip(geany_statusbar, TRUE); #endif } else if (last_state == DS_INACTIVE) { #if GTK_CHECK_VERSION(3, 0, 0) gtk_window_set_has_resize_grip(GTK_WINDOW(geany->main_widgets->window), FALSE); #else gtk_statusbar_set_has_resize_grip(geany_statusbar, FALSE); #endif gtk_widget_show(debug_statusbar); } last_state = state; } }
/** * gva_main_progress_bar_show: * * Shows the progress bar in the main window's status bar and sets the * mouse cursor to busy. Generally useful before starting a long-running * foreground task. **/ void gva_main_progress_bar_show (void) { GtkWindow *window; window = GTK_WINDOW (GVA_WIDGET_MAIN_WINDOW); gtk_window_set_has_resize_grip (window, FALSE); gva_main_progress_bar_set_fraction (0.0); gtk_widget_show (GVA_WIDGET_MAIN_PROGRESS_BAR); gva_main_cursor_busy (); }
void create_win0() { if (gwin0) return; #if _DEBUG && 0 dbg("create_win0\n"); #endif gwin0 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(gwin0), FALSE); gtk_container_set_border_width (GTK_CONTAINER (gwin0), 0); gtk_widget_realize (gwin0); set_no_focus(gwin0); }
void create_win_pho() { if (gwin_pho) return; gwin_pho = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(gwin_pho), 1 ,1); gtk_window_set_has_resize_grip(GTK_WINDOW(gwin_pho), FALSE); gtk_container_set_border_width (GTK_CONTAINER (gwin_pho), 0); gtk_widget_realize (gwin_pho); set_no_focus(gwin_pho); change_win_bg(gwin_pho); }
static WidgetInfo * new_widget_info (const char *name, GtkWidget *widget, WidgetSize size) { WidgetInfo *info; info = g_new0 (WidgetInfo, 1); info->name = g_strdup (name); info->size = size; if (GTK_IS_WINDOW (widget)) { info->window = widget; gtk_window_set_resizable (GTK_WINDOW (info->window), FALSE); info->include_decorations = TRUE; g_signal_connect (info->window, "realize", G_CALLBACK (realize_callback), info); } else { info->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip (GTK_WINDOW (info->window), FALSE); info->include_decorations = FALSE; gtk_widget_show_all (widget); gtk_container_add (GTK_CONTAINER (info->window), widget); } info->no_focus = TRUE; gtk_widget_set_app_paintable (info->window, TRUE); g_signal_connect (info->window, "focus", G_CALLBACK (gtk_true), NULL); gtk_container_set_border_width (GTK_CONTAINER (info->window), 12); switch (size) { case SMALL: gtk_widget_set_size_request (info->window, 240, 75); break; case MEDIUM: gtk_widget_set_size_request (info->window, 240, 165); break; case LARGE: gtk_widget_set_size_request (info->window, 240, 240); break; default: break; } return info; }
static void *krad_gui_gtk_init(gpointer data) { krad_gui_gtk_t *krad_gui_gtk = (krad_gui_gtk_t *)data; gtk_init (NULL, NULL); krad_gui_gtk->window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (krad_gui_gtk->window), "Krad GUI"); g_signal_connect (krad_gui_gtk->window, "destroy", G_CALLBACK (close_window), krad_gui_gtk); //gtk_container_set_border_width (GTK_CONTAINER (krad_gui_gtk->window), 8); //krad_gui_gtk->frame = gtk_frame_new (NULL); //gtk_frame_set_shadow_type (GTK_FRAME (krad_gui_gtk->frame), GTK_SHADOW_IN); //gtk_container_add (GTK_CONTAINER (krad_gui_gtk->window), krad_gui_gtk->frame); krad_gui_gtk->da = gtk_drawing_area_new (); /* set a minimum size */ gtk_window_set_position (GTK_WINDOW(krad_gui_gtk->window), GTK_WIN_POS_CENTER); //gtk_window_set_decorated (GTK_WINDOW(krad_gui_gtk->window), FALSE); gtk_window_set_has_resize_grip (GTK_WINDOW(krad_gui_gtk->window), FALSE); gtk_window_set_resizable (GTK_WINDOW(krad_gui_gtk->window), FALSE); gtk_window_set_focus_on_map (GTK_WINDOW(krad_gui_gtk->window), TRUE); gtk_widget_set_size_request (krad_gui_gtk->da, krad_gui_gtk->width, krad_gui_gtk->height); gtk_container_add (GTK_CONTAINER (krad_gui_gtk->window), krad_gui_gtk->da); /* Signals used to handle the backing surface */ g_signal_connect (krad_gui_gtk->da, "draw", G_CALLBACK (draw_cb), krad_gui_gtk); g_signal_connect (krad_gui_gtk->da,"configure-event", G_CALLBACK (configure_event_cb), krad_gui_gtk); gtk_widget_show_all (krad_gui_gtk->window); gtk_window_present (GTK_WINDOW(krad_gui_gtk->window)); g_timeout_add (30, update_gui, krad_gui_gtk); gtk_main (); free(krad_gui_gtk->krad_gui->gui_ptr); krad_gui_gtk->krad_gui->gui_ptr = NULL; return 0; }
/* At some point subclass GtkWindow instead. */ static void on_realize(GtkWidget *win, gpointer data) { guint width; GtkAllocation allocation; gtk_widget_get_allocation(win, &allocation); width = gdk_screen_width(); gtk_window_set_decorated (GTK_WINDOW (win), FALSE); set_strut(GTK_WINDOW(win), width, 0, allocation.height, allocation.height, 0, width); // We don't care about showing the panel on all desktops just yet. gtk_window_stick (GTK_WINDOW (win)); gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_DOCK); gdk_window_set_geometry_hints (gtk_widget_get_window(win), NULL, GDK_HINT_POS); gdk_window_move_resize(gtk_widget_get_window(win), 0, 0, width, allocation.height); gtk_window_set_has_resize_grip(GTK_WINDOW(win), FALSE); }
void create_win_gtab() { if (gwin_gtab) return; gwin_gtab = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(gwin_gtab), FALSE); gtk_container_set_border_width (GTK_CONTAINER (gwin_gtab), 0); gtk_widget_realize (gwin_gtab); set_no_focus(gwin_gtab); if (use_tsin_sel_win()) init_tsin_selection_win(); }
void interface_add_plugin_widget (PluginHandle * plugin, GtkWidget * widget) { g_return_if_fail (current_interface); if (PLUGIN_HAS_FUNC (current_interface, run_gtk_plugin)) current_interface->run_gtk_plugin (widget, plugin_get_name (plugin)); else { GtkWidget * window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title ((GtkWindow *) window, plugin_get_name (plugin)); gtk_window_set_default_size ((GtkWindow *) window, 300, 200); gtk_window_set_has_resize_grip ((GtkWindow *) window, FALSE); gtk_container_add ((GtkContainer *) window, widget); g_signal_connect (window, "delete-event", (GCallback) delete_cb, plugin); gtk_widget_show_all (window); } }
static void gw_installprogresswindow_constructed (GObject *object) { //Declarations GwInstallProgressWindow *window; GwInstallProgressWindowPrivate *priv; GtkAccelGroup *accelgroup; //Chain the parent class { G_OBJECT_CLASS (gw_installprogresswindow_parent_class)->constructed (object); } window = GW_INSTALLPROGRESSWINDOW (object); priv = window->priv; accelgroup = gw_window_get_accel_group (GW_WINDOW (window)); g_mutex_init (&priv->mutex); priv->label = GTK_LABEL (gw_window_get_object (GW_WINDOW (window), "progress_label")); priv->sublabel = GTK_LABEL (gw_window_get_object (GW_WINDOW (window), "sub_progress_label")); priv->progressbar = GTK_PROGRESS_BAR (gw_window_get_object (GW_WINDOW (window), "progress_progressbar")); priv->cancel_button = GTK_BUTTON (gw_window_get_object (GW_WINDOW (window), "cancel_button")); priv->cancellable = g_cancellable_new (); gtk_window_set_title (GTK_WINDOW (window), gettext("Installing Dictionaries...")); gtk_window_set_resizable (GTK_WINDOW (window), TRUE); gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_skip_taskbar_hint (GTK_WINDOW (window), TRUE); gtk_window_set_skip_pager_hint (GTK_WINDOW (window), TRUE); gtk_window_set_destroy_with_parent (GTK_WINDOW (window), TRUE); gtk_window_set_icon_name (GTK_WINDOW (window), "gwaei"); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_modal (GTK_WINDOW (window), TRUE); gtk_window_set_default_size (GTK_WINDOW (window), 500, -1); gtk_window_set_has_resize_grip (GTK_WINDOW (window), FALSE); gtk_container_set_border_width (GTK_CONTAINER (window), 4); gtk_widget_add_accelerator (GTK_WIDGET (priv->cancel_button), "activate", accelgroup, (GDK_KEY_W), GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator (GTK_WIDGET (priv->cancel_button), "activate", accelgroup, (GDK_KEY_Escape), 0, GTK_ACCEL_VISIBLE); gw_window_unload_xml (GW_WINDOW (window)); }
static void create_result_win(int res, char *cmd) { char tt[512]; if (res) { sprintf(tt, "%s code:%d '%s'\n%s", _(_L("結果失敗")), res, strerror(res), cmd); } else strcpy(tt, _(_L("結果成功"))); main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_MOUSE); gtk_window_set_has_resize_grip(GTK_WINDOW(main_window), FALSE); GtkWidget *button = gtk_button_new_with_label(tt); gtk_container_add (GTK_CONTAINER (main_window), button); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (cb_ret), main_window); gtk_widget_show_all(main_window); }
static void create_gui(struct application_info *app) { PangoFontDescription *font_desc = NULL; /* Main window. */ app->gui.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(G_OBJECT(app->gui.window), "delete_event", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(app->gui.window), "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_window_set_has_resize_grip(GTK_WINDOW(app->gui.window), FALSE); gtk_window_set_title(GTK_WINDOW(app->gui.window), "stopclock"); /* The layout box. */ app->gui.box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10); /* Create two labels and adjust their font. */ app->gui.clock = gtk_label_new("00:00"); app->gui.timer = gtk_label_new("00:00:00"); update_labels(app); font_desc = pango_font_description_from_string(LABEL_FONT); gtk_widget_modify_font(app->gui.clock, font_desc); gtk_widget_modify_font(app->gui.timer, font_desc); pango_font_description_free(font_desc); /* Timeout callback. */ g_timeout_add(500, (GSourceFunc)update_labels, app); /* Connect all the containers and show the window. */ gtk_box_pack_start(GTK_BOX(app->gui.box), app->gui.clock, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(app->gui.box), app->gui.timer, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(app->gui.window), app->gui.box); gtk_widget_show_all(app->gui.window); }
static GtkWidget * create_main_window (void) { GtkWidget *window; GtkWidget *box; GtkWidget *manager; GtkWidget *button_box; GtkWidget *button; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL); gtk_container_set_border_width (GTK_CONTAINER (window), 6); gtk_window_set_title (GTK_WINDOW (window), "Peas Demo"); gtk_window_set_has_resize_grip (GTK_WINDOW (window), FALSE); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (window), box); manager = peas_gtk_plugin_manager_new (peas_engine_get_default ()); gtk_box_pack_start (GTK_BOX (box), manager, TRUE, TRUE, 0); button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_set_spacing (GTK_BOX (button_box), 6); gtk_button_box_set_layout (GTK_BUTTON_BOX (button_box), GTK_BUTTONBOX_END); gtk_box_pack_start (GTK_BOX (box), button_box, FALSE, FALSE, 0); button = gtk_button_new_with_label ("New window"); g_signal_connect (button, "clicked", G_CALLBACK (create_new_window), NULL); gtk_container_add (GTK_CONTAINER (button_box), button); button = gtk_button_new_from_stock (GTK_STOCK_QUIT); g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); gtk_container_add (GTK_CONTAINER (button_box), button); return window; }
void create_win0() { if (gwin0) return; #if _DEBUG && 0 dbg("create_win0\n"); #endif gwin0 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(gwin0), FALSE); #if UNIX gtk_window_set_resizable(GTK_WINDOW(gwin0), FALSE); #endif #if WIN32 set_no_focus(gwin0); #endif gtk_container_set_border_width (GTK_CONTAINER (gwin0), 0); gtk_widget_realize (gwin0); #if UNIX GdkWindow *gdkwin0 = gtk_widget_get_window(gwin0); set_no_focus(gwin0); #else win32_init_win(gwin0); #endif }
void gcb_main() { GtkWidget *hbox,*vbox; int i; #if 1 if (gcb_enabled==old_gcb_enabled && gcb_position==old_gcb_position && gcb_position_x==old_gcb_position_x && gcb_position_y==old_gcb_position_y) return; #endif old_gcb_enabled = gcb_enabled; old_gcb_position = gcb_position; old_gcb_position_x = gcb_position_x; old_gcb_position_y = gcb_position_y; if (mainwin) { gtk_widget_destroy(mainwin); mainwin = NULL; } #if 0 if (button_bar_tips) gtk_widget_destroy(button_bar_tips); #endif if (hist_window) { gtk_widget_destroy(hist_window); hist_window = NULL; } if (!gcb_enabled) return; // printf("gcb_position:%d\n", gcb_position); static char geo[][2]={{0,0},{'+','-'},{'+','+'},{'-','-'},{'-','+'}}; g_free(geomstr); geomstr = g_strdup_printf("%c%d%c%d", geo[gcb_position][0], gcb_position_x, geo[gcb_position][1], gcb_position_y); dbg("geomstr %s\n", geomstr); if (!buttonArr) { buttonArr=(GtkWidget**)g_malloc(gcb_button_n * sizeof(GtkWidget *)); buttonStr=(gchar**)g_malloc0(gcb_button_n * sizeof(gchar *)); } if (!hist_strArr) { hist_strArr=(gchar**)g_malloc0(gcb_history_n * sizeof(gchar *)); hist_buttonArr=(GtkWidget**)g_malloc(gcb_history_n * sizeof(GtkWidget *)); } mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(mainwin), FALSE); gtk_window_set_decorated(GTK_WINDOW(mainwin),FALSE); gtk_window_set_focus_on_map (GTK_WINDOW(mainwin), FALSE); hist_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(hist_window), FALSE); char icon_path[40]; sys_icon_fname("gcb.png", icon_path); GtkWidget *win_icon=gtk_image_new_from_file(icon_path); gtk_window_set_icon(GTK_WINDOW(mainwin), gtk_image_get_pixbuf(GTK_IMAGE(win_icon))); gtk_window_set_icon(GTK_WINDOW(hist_window), gtk_image_get_pixbuf(GTK_IMAGE(win_icon))); // Under gnome 2.0, the mainwin is not fixed if decorated, annoying gtk_window_set_decorated(GTK_WINDOW(hist_window),FALSE); gtk_window_set_skip_pager_hint(GTK_WINDOW(hist_window),TRUE); gtk_window_set_skip_taskbar_hint(GTK_WINDOW(hist_window),TRUE); gtk_window_set_title (GTK_WINDOW (hist_window),"gcb history"); gtk_window_set_title (GTK_WINDOW(mainwin), "gcb: gtk copy-paste buffer"); gtk_window_stick(GTK_WINDOW(mainwin)); // g_signal_connect(G_OBJECT (mainwin),"destroy", G_CALLBACK (do_exit), NULL); g_signal_connect(G_OBJECT (hist_window),"delete_event", G_CALLBACK (delete_hist_win), NULL); g_signal_connect(G_OBJECT (hist_window),"focus-out-event", G_CALLBACK (hist_focus_out_callback), NULL); #if !GTK_CHECK_VERSION(2,12,0) button_bar_tips = gtk_tooltips_new (); #endif hbox = gtk_hbox_new (FALSE, 1); gtk_container_add (GTK_CONTAINER(mainwin), hbox); gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr); for(i=0;i<gcb_button_n;i++) { buttonArr[i] = gtk_button_new_with_label ("---"); // gtk_container_set_border_width(GTK_CONTAINER(buttonArr[i]),0); gtk_box_pack_start (GTK_BOX(hbox), buttonArr[i], TRUE, TRUE, FALSE); gtk_widget_show (buttonArr[i]); g_signal_connect (G_OBJECT (buttonArr[i]), "button-press-event", G_CALLBACK (get_mouse_button), (gpointer) buttonArr[i]); #if 0 g_signal_connect (G_OBJECT (buttonArr[i]), "key-press-event", G_CALLBACK (key_press_event), NULL); #endif #if 1 g_signal_connect (G_OBJECT (buttonArr[i]), "scroll-event", G_CALLBACK (gcb_button_scroll_event), NULL); #endif } vbox = gtk_vbox_new (FALSE, 1); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER(hist_window), vbox); for(i=0;i<gcb_history_n;i++) { hist_buttonArr[i] = gtk_button_new_with_label ("---"); gtk_container_set_border_width(GTK_CONTAINER(hist_buttonArr[i]),0); gtk_box_pack_start (GTK_BOX(vbox), hist_buttonArr[i], TRUE, TRUE, FALSE); gtk_widget_show (hist_buttonArr[i]); g_signal_connect (G_OBJECT (hist_buttonArr[i]), "button-press-event", G_CALLBACK (hist_get_mouse_button), (gpointer) hist_buttonArr[i]); #if 1 g_signal_connect (G_OBJECT (hist_buttonArr[i]), "key-press-event", G_CALLBACK (hist_key_press_event), NULL); #endif } #if 1 // need this because on win32 scoll is not recieved if win is not focused. gtk_box_pack_start (GTK_BOX (hbox), gtk_vseparator_new(), FALSE, FALSE, 0); GtkWidget *eve_arrow = gtk_event_box_new(); gtk_event_box_set_visible_window (GTK_EVENT_BOX(eve_arrow), FALSE); gtk_box_pack_start (GTK_BOX(hbox), eve_arrow, FALSE, FALSE, FALSE); g_signal_connect(G_OBJECT(eve_arrow),"button-press-event", G_CALLBACK(mouse_button_callback), NULL); gtk_container_add(GTK_CONTAINER(eve_arrow), gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN)); #endif gtk_widget_show_all(hbox); gtk_widget_show (vbox); gtk_widget_show (mainwin); pclipboard_prim = gtk_clipboard_get(GDK_SELECTION_PRIMARY); pclipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); set_snoop_button(buttonArr[0]); get_selection(pclipboard); get_selection(pclipboard_prim); gtk_container_set_border_width(GTK_CONTAINER(hbox),0); gtk_container_set_border_width(GTK_CONTAINER(mainwin),0); gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr); #if GTK_CHECK_VERSION(2,6,0) g_signal_connect(pclipboard, "owner-change", G_CALLBACK (cb_owner_change), NULL); g_signal_connect(pclipboard_prim, "owner-change", G_CALLBACK (cb_owner_change), NULL); #endif }
static void create_main_win() { main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(main_window), GTK_WIN_POS_CENTER); gtk_window_set_has_resize_grip(GTK_WINDOW(main_window), FALSE); g_signal_connect (G_OBJECT (main_window), "delete_event", G_CALLBACK (close_application), NULL); set_window_gcin_icon(main_window); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (main_window), vbox); GtkWidget *button_kbm = gtk_button_new_with_label(_(_L("gcin 注音/詞音/拼音 設定"))); gtk_box_pack_start (GTK_BOX (vbox), button_kbm, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_kbm), "clicked", G_CALLBACK (cb_kbm), NULL); GtkWidget *button_appearance_conf = gtk_button_new_with_label(_(_L("外觀設定"))); gtk_box_pack_start (GTK_BOX (vbox), button_appearance_conf, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_appearance_conf), "clicked", G_CALLBACK (cb_appearance_conf), NULL); GtkWidget *button_gtab_conf = gtk_button_new_with_label(_(_L("倉頡/行列/嘸蝦米/大易設定"))); gtk_box_pack_start (GTK_BOX (vbox), button_gtab_conf, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_gtab_conf), "clicked", G_CALLBACK (cb_gtab_conf), NULL); int i; for (i=0; i < inmdN; i++) { INMD *pinmd = &inmd[i]; if (pinmd->method_type != method_type_MODULE || pinmd->disabled) continue; GCIN_module_callback_functions *f = init_GCIN_module_callback_functions(pinmd->filename); if (!f) continue; if (!f->module_setup_window_create) { free(f); continue; } char tt[128]; strcpy(tt, pinmd->cname); strcat(tt, _(_L("設定"))); GtkWidget *button_chewing_input_method = gtk_button_new_with_label(tt); gtk_box_pack_start (GTK_BOX (vbox), button_chewing_input_method, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_chewing_input_method), "clicked", G_CALLBACK (f->module_setup_window_create), NULL); } GtkWidget *button_default_input_method = gtk_button_new_with_label(_(_L("內定輸入法 & 開啟/關閉"))); gtk_box_pack_start (GTK_BOX (vbox), button_default_input_method, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_default_input_method), "clicked", G_CALLBACK (cb_default_input_method), NULL); GtkWidget *button_alt_shift = gtk_button_new_with_label(_(_L("alt-shift 片語編輯"))); gtk_box_pack_start (GTK_BOX (vbox), button_alt_shift, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_alt_shift), "clicked", G_CALLBACK (cb_alt_shift), NULL); GtkWidget *button_symbol_table = gtk_button_new_with_label(_(_L("符號表編輯"))); gtk_box_pack_start (GTK_BOX (vbox), button_symbol_table, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_symbol_table), "clicked", G_CALLBACK (cb_symbol_table), NULL); #if TRAY_ENABLED if (!gcin_status_tray) { #endif GtkWidget *button_gb_output_toggle = gtk_button_new_with_label(_(_L("簡體字輸出切換"))); gtk_box_pack_start (GTK_BOX (vbox), button_gb_output_toggle, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_gb_output_toggle), "clicked", G_CALLBACK (cb_gb_output_toggle), NULL); #if TRAY_ENABLED } #endif GtkWidget *button_gb_translate_toggle = gtk_button_new_with_label(_(_L("剪貼區 簡體字->正體字"))); gtk_box_pack_start (GTK_BOX (vbox), button_gb_translate_toggle, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_gb_translate_toggle), "clicked", G_CALLBACK (cb_gb_translate_toggle), NULL); GtkWidget *button_juying_learn_toggle = gtk_button_new_with_label(_(_L("剪貼區 注音查詢"))); gtk_box_pack_start (GTK_BOX (vbox), button_juying_learn_toggle, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_juying_learn_toggle), "clicked", G_CALLBACK (cb_juying_learn), NULL); GtkWidget *expander_ts = gtk_expander_new (_(_L("詞庫選項"))); gtk_box_pack_start (GTK_BOX (vbox), expander_ts, FALSE, FALSE, 0); g_signal_connect (expander_ts, "notify::expanded", G_CALLBACK (expander_callback), NULL); GtkWidget *vbox_ts = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (expander_ts), vbox_ts); GtkWidget *button_ts_export = gtk_button_new_with_label(_(_L("詞庫匯出"))); gtk_widget_set_hexpand (button_ts_export, TRUE); gtk_box_pack_start (GTK_BOX (vbox_ts), button_ts_export, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_ts_export), "clicked", G_CALLBACK (cb_ts_export), NULL); GtkWidget *button_ts_import = gtk_button_new_with_label(_(_L("詞庫匯入"))); gtk_widget_set_hexpand (button_ts_import, TRUE); gtk_box_pack_start (GTK_BOX (vbox_ts), button_ts_import, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_ts_import), "clicked", G_CALLBACK (cb_ts_import), NULL); GtkWidget *button_ts_edit = gtk_button_new_with_label(_(_L("詞庫編輯"))); gtk_widget_set_hexpand (button_ts_edit, TRUE); gtk_box_pack_start (GTK_BOX (vbox_ts), button_ts_edit, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_ts_edit), "clicked", G_CALLBACK (cb_ts_edit), NULL); if (inmd[default_input_method].method_type == method_type_TSIN) { GtkWidget *button_tslearn = gtk_button_new_with_label(_(_L("讓詞音從文章學習詞"))); gtk_box_pack_start (GTK_BOX (vbox_ts), button_tslearn, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_tslearn), "clicked", G_CALLBACK (cb_tslearn), NULL); GtkWidget *button_ts_import_sys = gtk_button_new_with_label(_(_L("匯入系統的詞庫"))); gtk_box_pack_start (GTK_BOX (vbox_ts), button_ts_import_sys, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_ts_import_sys), "clicked", G_CALLBACK (cb_ts_import_sys), NULL); GtkWidget *button_ts_contribute = gtk_button_new_with_label(_(_L("貢獻選擇的詞庫"))); gtk_box_pack_start (GTK_BOX (vbox_ts), button_ts_contribute, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_ts_contribute), "clicked", G_CALLBACK (cb_ts_contribute), NULL); } GtkWidget *button_about = gtk_button_new_with_label(_(_L("關於 gcin"))); gtk_box_pack_start (GTK_BOX (vbox), button_about, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_about), "clicked", G_CALLBACK (create_about_window), NULL); GtkWidget *button_help = gtk_button_new_from_stock (GTK_STOCK_HELP); gtk_box_pack_start (GTK_BOX (vbox), button_help, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_help), "clicked", G_CALLBACK (cb_help), NULL); GtkWidget *button_quit = gtk_button_new_from_stock (GTK_STOCK_QUIT); gtk_box_pack_start (GTK_BOX (vbox), button_quit, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (button_quit), "clicked", G_CALLBACK (close_application), NULL); gtk_widget_show_all(main_window); }
int module_init_win(HIME_module_main_functions *funcs) { gmf = *funcs; // dbg("module_init_win\n"); gmf.mf_set_tsin_pho_mode(); gmf.mf_set_win1_cb((cb_selec_by_idx_t)select_idx, prev_page, next_page); if (win_anthy) return TRUE; if (anthy_init() == -1) { GtkWidget *dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Cannot init anthy. Please install anthy."); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); return FALSE; } ac = anthy_create_context(); if (!ac) { printf("anthy_create_context err\n"); return FALSE; } anthy_context_set_encoding(ac, ANTHY_UTF8_ENCODING); win_anthy = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(win_anthy), FALSE); gtk_window_set_default_size(GTK_WINDOW (win_anthy), 40, 50); gtk_widget_realize (win_anthy); gmf.mf_set_no_focus(win_anthy); event_box_anthy = gtk_event_box_new(); gtk_event_box_set_visible_window (GTK_EVENT_BOX(event_box_anthy), FALSE); gtk_container_add(GTK_CONTAINER(win_anthy), event_box_anthy); GtkWidget *hbox_top = gtk_hbox_new (FALSE, 0); gtk_container_add(GTK_CONTAINER(event_box_anthy), hbox_top); g_signal_connect(G_OBJECT(event_box_anthy),"button-press-event", G_CALLBACK(mouse_button_callback), NULL); if (!seg) { int n=sizeof(SEG)*MAX_SEG_N; seg=malloc(n); bzero(seg, n); } int i; for(i=0; i < MAX_SEG_N; i++) { seg[i].label = gtk_label_new(NULL); gtk_widget_show(seg[i].label); gtk_box_pack_start (GTK_BOX (hbox_top), seg[i].label, FALSE, FALSE, 0); } gtk_widget_show_all(win_anthy); gmf.mf_init_tsin_selection_win(); module_change_font_size(); if (!gmf.mf_phkbm->selkeyN) gmf.mf_load_tab_pho_file(); module_hide_win(); return TRUE; }
void module_setup_window_create (GtkButton *button, gpointer data_hime_setup_window_type_utility) { gboolean bWriteMode = TRUE; chewing_config_open (bWriteMode); chewing_config_load (&g_chewingConfig); if (hime_chewing_window) { gtk_window_present (GTK_WINDOW (hime_chewing_window)); return; } hime_chewing_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); if (data_hime_setup_window_type_utility) gtk_window_set_type_hint(GTK_WINDOW(hime_chewing_window), GDK_WINDOW_TYPE_HINT_UTILITY); /* main setup win setting */ gtk_window_set_position (GTK_WINDOW (hime_chewing_window), GTK_WIN_POS_MOUSE); gtk_window_set_has_resize_grip (GTK_WINDOW (hime_chewing_window), FALSE); g_signal_connect (G_OBJECT (hime_chewing_window), "delete_event", G_CALLBACK (cb_close_window), NULL); gtk_window_set_title (GTK_WINDOW (hime_chewing_window), _("新酷音設定")); gtk_container_set_border_width (GTK_CONTAINER (hime_chewing_window), 1); vbox_top = gtk_vbox_new (FALSE, 3); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (hime_chewing_window), vbox_top); // cand per page g_pHBoxCandPerPage = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxCandPerPage, TRUE, TRUE, 1); g_pLabelCandPerPage = gtk_label_new (_("每頁候選字數")); gtk_box_pack_start (GTK_BOX (g_pHBoxCandPerPage), g_pLabelCandPerPage, TRUE, TRUE, 0); g_pGtkAdj = (GtkAdjustment *)gtk_adjustment_new (g_chewingConfig.candPerPage, 1, 10, 1.0, 1.0, 0.0); g_pSpinButtonCandPerPage = gtk_spin_button_new (g_pGtkAdj, 0, 0); gtk_box_pack_start (GTK_BOX (g_pHBoxCandPerPage), g_pSpinButtonCandPerPage, FALSE, FALSE, 0); // space as selection g_pHBoxSpaceAsSelection = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxSpaceAsSelection, TRUE, TRUE, 1); g_pCheckButtonSpaceAsSelection = gtk_check_button_new_with_label(_("空白鍵選字")); gtk_box_pack_start (GTK_BOX (g_pHBoxSpaceAsSelection), g_pCheckButtonSpaceAsSelection, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (g_pCheckButtonSpaceAsSelection), g_chewingConfig.bSpaceAsSelection); // esc clean buf g_pHBoxEscCleanAllBuf = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxEscCleanAllBuf, TRUE, TRUE, 1); g_pCheckButtonEscCleanAllBuf = gtk_check_button_new_with_label (_("ESC 鍵清空緩衝區")); gtk_box_pack_start (GTK_BOX (g_pHBoxEscCleanAllBuf), g_pCheckButtonEscCleanAllBuf, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (g_pCheckButtonEscCleanAllBuf), g_chewingConfig.bEscCleanAllBuf); // auto shift cursor g_pHBoxAutoShiftCur = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxAutoShiftCur, TRUE, TRUE, 1); g_pCheckButtonAutoShiftCur = gtk_check_button_new_with_label (_("選字完畢自動跳字")); gtk_box_pack_start (GTK_BOX (g_pHBoxAutoShiftCur), g_pCheckButtonAutoShiftCur, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (g_pCheckButtonAutoShiftCur), g_chewingConfig.bAutoShiftCur); // add phrase forward g_pHBoxAddPhraseForward = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_top), g_pHBoxAddPhraseForward, TRUE, TRUE, 1); g_pCheckButtonAddPhraseForward = gtk_check_button_new_with_label (_("向後加詞")); gtk_box_pack_start (GTK_BOX (g_pHBoxAddPhraseForward), g_pCheckButtonAddPhraseForward, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (g_pCheckButtonAddPhraseForward), g_chewingConfig.bAddPhraseForward); // cancel & ok buttons hbox_cancel_ok = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_cancel_ok , FALSE, FALSE, 5); button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gboolean button_order; g_object_get(gtk_settings_get_default(), "gtk-alternative-button-order", &button_order, NULL); if (button_order) gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0); else gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0); button_ok = gtk_button_new_from_stock (GTK_STOCK_OK); #if !GTK_CHECK_VERSION(2,91,2) if (button_order) gtk_box_pack_end (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5); else gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5); #else if (button_order) gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_LEFT, 1, 1); else gtk_grid_attach_next_to (GTK_BOX (hbox_cancel_ok), button_ok, button_cancel, GTK_POS_RIGHT, 1, 1); #endif g_signal_connect (G_OBJECT (button_cancel), "clicked", G_CALLBACK (cb_close_window), G_OBJECT (hime_chewing_window)); g_signal_connect (G_OBJECT (button_ok), "clicked", G_CALLBACK (cb_update_setting), G_OBJECT (hime_chewing_window)); gtk_widget_show_all (hime_chewing_window); }
int main(int argc, char **argv) { #if WIN32 init_TableDir(); #endif gtk_init (&argc, &argv); #if HIME_i18n_message bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain(GETTEXT_PACKAGE); #endif b_pinyin = is_pinyin_kbm(); pho_load(); mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(mainwin), FALSE); gtk_window_set_default_size(GTK_WINDOW (mainwin), 640, 220); set_window_hime_icon(mainwin); GtkWidget *sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); GtkWidget *vbox_top = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox_top), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER(mainwin), vbox_top); GtkWidget *view = gtk_text_view_new (); gtk_widget_set_hexpand (view, TRUE); gtk_widget_set_vexpand (view, TRUE); gtk_container_add (GTK_CONTAINER(sw), view); gtk_box_pack_start (GTK_BOX (vbox_top), sw, TRUE, TRUE, 0); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)); gtk_text_buffer_create_tag (buffer, "blue_background", "background", "blue", "foreground", "white", NULL); gtk_text_buffer_create_tag (buffer, "char_wrap", "wrap_mode", GTK_WRAP_CHAR, NULL); hbox_buttons = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox_top), hbox_buttons, FALSE, FALSE, 0); GtkWidget *button_fetch = gtk_button_new_with_label(_(_L("自剪貼區更新"))); gtk_box_pack_start (GTK_BOX (hbox_buttons), button_fetch, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_fetch), "clicked", G_CALLBACK (cb_button_fetch), NULL); GtkWidget *button_exit = gtk_button_new_from_stock(GTK_STOCK_QUIT); gtk_box_pack_start (GTK_BOX (hbox_buttons), button_exit, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button_exit), "clicked", G_CALLBACK (do_exit), NULL); g_signal_connect (G_OBJECT (mainwin), "delete_event", G_CALLBACK (do_exit), NULL); gtk_widget_show_all(mainwin); #if UNIX pclipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY); #else pclipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); #endif req_clipboard(); gtk_main(); return 0; }
static void initGUI(int numframes, gchar *notefile) { g_object_set(gtk_settings_get_default(),"gtk-application-prefer-dark-theme", TRUE, NULL); int i = 0, transIndex = 0; GtkWidget *timeBox = NULL, *pageBox = NULL, *notePadBox = NULL, *notePadScroll = NULL, *table = NULL; GtkWidget *canvas = NULL, *frame = NULL, *evbox = NULL, *pageevbox = NULL, *outerevbox = NULL, *timeFrame = NULL, *pageFrame = NULL; GtkWidget *mainVBox = NULL; GdkRGBA black; GtkWidget *toolbar = NULL, *timeToolbar = NULL; GtkToolItem *openButton = NULL, *saveAsButton = NULL, *fontSelectButton = NULL, *timeFontSelectButton = NULL; PangoFontDescription *font_desc = NULL; struct viewport *thisport = NULL; /* init colors */ if (gdk_rgba_parse(&black,"#000000") != TRUE) fprintf(stderr, "Could not resolve color \"black\".\n"); if (gdk_rgba_parse(&col_current,"#BBFFBB") != TRUE) fprintf(stderr, "Could not resolve color \"col_current\".\n"); if (gdk_rgba_parse(&col_marked,"#990000") != TRUE) fprintf(stderr, "Could not resolve color \"col_marked\".\n"); if (gdk_rgba_parse(&col_dim,"#999999") != TRUE) fprintf(stderr, "Could not resolve color \"col_dim\".\n"); /* init our two windows */ win_preview = gtk_window_new(GTK_WINDOW_TOPLEVEL); win_beamer = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(win_preview), "pdfpres - Preview"); gtk_window_set_title(GTK_WINDOW(win_beamer), "pdfpres - Beamer"); g_signal_connect(G_OBJECT(win_preview), "delete_event", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_preview), "destroy", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_beamer), "delete_event", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_beamer), "destroy", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_preview), "key_press_event", G_CALLBACK(onKeyPressed), NULL); g_signal_connect(G_OBJECT(win_beamer), "key_press_event", G_CALLBACK(onKeyPressed), NULL); gtk_widget_add_events(win_beamer, GDK_BUTTON_PRESS_MASK); gtk_widget_add_events(win_beamer, GDK_BUTTON_RELEASE_MASK); g_signal_connect(G_OBJECT(win_beamer), "button_release_event", G_CALLBACK(onMouseReleased), NULL); gtk_widget_add_events(win_preview, GDK_BUTTON_PRESS_MASK); gtk_widget_add_events(win_preview, GDK_BUTTON_RELEASE_MASK); g_signal_connect(G_OBJECT(win_preview), "button_release_event", G_CALLBACK(onMouseReleased), NULL); gtk_container_set_border_width(GTK_CONTAINER(win_preview), 0); gtk_container_set_border_width(GTK_CONTAINER(win_beamer), 0); gtk_widget_override_background_color(win_beamer, GTK_STATE_NORMAL, &black); /* That little "resize grip" is a no-go for our beamer window. */ gtk_window_set_has_resize_grip(GTK_WINDOW(win_beamer), FALSE); /* create buttons */ timeToolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(timeToolbar), GTK_TOOLBAR_ICONS); gtk_container_set_border_width(GTK_CONTAINER(timeToolbar), 5); if (!prefs.timer_is_clock) { startButton = gtk_tool_button_new_from_stock( GTK_STOCK_MEDIA_PLAY); g_signal_connect(G_OBJECT(startButton), "clicked", G_CALLBACK(toggleTimer), NULL); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), startButton, -1); resetButton = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_REWIND); g_signal_connect(G_OBJECT(resetButton), "clicked", G_CALLBACK(resetTimer), NULL); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), resetButton, -1); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), gtk_separator_tool_item_new(), -1); } timeFontSelectButton = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), timeFontSelectButton, -1); g_signal_connect(G_OBJECT(timeFontSelectButton), "clicked", G_CALLBACK(onTimerFontSelectClick), NULL); /* setting text size for time/page label */ timeElapsedLabel = gtk_label_new(NULL); curPageLabel = gtk_label_new(NULL); font_desc = pango_font_description_from_string(prefs.font_timer); gtk_widget_modify_font(GTK_WIDGET(timeElapsedLabel), font_desc); gtk_widget_modify_font(GTK_WIDGET(curPageLabel), font_desc); pango_font_description_free(font_desc); if (prefs.timer_is_clock) { printCurrentTime(timeElapsedLabel); } else { gtk_label_set_text(GTK_LABEL(timeElapsedLabel), "00:00"); } gtk_label_set_text(GTK_LABEL(curPageLabel), "0/0"); /* Add timer label to another event box so we can set a nice border. */ evbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(evbox), timeElapsedLabel); gtk_container_set_border_width(GTK_CONTAINER(evbox), 10); pageevbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(pageevbox), curPageLabel); gtk_container_set_border_width(GTK_CONTAINER(pageevbox), 10); /* create timer */ timeBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_box_pack_start(GTK_BOX(timeBox), evbox, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(timeBox), timeToolbar, FALSE, FALSE, 5); pageBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_box_pack_start(GTK_BOX(pageBox), pageevbox, FALSE, FALSE, 5); if (prefs.timer_is_clock) { timeFrame = gtk_frame_new("Clock"); } else { timeFrame = gtk_frame_new("Timer"); } gtk_container_add(GTK_CONTAINER(timeFrame), timeBox); pageFrame = gtk_frame_new("Page"); gtk_container_add(GTK_CONTAINER(pageFrame), pageBox); /* create note pad inside a scrolled window */ notePadBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); notePadScroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(notePadScroll), 5); notePadFrame = gtk_frame_new("Notes for current slide"); notePad = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(notePad), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(notePad), FALSE); g_signal_connect(G_OBJECT(notePad), "key_press_event", G_CALLBACK(onPadKeyPressed), NULL); /* Remarks: * * - The note pad uses word wrapping. If that's not enough, it also * uses wrapping on a per character basis. * - The note pad is placed into a GtkScrolledWindow. This window * allows vertical scrolling but no horizontal scrolling. */ gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(notePad), GTK_WRAP_WORD_CHAR); gtk_container_add(GTK_CONTAINER(notePadScroll), notePad); gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(notePadScroll), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(notePadScroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(notePadBox), notePadScroll, TRUE, TRUE, 2); /* set note pad font and margin */ font_desc = pango_font_description_from_string(prefs.font_notes); gtk_widget_modify_font(notePad, font_desc); pango_font_description_free(font_desc); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(notePad), 5); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(notePad), 5); noteBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(notePad)); /* We detect changes of the notes by catching the "changed" signal. * As this signal is also emitted when we change the buffer * programmatically, we first have a look if there was a * "begin_user_action" signal. If so, the user has changed the * buffer. */ g_signal_connect(G_OBJECT(noteBuffer), "changed", G_CALLBACK(onEditing), NULL); g_signal_connect(G_OBJECT(noteBuffer), "begin_user_action", G_CALLBACK(onBeginUserAction), NULL); g_signal_connect(G_OBJECT(noteBuffer), "end_user_action", G_CALLBACK(onEndUserAction), NULL); /* create toolbar */ toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); gtk_container_set_border_width(GTK_CONTAINER(toolbar), 5); openButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), openButton, -1); g_signal_connect(G_OBJECT(openButton), "clicked", G_CALLBACK(onOpenClicked), NULL); /* TODO: Tooltips?! */ saveButton = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveButton, -1); gtk_widget_set_sensitive(GTK_WIDGET(saveButton), FALSE); g_signal_connect(G_OBJECT(saveButton), "clicked", G_CALLBACK(onSaveClicked), NULL); saveAsButton = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE_AS); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveAsButton, -1); g_signal_connect(G_OBJECT(saveAsButton), "clicked", G_CALLBACK(onSaveAsClicked), NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), gtk_separator_tool_item_new(), -1); editButton = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_EDIT); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), editButton, -1); g_signal_connect(G_OBJECT(editButton), "toggled", G_CALLBACK(onEditToggled), NULL); fontSelectButton = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), fontSelectButton, -1); g_signal_connect(G_OBJECT(fontSelectButton), "clicked", G_CALLBACK(onFontSelectClick), NULL); gtk_box_pack_start(GTK_BOX(notePadBox), toolbar, FALSE, FALSE, 2); gtk_container_add(GTK_CONTAINER(notePadFrame), notePadBox); /* init containers for "preview" */ table = gtk_table_new(7, 10, TRUE); gtk_table_set_col_spacings(GTK_TABLE(table), 5); gtk_container_set_border_width(GTK_CONTAINER(table), 10); /* dynamically create all the frames */ for (i = 0; i < numframes; i++) { /* calc the offset for this frame */ transIndex = i - (int)((double)numframes / 2.0); /* create the widget - note that it is important not to * set the title to NULL. this would cause a lot more * redraws on startup because the frame will get re- * allocated when the title changes. */ frame = gtk_frame_new(""); /* create a new drawing area - the pdf will be rendered in * there */ canvas = gtk_drawing_area_new(); /* add widgets to their parents. the canvas is placed in an * eventbox, the box's size_allocate signal will be handled. so, * we know the exact width/height we can render into. (placing * the canvas into the frame would create the need of knowing the * frame's border size...) */ evbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(evbox), canvas); gtk_container_add(GTK_CONTAINER(frame), evbox); /* every frame will be placed in another eventbox so we can set a * background color */ outerevbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(outerevbox), frame); if (i == 0) { //gtk_table_attach_defaults(GTK_TABLE(table), notePadFrame, // 0, 1, 0, 2); //gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, // 3, 4, 1, 2); } else { if (i == numframes - 1) { gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, 6, 10, 0, 5); gtk_table_attach_defaults(GTK_TABLE(table), timeFrame, 6, 8, 5, 7); gtk_table_attach_defaults(GTK_TABLE(table), pageFrame, 8, 10, 5, 7); } else { if (i == (int)(numframes / 2)) { gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, 0, 6, 0, 7); } } } /* make the eventbox "transparent" */ gtk_event_box_set_visible_window(GTK_EVENT_BOX(evbox), FALSE); /* save info of this rendering port */ thisport = (struct viewport *)malloc(sizeof(struct viewport)); g_assert(thisport); thisport->offset = transIndex; thisport->canvas = canvas; thisport->frame = frame; thisport->pixbuf = NULL; thisport->width = -1; thisport->height = -1; thisport->isBeamer = FALSE; ports = g_list_append(ports, thisport); /* resize callback */ g_signal_connect(G_OBJECT(evbox), "size_allocate", G_CALLBACK(onResize), thisport); /* How to draw into this particular canvas: */ g_signal_connect(G_OBJECT(canvas), "draw", G_CALLBACK(onCanvasDraw), thisport); } /* Add main content and a status bar to preview window. * * Note: It's important to use gtk_box_pack_* to add the statusbar * because gtk_container_add will pick unappropriate defaults. */ mainVBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_add(GTK_CONTAINER(mainVBox), table); mainStatusbar = gtk_statusbar_new(); gtk_box_pack_end(GTK_BOX(mainVBox), mainStatusbar, FALSE, FALSE, 0); setStatusText_strdup("Ready."); gtk_container_add(GTK_CONTAINER(win_preview), mainVBox); /* in order to set the initially highlighted frame */ refreshFrames(); /* add a rendering area to the beamer window */ canvas = gtk_drawing_area_new(); gtk_container_add(GTK_CONTAINER(win_beamer), canvas); /* save info of this rendering port */ thisport = (struct viewport *)malloc(sizeof(struct viewport)); g_assert(thisport); thisport->offset = 0; thisport->canvas = canvas; thisport->frame = NULL; thisport->pixbuf = NULL; thisport->width = -1; thisport->height = -1; thisport->isBeamer = TRUE; ports = g_list_append(ports, thisport); /* connect the on-resize-callback directly to the window */ g_signal_connect(G_OBJECT(win_beamer), "size_allocate", G_CALLBACK(onResize), thisport); /* How to draw into this particular canvas: */ g_signal_connect(G_OBJECT(canvas), "draw", G_CALLBACK(onCanvasDraw), thisport); /* load notes if requested */ if (notefile) { showNotesFromFile(notefile); } /* Set default sizes for both windows. (Note: If the widgets don't * fit into that space, the windows will be larger. Also, they are * allowed to get shrinked by the user.) */ gtk_window_set_default_size(GTK_WINDOW(win_preview), 640, 400); gtk_window_set_default_size(GTK_WINDOW(win_beamer), 320, 240); /* Hide titlebar when maximized */ gtk_window_set_hide_titlebar_when_maximized(GTK_WINDOW(win_preview), TRUE); /* show the windows */ gtk_widget_show_all(win_preview); gtk_widget_show_all(win_beamer); /* now, as the real gdk window exists, hide mouse cursor in the * beamer window */ gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(win_beamer)), gdk_cursor_new(GDK_BLANK_CURSOR)); /* Show a clock or a timer? */ if (prefs.timer_is_clock) { g_timeout_add(500, (GSourceFunc)printCurrentTime, (gpointer)timeElapsedLabel); } else { g_timeout_add(500, (GSourceFunc)printTimeElapsed, (gpointer)timeElapsedLabel); } }
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; }
void create_win_save_phrase(WSP_S *wsp, int wspN) { #if WIN32 if (test_mode) return; #endif if (!wspN) return; SAVE_SESS *sess = tzmalloc(SAVE_SESS, 1); GtkWidget *main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip(GTK_WINDOW(main_window), FALSE); sess->win = main_window; gtk_window_set_default_size(GTK_WINDOW (main_window), 20, 10); gtk_window_set_title(GTK_WINDOW(main_window), _(_L("加片語到詞庫"))); #if 0 g_signal_connect (G_OBJECT (main_window), "delete_event", G_CALLBACK (delete_event), sess); #endif GtkWidget *vbox = gtk_vbox_new (FALSE, 0); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (main_window), vbox); char tt[512]; tt[0] = 0; wsp_str(wsp, wspN, tt); gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new(tt), FALSE, FALSE, 0); int i; for(i=0; i<wspN; i++) { if (ph_key_sz==2) strcat(tt, phokey_to_str(wsp[i].key)); strcat(tt, " "); } if (tt[0]) gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new(tt), FALSE, FALSE, 0); sess->mywsp = tmemdup(wsp, WSP_S, wspN); sess->mywspN = wspN; GtkWidget *hbox_cancel_ok = gtk_hbox_new (FALSE, 10); gtk_box_pack_start (GTK_BOX (vbox), hbox_cancel_ok , FALSE, FALSE, 5); GtkWidget *button_ok = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_ok, TRUE, TRUE, 5); GtkWidget *button_cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL); gtk_box_pack_start (GTK_BOX (hbox_cancel_ok), button_cancel, TRUE, TRUE, 0); sess->label_countdown = gtk_label_new(NULL); gtk_box_pack_start (GTK_BOX (vbox), sess->label_countdown, FALSE, FALSE, 5); #if 1 #if WIN32 set_no_focus(main_window); #endif gtk_widget_realize(main_window); #if UNIX set_no_focus(main_window); #else win32_init_win(main_window); #endif #endif // dbg("mmmmmmmmmmmmm\n"); GTK_WIDGET_SET_FLAGS (button_ok, GTK_CAN_DEFAULT); gtk_widget_grab_default (button_ok); #if 1 // dbg("main_window %x\n", main_window); g_signal_connect (G_OBJECT (button_cancel), "clicked", G_CALLBACK (close_win_save_phrase), sess); g_signal_connect (G_OBJECT (button_ok), "clicked", G_CALLBACK (cb_ok), sess); #endif gtk_window_present(GTK_WINDOW(main_window)); gtk_window_set_keep_above(GTK_WINDOW(main_window), TRUE); // gtk_window_set_modal(GTK_WINDOW(main_window), TRUE); sess->countdown = 3; disp_countdown(sess); sess->countdown_handle = g_timeout_add(1000, timeout_countdown, sess); gtk_widget_show_all(main_window); }
static gboolean init (void) { search_tool = aud_plugin_lookup_basename ("search-tool"); aud_config_set_defaults ("gtkui", gtkui_defaults); audgui_set_default_icon(); audgui_register_stock_icons(); pw_col_init (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip ((GtkWindow *) window, FALSE); g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(window_delete), NULL); accel = gtk_accel_group_new (); gtk_window_add_accel_group ((GtkWindow *) window, accel); vbox_outer = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add ((GtkContainer *) window, vbox_outer); menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start ((GtkBox *) vbox_outer, menu_box, FALSE, FALSE, 0); toolbar = gtk_toolbar_new (); gtk_toolbar_set_style ((GtkToolbar *) toolbar, GTK_TOOLBAR_ICONS); GtkStyleContext * context = gtk_widget_get_style_context (toolbar); gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR); gtk_box_pack_start ((GtkBox *) vbox_outer, toolbar, FALSE, FALSE, 0); /* search button */ if (search_tool) { search_button = toggle_button_new (GTK_STOCK_FIND, NULL, toggle_search_tool); gtk_toolbar_insert ((GtkToolbar *) toolbar, search_button, -1); gtk_toggle_tool_button_set_active ((GtkToggleToolButton *) search_button, aud_plugin_get_enabled (search_tool)); aud_plugin_add_watch (search_tool, search_tool_toggled, NULL); } /* playback buttons */ toolbar_button_add (toolbar, button_open_pressed, GTK_STOCK_OPEN); toolbar_button_add (toolbar, button_add_pressed, GTK_STOCK_ADD); button_play = toolbar_button_add (toolbar, aud_drct_play_pause, GTK_STOCK_MEDIA_PLAY); button_stop = toolbar_button_add (toolbar, aud_drct_stop, GTK_STOCK_MEDIA_STOP); toolbar_button_add (toolbar, aud_drct_pl_prev, GTK_STOCK_MEDIA_PREVIOUS); toolbar_button_add (toolbar, aud_drct_pl_next, GTK_STOCK_MEDIA_NEXT); /* time slider and label */ GtkToolItem * boxitem1 = gtk_tool_item_new (); gtk_tool_item_set_expand (boxitem1, TRUE); gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem1, -1); GtkWidget * box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add ((GtkContainer *) boxitem1, box1); slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL); gtk_range_set_increments ((GtkRange *) slider, 5000, 5000); gtk_scale_set_draw_value(GTK_SCALE(slider), FALSE); gtk_widget_set_size_request(slider, 120, -1); gtk_widget_set_valign (slider, GTK_ALIGN_CENTER); gtk_widget_set_can_focus(slider, FALSE); gtk_box_pack_start ((GtkBox *) box1, slider, TRUE, TRUE, 6); label_time = markup_label_new(NULL); gtk_box_pack_end ((GtkBox *) box1, label_time, FALSE, FALSE, 6); gtk_widget_set_no_show_all (slider, TRUE); gtk_widget_set_no_show_all (label_time, TRUE); /* repeat and shuffle buttons */ button_repeat = toggle_button_new ("media-playlist-repeat", "RP", toggle_repeat); gtk_toolbar_insert ((GtkToolbar *) toolbar, button_repeat, -1); button_shuffle = toggle_button_new ("media-playlist-shuffle", "SF", toggle_shuffle); gtk_toolbar_insert ((GtkToolbar *) toolbar, button_shuffle, -1); /* volume button */ GtkToolItem * boxitem2 = gtk_tool_item_new (); gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem2, -1); GtkWidget * box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add ((GtkContainer *) boxitem2, box2); volume = gtk_volume_button_new(); gtk_button_set_relief(GTK_BUTTON(volume), GTK_RELIEF_NONE); gtk_scale_button_set_adjustment(GTK_SCALE_BUTTON(volume), GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 100, 1, 5, 0))); gtk_widget_set_can_focus(volume, FALSE); gint lvol = 0, rvol = 0; aud_drct_get_volume(&lvol, &rvol); gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), (lvol + rvol) / 2); gtk_box_pack_start ((GtkBox *) box2, volume, FALSE, FALSE, 0); /* main UI layout */ layout_load (); GtkWidget * layout = layout_new (); gtk_box_pack_start ((GtkBox *) vbox_outer, layout, TRUE, TRUE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); layout_add_center (vbox); ui_playlist_notebook_new (); gtk_box_pack_start ((GtkBox *) vbox, (GtkWidget *) UI_PLAYLIST_NOTEBOOK, TRUE, TRUE, 0); /* optional UI elements */ show_menu (aud_get_bool ("gtkui", "menu_visible")); show_infoarea (aud_get_bool ("gtkui", "infoarea_visible")); if (aud_get_bool ("gtkui", "statusbar_visible")) { statusbar = ui_statusbar_new (); gtk_box_pack_end ((GtkBox *) vbox_outer, statusbar, FALSE, FALSE, 0); } AUDDBG("hooks associate\n"); ui_hooks_associate(); AUDDBG("playlist associate\n"); ui_playlist_notebook_populate(); g_signal_connect(slider, "change-value", G_CALLBACK(ui_slider_change_value_cb), NULL); g_signal_connect(slider, "button-press-event", G_CALLBACK(ui_slider_button_press_cb), NULL); g_signal_connect(slider, "button-release-event", G_CALLBACK(ui_slider_button_release_cb), NULL); volume_change_handler_id = g_signal_connect(volume, "value-changed", G_CALLBACK(ui_volume_value_changed_cb), NULL); g_signal_connect(volume, "pressed", G_CALLBACK(ui_volume_pressed_cb), NULL); g_signal_connect(volume, "released", G_CALLBACK(ui_volume_released_cb), NULL); update_volume_timeout_source = g_timeout_add(250, (GSourceFunc) ui_volume_slider_update, volume); g_signal_connect (window, "map-event", (GCallback) window_mapped_cb, NULL); g_signal_connect (window, "key-press-event", (GCallback) window_keypress_cb, NULL); g_signal_connect (UI_PLAYLIST_NOTEBOOK, "key-press-event", (GCallback) playlist_keypress_cb, NULL); if (aud_drct_get_playing ()) { ui_playback_begin (); if (aud_drct_get_ready ()) ui_playback_ready (); } else ui_playback_stop (); title_change_cb (); gtk_widget_show_all (vbox_outer); update_toggles (NULL, NULL); menu_rclick = make_menu_rclick (accel); menu_tab = make_menu_tab (accel); return TRUE; }