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