static GtkWidget * dcc_gnome_make_mainwin (void)
{
GtkWidget *mainwin;
mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
{
char *title;
title = dcc_gnome_get_title ();
gtk_window_set_title (GTK_WINDOW (mainwin),
title);
free (title);
}
/* Set a reasonable default size that allows all columns and a few
rows to be seen with a typical theme */
gtk_window_set_default_size (GTK_WINDOW (mainwin), 500, 300);
/* Quit when it's closed */
g_signal_connect (GTK_OBJECT(mainwin), "delete-event",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (GTK_OBJECT(mainwin), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
#if GTK_CHECK_VERSION(2,2,0)
gtk_window_set_icon_from_file (GTK_WINDOW (mainwin),
PKGDATADIR "/distccmon-gnome-icon.png",
NULL);
#endif
return mainwin;
}
/*
* Error-Window, if user insert incorrect input type
*/
void window_error(char* error_msg){
GtkWidget *window,
*label,
*table = gtk_table_new (5, 10, TRUE),
*button = gtk_button_new_with_label ("Close");
GError *error = NULL;
/* Set all window options (color, size, position, etc) */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(window), 200, 150);
gtk_widget_set_size_request (window, 200, 150);
gtk_window_set_title (GTK_WINDOW(window), "Error!");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file (GTK_WINDOW(window), ICON_CLOSE , &error);
/* Error Message */
label = gtk_label_new (error_msg);
gtk_table_attach (GTK_TABLE (table), label, 1, 9, 1, 3, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_table_attach (GTK_TABLE (table), button, 0, 10, 4, 5, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (destroy), G_OBJECT (window));
/* Attach tabke at window container */
gtk_container_add (GTK_CONTAINER (window), table);
/* Exit event and Widget Show */
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show_all (window);
}
static GtkWidget*
mug_shell (MugData *mugdata)
{
GtkWidget *vbox;
mugdata->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (mugdata->win), "Mug Mail Search");
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
mugdata->toolbar = mug_toolbar (mugdata);
gtk_box_pack_start (GTK_BOX (vbox), mugdata->toolbar, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (vbox), mug_main_area (mugdata), TRUE,
TRUE, 2);
mugdata->statusbar = mug_statusbar ();
gtk_box_pack_start (GTK_BOX (vbox), mugdata->statusbar, FALSE, FALSE,
2);
gtk_container_add (GTK_CONTAINER (mugdata->win), vbox);
gtk_widget_show_all (vbox);
gtk_window_set_default_size (GTK_WINDOW (mugdata->win), 700, 500);
gtk_window_set_resizable (GTK_WINDOW (mugdata->win), TRUE);
{
gchar *icon;
icon = g_strdup_printf ("%s%cmug.svg",
MUGDIR, G_DIR_SEPARATOR);
gtk_window_set_icon_from_file (GTK_WINDOW (mugdata->win), icon, NULL);
g_free (icon);
}
return mugdata->win;
}
static gint
luaH_window_newindex(lua_State *L, luapdf_token_t token)
{
widget_t *w = luaH_checkwidget(L, 1);
switch(token)
{
LUAPDF_WIDGET_BIN_NEWINDEX_COMMON(w)
case L_TK_DECORATED:
gtk_window_set_decorated(GTK_WINDOW(w->widget),
luaH_checkboolean(L, 3));
break;
case L_TK_TITLE:
gtk_window_set_title(GTK_WINDOW(w->widget),
luaL_checkstring(L, 3));
break;
case L_TK_ICON:
gtk_window_set_icon_from_file(GTK_WINDOW(w->widget),
luaL_checkstring(L, 3), NULL);
break;
default:
return 0;
}
return luaH_object_emit_property_signal(L, 1);
}
int main(int argc, char *argv[]) {
GtkWidget *notebook;
GtkWidget *tab;
gtk_init(&argc, &argv);
glutInit(&argc, argv);//对GLUT进行初始化，这个函数必须在其它的GLUT使用之前调用一次
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "罗婷婷插补仿真系统");
gtk_window_set_icon_from_file(GTK_WINDOW(window),"Goozillian.jpg",0);
gtk_window_set_default_size(GTK_WINDOW(window), 300, 200);
notebook = gtk_notebook_new();
tab = createTab("Timting.jpg", "空间直线插补");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), addButton(tab1Box(w_tab1),line_interpolation), tab);
tab = createTab("Timting.jpg", "空间圆弧插补");
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), addButton(tab2Box(w_tab2),circle_interpolation/*不提供参数就要使用extern*/), tab);
gtk_container_add(GTK_CONTAINER(window), to_a_vbox(createMenu(),notebook));
g_signal_connect(GTK_OBJECT(window), "destroy",G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void display_about_dialog(GtkWidget *widget, gpointer *user_data) {
/** Display the about window. **/
GtkWidget *about_dialog = gtk_about_dialog_new() ;
gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(about_dialog), prgname.c_str()) ;
gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(about_dialog), VERSION) ;
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(PATH_TO_PRG_ICON, NULL);
gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(about_dialog), pixbuf) ;
g_object_unref(pixbuf) ;
gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(about_dialog), COPYRIGHT) ;
char *license_content ;
g_file_get_contents(PATH_TO_GPLV3, &license_content, NULL, NULL);
gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(about_dialog), license_content) ;
gtk_about_dialog_set_wrap_license(GTK_ABOUT_DIALOG(about_dialog), TRUE) ;
gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(about_dialog), PRGWEBURL) ;
gtk_about_dialog_set_website_label(GTK_ABOUT_DIALOG(about_dialog), PRGNAME "Website" ) ;
gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(about_dialog), "Thanks to my beloved mother, my family and to the doctors.\nStay away from drugs: drugs destroy your brain and your life.") ;
const char *programmer[] = { AUTHOR " " MAIL, NULL } ;
gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(about_dialog), programmer) ;
const char *artist[] = { AUTHOR " " MAIL, NULL } ;
gtk_about_dialog_set_artists( GTK_ABOUT_DIALOG(about_dialog), artist) ;
const char *documenters[] = { AUTHOR " " MAIL, NULL } ;
gtk_about_dialog_set_documenters( GTK_ABOUT_DIALOG(about_dialog), documenters) ;
gtk_window_set_icon_from_file(GTK_WINDOW(about_dialog), PATH_TO_PRG_WIN_ICON, NULL) ;
gtk_window_set_position(GTK_WINDOW(about_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_window_set_resizable(GTK_WINDOW(about_dialog), FALSE);
gtk_widget_set_size_request(about_dialog, -1, -1) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(about_dialog), TRUE) ;
gtk_window_set_transient_for(GTK_WINDOW(about_dialog), GTK_WINDOW(gui->window)) ;
g_signal_connect_swapped(G_OBJECT(about_dialog), "response", G_CALLBACK (gtk_widget_destroy), about_dialog) ;
gtk_dialog_run(GTK_DIALOG(about_dialog) ) ;
}
void
set_icon() {
if(file_exists(uzbl.gui.icon)) {
if (uzbl.gui.main_window)
gtk_window_set_icon_from_file (GTK_WINDOW (uzbl.gui.main_window), uzbl.gui.icon, NULL);
} else {
g_printerr ("Icon \"%s\" not found. ignoring.\n", uzbl.gui.icon);
}
}
int main(int argc,char **argv)
{
GtkWidget *win;
GtkWidget *button;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *frame;
IS_SELECT is_select;
change_path(argv[0]);
gtk_init(&argc,&argv);
win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(win),"IScreenshot");
gtk_window_set_icon_from_file(GTK_WINDOW(win),
"img/64x64/iscreenshot.png",NULL);
g_signal_connect(G_OBJECT(win),"delete_event",
G_CALLBACK(really_quit),NULL);
init_data(&is_select,win);
vbox=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(win),vbox);
create_title_screen(vbox);
frame=gtk_frame_new("Select");
hbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),frame,FALSE,FALSE,0);
gtk_container_add(GTK_CONTAINER(frame),hbox);
frame=gtk_frame_new("Region to capture");
gtk_box_pack_start(GTK_BOX(hbox),frame,FALSE,FALSE,0);
create_radio_button(frame,&is_select);
frame=gtk_frame_new("Delay before capturing");
gtk_box_pack_start(GTK_BOX(hbox),frame,FALSE,FALSE,0);
create_select_time(frame,&is_select);
hbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
button=gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,FALSE,10);
g_signal_connect(G_OBJECT(button),"clicked",
G_CALLBACK(screenshot),&is_select);
button=gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_box_pack_end(GTK_BOX(hbox),button,FALSE,FALSE,10);
g_signal_connect(G_OBJECT(button),"clicked",
G_CALLBACK(really_quit),NULL);
gtk_widget_show_all(win);
gtk_main();
}
/** \brief Invoke Sky-at-glance.
*
* This function is a shortcut to the sky at glance function
* in that it will make the predictions with the satellites
* tracked in the current module.
*/
static void sky_at_glance_cb (GtkWidget *menuitem, gpointer data)
{
GtkSatModule *module = GTK_SAT_MODULE (data);
//GtkWidget *skg;
//GtkWidget *window;
gchar *buff;
(void) menuitem; /* avoid unused parameter compiler warning */
/* if module is busy wait until done then go on */
g_mutex_lock(&module->busy);
if (module->skgwin != NULL) {
/* there is already a sky at glance for this module */
gtk_window_present (GTK_WINDOW (module->skgwin));
g_mutex_unlock(&module->busy);
return;
}
/* create window */
module->skgwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
buff = g_strdup_printf (_("The sky at a glance (%s)"), module->name);
gtk_window_set_title (GTK_WINDOW (module->skgwin), buff);
g_free (buff);
g_signal_connect (G_OBJECT (module->skgwin), "delete_event", G_CALLBACK (window_delete), NULL);
g_signal_connect (G_OBJECT (module->skgwin), "destroy", G_CALLBACK (destroy_skg), module);
/* window icon */
buff = icon_file_name ("gpredict-planner.png");
gtk_window_set_icon_from_file (GTK_WINDOW (module->skgwin), buff, NULL);
g_free (buff);
/* create sky at a glance widget */
if (sat_cfg_get_bool (SAT_CFG_BOOL_PRED_USE_REAL_T0)) {
module->skg = gtk_sky_glance_new (module->satellites, module->qth, 0.0);
}
else {
module->skg = gtk_sky_glance_new (module->satellites, module->qth, module->tmgCdnum);
}
/* store time at which GtkSkyGlance has been created */
module->lastSkgUpd = module->tmgCdnum;
gtk_container_set_border_width (GTK_CONTAINER (module->skgwin), 10);
gtk_container_add (GTK_CONTAINER (module->skgwin), module->skg);
gtk_widget_show_all (module->skgwin);
g_mutex_unlock(&module->busy);
}
void iscreenshot_save(GdkPixbuf *pixbuf)
{
GtkWidget *win;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *box;
GtkWidget *save_to_file;
GtkWidget *save_to_clipboard;
GtkWidget *cancel;
GtkWidget *show;
GtkWidget *image;
GdkPixbuf *temp;
gtk_init(NULL,NULL);
win=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(win),GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(win),"IScreenShot Save");
gtk_window_set_icon_from_file(GTK_WINDOW(win),"img/64x64/save.png",NULL);
g_signal_connect(G_OBJECT(win),"delete_event",G_CALLBACK(gtk_main_quit),NULL);
box=gtk_vbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(win),box);
hbox=gtk_hbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(box),hbox,FALSE,FALSE,0);
vbox=gtk_vbox_new(FALSE,0);
gtk_box_pack_start(GTK_BOX(hbox),vbox,FALSE,FALSE,0);
save_to_file=gtk_button_new_with_label("Save To File");
gtk_box_pack_start(GTK_BOX(vbox),save_to_file,FALSE,FALSE,5);
g_signal_connect(G_OBJECT(save_to_file),"clicked",
G_CALLBACK(iscreenshot_save_to_file),pixbuf);
save_to_clipboard=gtk_button_new_with_label("Save To Clipboard");
gtk_box_pack_start(GTK_BOX(vbox),save_to_clipboard,FALSE,FALSE,5);
g_signal_connect(G_OBJECT(save_to_clipboard),"clicked",
G_CALLBACK(iscreenshot_save_to_clipboard),pixbuf);
show=gtk_button_new_with_label("Only Show");
gtk_box_pack_start(GTK_BOX(vbox),show,FALSE,FALSE,5);
g_signal_connect(G_OBJECT(show),"clicked",
G_CALLBACK(iscreenshot_save_only_show),pixbuf);
cancel=gtk_button_new_with_label("Cancel");
gtk_box_pack_start(GTK_BOX(vbox),cancel,FALSE,FALSE,5);
g_signal_connect(G_OBJECT(cancel),"clicked",
G_CALLBACK(gtk_main_quit),NULL);
temp=gdk_pixbuf_scale_simple(pixbuf,200,130,GDK_INTERP_BILINEAR);
image=gtk_image_new_from_pixbuf(temp);
gtk_box_pack_end(GTK_BOX(hbox),image,FALSE,FALSE,10);
gtk_widget_show_all(win);
gtk_main();
}
int
main (int argc, char *argv[])
{
GConfClient *client;
GConfChangeSet *changeset;
GladeXML *dialog = NULL;
GtkWidget *dialog_win;
bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gnome_program_init ("brightside-properties", VERSION,
LIBGNOMEUI_MODULE, argc, argv,
NULL);
client = gconf_client_get_default ();
gconf_client_add_dir (client, BRIGHTSIDE_KEY_ROOT,
GCONF_CLIENT_PRELOAD_RECURSIVE, NULL);
conf_client = client;
changeset = gconf_change_set_new ();
dialog = create_dialog ();
setup_dialog (dialog, changeset);
dialog_win = gtk_dialog_new_with_buttons(
_("Screen Actions"), NULL,
GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
NULL);
gtk_container_set_border_width (GTK_CONTAINER (dialog_win), 5);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG(dialog_win)->vbox), 2);
gtk_dialog_set_default_response (GTK_DIALOG (dialog_win),
GTK_RESPONSE_CLOSE);
g_signal_connect (G_OBJECT (dialog_win), "response",
(GCallback) dialog_button_clicked_cb, changeset);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog_win)->vbox),
WID ("prefs_widget"), TRUE, TRUE, 0);
gtk_window_set_resizable (GTK_WINDOW (dialog_win), FALSE);
gtk_window_set_icon_from_file (GTK_WINDOW (dialog_win),
BRIGHTSIDE_DATA "brightside.svg", NULL);
gtk_widget_show_all (dialog_win);
if (is_running () == FALSE)
g_spawn_command_line_async ("brightside", NULL);
gtk_main ();
gconf_change_set_unref (changeset);
g_object_unref (dialog);
return 0;
}
/** \brief Open Radio control window.
* \param menuitem The menuitem that was selected.
* \param data Pointer the GtkSatModule.
*/
static void rigctrl_cb (GtkWidget *menuitem, gpointer data)
{
GtkSatModule *module = GTK_SAT_MODULE (data);
gchar *buff;
(void) menuitem; /* avoid unused parameter compiler warning */
if (module->rigctrlwin != NULL) {
/* there is already a roto controller for this module */
gtk_window_present (GTK_WINDOW (module->rigctrlwin));
return;
}
module->rigctrl = gtk_rig_ctrl_new (module);
if (module->rigctrl == NULL) {
/* gtk_rot_ctrl_new returned NULL becasue no radios are configured */
GtkWidget *dialog;
dialog = gtk_message_dialog_new (GTK_WINDOW (app),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("You have no radio configuration!\n"\
"Please configure a radio first.")
);
g_signal_connect_swapped (dialog, "response",
G_CALLBACK (gtk_widget_destroy), dialog);
gtk_window_set_title (GTK_WINDOW (dialog), _("ERROR"));
gtk_widget_show_all (dialog);
return;
}
/* create a window */
module->rigctrlwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
buff = g_strdup_printf (_("Gpredict Radio Control: %s"), module->name);
gtk_window_set_title (GTK_WINDOW (module->rigctrlwin), buff);
g_free (buff);
g_signal_connect (G_OBJECT (module->rigctrlwin), "delete_event",
G_CALLBACK (window_delete), NULL);
g_signal_connect (G_OBJECT (module->rigctrlwin), "destroy",
G_CALLBACK (destroy_rigctrl), module);
/* window icon */
buff = icon_file_name ("gpredict-oscilloscope.png");
gtk_window_set_icon_from_file (GTK_WINDOW (module->rigctrlwin), buff, NULL);
g_free (buff);
gtk_container_add (GTK_CONTAINER (module->rigctrlwin), module->rigctrl);
gtk_widget_show_all (module->rigctrlwin);
}
/**************************************************************************
Entry point of the freeciv-modpack program
**************************************************************************/
int main(int argc, char *argv[])
{
GtkWidget *toplevel;
int loglevel = LOG_NORMAL;
int ui_options;
init_nls();
init_character_encodings(FC_DEFAULT_DATA_ENCODING, FALSE);
fc_init_network();
g_thread_init(NULL);
log_init(NULL, loglevel, NULL, NULL, -1);
/* This modifies argv! */
ui_options = fcmp_parse_cmdline(argc, argv);
if (ui_options != -1) {
/* Process GTK arguments */
gtk_init(&ui_options, &argv);
toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_realize(toplevel);
gtk_widget_set_name(toplevel, "Freeciv-modpack");
gtk_window_set_title(GTK_WINDOW(toplevel), _("Freeciv modpack installer"));
/* Keep the icon of the executable on Windows */
#ifndef WIN32_NATIVE
{
/* Unlike main client, this only works if installed. Ignore any
* errors loading the icon. */
GError *err;
(void) gtk_window_set_icon_from_file(GTK_WINDOW(toplevel), MPICON_PATH,
&err);
}
#endif /* WIN32_NATIVE */
g_signal_connect(toplevel, "delete_event",
G_CALLBACK(quit_dialog_callback), NULL);
modinst_setup_widgets(toplevel);
gtk_widget_show_all(toplevel);
gtk_main();
}
return EXIT_SUCCESS;
}
void windows_adduser()
{
GtkWidget *table = gtk_table_new (10, 10, TRUE),
*label,
*button,
*twitterLogin,
*tw_login_imgevent;
GError *error = NULL;
AuthWidget *DataInput;
/* allocate space for struct */
DataInput = g_slice_new (AuthWidget);
/* Set all window options (color, size, position, logo, icon, etc) */
DataInput->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(DataInput->window), 200, 210);
gtk_widget_set_size_request (DataInput->window, 200, 210);
gtk_window_set_title (GTK_WINDOW(DataInput->window), "Nuovo Utente");
gtk_container_set_border_width (GTK_CONTAINER (DataInput->window), 0);
gtk_window_set_position(GTK_WINDOW(DataInput->window), GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file (GTK_WINDOW(DataInput->window), ICON_ADDUSER, &error);
/* Attach twitter-login image */
twitterLogin = gtk_image_new_from_file (ICON_SIGNIN);
tw_login_imgevent = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (tw_login_imgevent), twitterLogin);
gtk_table_attach (GTK_TABLE (table), tw_login_imgevent, 0, 10, 1, 3, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
/* Call oAuth function */
g_signal_connect (G_OBJECT (tw_login_imgevent), "button_press_event", G_CALLBACK(temp_token), NULL);
/* Attach Box for PIN */
label = gtk_label_new ("Inserisci PIN");
DataInput->pin = gtk_entry_new ();
gtk_label_set_justify(GTK_LABEL (label),GTK_JUSTIFY_LEFT);
gtk_entry_set_text (GTK_ENTRY (DataInput->pin), "");
gtk_table_attach (GTK_TABLE (table), label, 1, 9, 3, 5, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_table_attach (GTK_TABLE (table), DataInput->pin, 1, 9, 5, 6, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
/* Press Button and call function for verify PIN */
button = gtk_button_new_with_label ("Crea Account");
gtk_table_attach (GTK_TABLE (table), button, 1, 9,7, 9, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_container_add (GTK_CONTAINER (DataInput->window), table);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK(access_token_gtk), DataInput);
/* Exit event and Widget Show */
g_signal_connect (G_OBJECT (DataInput->window), "delete_event", G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show_all (DataInput->window);
}
/*--------------------------------------------------------------------------*\
*
\*--------------------------------------------------------------------------*/
gboolean
on_win_dispensers_delete_event (GtkWidget *widget,
GdkEvent *event,
gpointer user_data)
{
/*-- Stop the update timer going -----------------------------------*/
DataFn_StopDispenserTimer();
/*-- As this event deletes the window we need to re-create it -------*/
WinAcceptors = create_win_dispensers();
gtk_window_set_position (GTK_WINDOW(WinDispensers),GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_icon_from_file (GTK_WINDOW(WinDispensers),
"../pixmaps/AESDemo-icon.png", NULL);
return FALSE;
}
/*
* Upgrade Window
* Check Updates from vebsite http://www.twitcrusader.org and get file version.php
*
*/
void windows_upgrade(){
FILE* checkLatesVersion = NULL;
char bufferLatesVersion[10];
GtkWidget *window,
*lastVersionMSG = gtk_label_new ("Last Version: "),
*lastVersionCheck,
*currentVersionMSG = gtk_label_new ("Current Version: "),
*currentVersionCheck = gtk_label_new (TWC_VERSION),
*table = gtk_table_new (8, 10, TRUE),
*button = gtk_button_new_with_label ("Close");
GError *error = NULL;
/* Check Online Version From WebSite and Download File To /tmp/ directory */
system ("wget -O /tmp/version.twc "TWC_UPDATES_URL"?current="TWC_VERSION);
/* Check version with downloaded file */
checkLatesVersion = fopen ("/tmp/version.twc", "r");
fgets(bufferLatesVersion, 10, checkLatesVersion);
/* Remove tmp file */
remove("/tmp/version.twc");
/* Set all window options (color, size, position, etc) */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(window), 240, 180);
gtk_widget_set_size_request (window, 240, 180);
gtk_window_set_title (GTK_WINDOW(window), "Check Updates");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file (GTK_WINDOW(window), ICON_UPGRADE, &error);
/* Attach All Widget */
lastVersionCheck = gtk_label_new (bufferLatesVersion);
gtk_table_attach (GTK_TABLE (table), currentVersionMSG, 1, 6, 1, 2, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_table_attach (GTK_TABLE (table), currentVersionCheck, 6, 9, 1, 2, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_table_attach (GTK_TABLE (table), lastVersionMSG, 1, 5, 3, 4, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_table_attach (GTK_TABLE (table), lastVersionCheck, 6, 9, 3, 4, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_table_attach (GTK_TABLE (table), button, 1, 9, 5, 7, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (destroy), G_OBJECT (window));
/* Attach tabke at window container */
gtk_container_add (GTK_CONTAINER (window), table);
/* Exit event and Widget Show */
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_widget_destroy), NULL);
gtk_widget_show_all (window);
}
int main(int argc, char **argv)
{
bindtextdomain("tray_eject", LOCALE_DIR);
textdomain("tray_eject");
gtk_init(&argc, &argv);
count = 0;
dev = g_hash_table_new_full(g_str_hash, g_str_equal, key_destroy,
value_destroy);
icon = (GtkStatusIcon *)
gtk_status_icon_new_from_file(ICON_PATH "dev1.png");
update_status();
menu = gtk_menu_new();
item = gtk_menu_item_new_with_label(_("Safely remove all"));
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(eject), NULL);
sep = gtk_separator_menu_item_new();
gtk_widget_show(sep);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep);
g_signal_connect(G_OBJECT(icon), "popup-menu",
G_CALLBACK(popup), NULL);
if (init_hal() < 0)
return 1;
dialog = gtk_dialog_new_with_buttons("Error", NULL,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, NULL);
gtk_window_set_icon_from_file(GTK_WINDOW(dialog), ICON_PATH "error.png", NULL);
msg = gtk_label_new(_("Unable to unmount this device. Some\napplication is likely to be using it.\nPlease close the offending application\nand try again."));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), msg, TRUE, TRUE, 10);
gtk_widget_show(msg);
gtk_main();
return 0;
}
int
main(int argc, char **argv)
{
gtk_init(&argc, &argv);
char *glade_xml_file = find_in_share("c2v.glade");
if (!glade_xml_file) {
printf("Couldn't find the glade file: c2v.glade. "
"Aborting...\n");
exit(1);
}
glade_xml = glade_xml_new(glade_xml_file, NULL, NULL);
free(glade_xml_file);
set_font();
set_title();
GtkWidget *win = get_widget_checked("c2v_window");
GError *err=NULL;
int ok=gtk_window_set_icon_from_file(GTK_WINDOW(win),
imgloc("c2v.png"),&err);
if (!ok)
printf("Error loading icon: %s\n", err->message);
if (argc>1) {
select_defaults_by_file_type(argv[1],TRUE);
add_input_file(argv[1]);
int output_format = get_combo_box_item("output_format_combobox");
process();
// if we opened up an external application, we can just exit now
// otherwise we will stay open
if (output_format == OUTPUT_KML || output_format == OUTPUT_ALOS_CSV)
exit(EXIT_SUCCESS);
}
else {
set_combo_box_item("input_format_combobox", INPUT_AUTO);
set_combo_box_item("output_format_combobox", OUTPUT_KML);
}
glade_xml_signal_autoconnect(glade_xml);
gtk_main ();
exit (EXIT_SUCCESS);
}
void display_message_dialog(const char *title, const char *msg, GtkMessageType type, GtkButtonsType button_type) {
/** Display a message dialog for informing the user with a message. **/
GtkWidget *message_dialog = gtk_message_dialog_new(GTK_WINDOW(gui->window), GTK_DIALOG_MODAL, type, button_type, msg, NULL ) ;
gtk_window_set_icon_from_file(GTK_WINDOW(message_dialog), PATH_TO_PRG_WIN_ICON, NULL) ;
gtk_window_set_title(GTK_WINDOW(message_dialog), title) ;
gtk_window_set_position(GTK_WINDOW(message_dialog), GTK_WIN_POS_CENTER_ALWAYS) ;
gtk_window_set_resizable(GTK_WINDOW(message_dialog), FALSE);
gtk_widget_set_size_request(message_dialog,-1,-1) ;
gtk_window_set_modal(GTK_WINDOW(message_dialog), TRUE) ;
gtk_window_set_destroy_with_parent(GTK_WINDOW(message_dialog), TRUE) ;
g_signal_connect_swapped(G_OBJECT(message_dialog), "response", G_CALLBACK (gtk_widget_destroy), message_dialog) ;
gtk_dialog_run(GTK_DIALOG(message_dialog) ) ;
}
GtkWidget *make_dialog(const gchar *title, const gchar *icon_file)
{
GtkWidget *dialog;
GtkWidget *hbox_label;
GtkWidget *hbox_button;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *button;
dialog = gtk_dialog_new();
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ALWAYS);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
gtk_window_set_title(GTK_WINDOW(dialog), title);
gtk_window_set_icon_from_file(GTK_WINDOW(dialog), icon_file, NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
hbox_label = gtk_hbox_new(FALSE, 0);
label = gtk_label_new(dialog_text);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(hbox_label), label, FALSE, FALSE, 0);
hbox_button = gtk_hbox_new(TRUE, 0);
button = gtk_button_new_with_label(dialog_button_text[0]);
gtk_widget_set_size_request(button, 70, 26);
gtk_box_pack_start(GTK_BOX(hbox_button), button, FALSE, FALSE, 5);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(dialog_ok), (gpointer)title);
button = gtk_button_new_with_label(dialog_button_text[1]);
gtk_widget_set_size_request(button, 70, 26);
gtk_box_pack_start(GTK_BOX(hbox_button), button, FALSE, FALSE, 5);
gtk_window_set_focus(GTK_WINDOW(dialog), button);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(dialog_cancel), NULL);
vbox = GTK_DIALOG(dialog)->vbox;
gtk_box_pack_start(GTK_BOX(vbox), hbox_label, FALSE, FALSE, 10);
gtk_box_pack_start(GTK_BOX(vbox), hbox_button, FALSE, FALSE, 0);
return dialog;
}
GtkWidget * intro_window(){
GtkWidget *window, *img;
// Thiet lap window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Giới thiệu");
gtk_window_set_default_size(GTK_WINDOW(window), 500, 300);
gtk_window_set_type_hint(GTK_WINDOW(window),GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 5);
gtk_window_set_opacity(GTK_WINDOW(window),0.9);
gtk_window_set_icon_from_file(GTK_WINDOW(window),"skin//icon.png",NULL);
// Them hinh vao window
img = gtk_image_new_from_file("skin//intro.png");
gtk_container_add(GTK_CONTAINER(window), img);
return window;
}
void window_set_icon(GtkWidget *window, const gchar *icon, const gchar *file)
{
if (!icon && !file) icon = PIXBUF_INLINE_ICON;
if (icon)
{
GdkPixbuf *pixbuf;
pixbuf = pixbuf_inline(icon);
if (pixbuf)
{
gtk_window_set_icon(GTK_WINDOW(window), pixbuf);
g_object_unref(pixbuf);
}
}
else
{
gtk_window_set_icon_from_file(GTK_WINDOW(window), file, NULL);
}
}
void on_about_activate(GtkImageMenuItem* widget, gpointer data) {
GError* err = NULL;
GdkPixbuf* icon = gdk_pixbuf_new_from_file_at_size
(DATADIR"/qwertickle.png", 100, 100, &err);
const gchar* authors[] = { "Wei-Ning Huang\n<*****@*****.**>\n", NULL};
GtkAboutDialog* dialog = GTK_ABOUT_DIALOG(gtk_about_dialog_new());
gtk_window_set_icon_from_file(
GTK_WINDOW(dialog), DATADIR"/qwertickle.png", &err);
gtk_about_dialog_set_authors(dialog, authors);
gtk_about_dialog_set_program_name(dialog, PACKAGE_NAME);
gtk_about_dialog_set_version(dialog, PACKAGE_VERSION);
gtk_about_dialog_set_website(dialog, PACKAGE_URL);
gtk_about_dialog_set_copyright(dialog, PACKAGE_COPYRIGHT);
gtk_about_dialog_set_license(dialog, PACKAGE_LICENSE);
gtk_about_dialog_set_logo(dialog, icon);
gtk_about_dialog_set_comments(dialog, PACKAGE_COMMENTS);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(GTK_WIDGET(dialog));
}
/*
* About window
*
*/
void windows_about(){
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(ICON_ABOUT, NULL);
GtkWidget *dialog = gtk_about_dialog_new();
GError *error = NULL;
/* Set all window options (color, size, position, logo, icon, etc) */
gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(dialog), "TwitCrusader");
gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), "");
gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(dialog), "(c) PTKDev, RoxShannon");
gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(dialog), "Basato su librerie GTK e semplicità!\n\nVersion: "TWC_VERSION""TWC_VERSION_STATUS);
gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(dialog), "http://www.twitcrusader.org/");
gtk_window_set_icon_from_file (GTK_WINDOW(dialog), ICON_STAR, &error);
gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(dialog), pixbuf);
g_object_unref(pixbuf), pixbuf = NULL;
/* CALLBACK: exit event and Widget Show */
gtk_dialog_run(GTK_DIALOG (dialog));
gtk_widget_destroy(dialog);
}
int main (int argc, char *argv[]) {
GtkWindow *mainwindow;
GtkWidget *notlivedialog;
GtkWidget *menubar1;
GtkWidget *about;
GtkAboutDialog *aboutdialog;
gchar *path;
setlocale(LC_ALL, "");
bindtextdomain(PROJECT_NAME, LOCALE_DIR);
textdomain(PROJECT_NAME);
path = g_strdup_printf("/sbin:/usr/sbin:/usr/local/sbin:%s", g_getenv("PATH"));
g_setenv("PATH", path, TRUE);
g_free(path);
gtk_init(&argc, &argv);
widgetstree = gtk_builder_new();
gtk_builder_add_from_file(widgetstree, UI_FILE, NULL);
gtk_builder_connect_signals(widgetstree, NULL);
pid = 0;
location = NULL;
mainwindow = (GtkWindow *) gtk_builder_get_object(widgetstree, "mainwindow");
gtk_window_set_icon_from_file(mainwindow, APP_ICON, NULL);
aboutdialog = (GtkAboutDialog *) gtk_builder_get_object(widgetstree, "aboutdialog");
gtk_about_dialog_set_version(aboutdialog, PROJECT_VERSION);
gtk_widget_show((GtkWidget *) mainwindow);
if (g_file_test("/live/media/boot/liveboot", G_FILE_TEST_EXISTS)) {
initlocations();
} else {
notlivedialog = (GtkWidget *) gtk_builder_get_object(widgetstree, "notlivedialog");
gtk_widget_show(notlivedialog);
}
gtk_main();
return 0;
}
void fileops_confirm_trash ()
{
GtkWidget* dialog;
int result;
dialog = gtk_message_dialog_new (NULL,
GTK_DIALOG_MODAL,
GTK_MESSAGE_WARNING,
GTK_BUTTONS_CANCEL,
NULL);
gtk_window_set_title (GTK_WINDOW (dialog), _("Empty Trash"));
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
char* _icon = icon_name_to_path ("user-trash-full", 16);
if (_icon != NULL)
{
gtk_window_set_icon_from_file (GTK_WINDOW (dialog), _icon, NULL);
g_free (_icon);
}
g_object_set (dialog,
"text", _("Empty all items from Trash?"),
"secondary-text", _("All items in the Trash will be permanently deleted."),
NULL);
gtk_dialog_add_buttons (GTK_DIALOG (dialog), _("Empty _Trash"),
GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_widget_add_events (dialog, GDK_FOCUS_CHANGE_MASK);
g_signal_connect (dialog, "focus-in-event", G_CALLBACK(focus_cb), NULL);
result = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (result == GTK_RESPONSE_OK)
fileops_empty_trash ();
}
/*
static void cb_scroll_event(GtkAdjustment *adj, GtkWidget *view)
{
gtk_text_view_place_cursor_onscreen(GTK_TEXT_VIEW(view));
}
*/
MainWin *create_main_window(void)
{
GtkWidget *vbox;
GtkWidget *sw;
MainWin *mw = g_malloc(sizeof(MainWin));
mw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name(mw->window, PACKAGE_NAME);
gtk_window_set_icon_from_file(GTK_WINDOW(mw->window), ICONDIR"/l3afpad.png", NULL);
gtk_window_set_default_icon_name(PACKAGE);
g_signal_connect(G_OBJECT(mw->window), "delete-event",
G_CALLBACK(on_file_quit), NULL);
g_signal_connect_after(G_OBJECT(mw->window), "delete-event",
G_CALLBACK(gtk_widget_hide_on_delete), NULL);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(mw->window), vbox);
mw->menubar = create_menu_bar(mw->window);
gtk_box_pack_start(GTK_BOX(vbox), gtk_ui_manager_get_widget(mw->menubar, "/M"), FALSE, FALSE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_hexpand (sw, TRUE);
gtk_widget_set_vexpand (sw, TRUE);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
mw->view = create_text_view();
gtk_container_add(GTK_CONTAINER(sw), mw->view);
mw->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(mw->view));
return mw;
}
int main (int argc, char *argv[])
{
GtkWidget *darea;
GtkWidget *window;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
darea = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window), darea);
gtk_widget_add_events(window, GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(darea), "draw", G_CALLBACK(on_draw_event), NULL);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(on_quit_event), NULL);
g_signal_connect(G_OBJECT(window), "button-press-event", G_CALLBACK(clicked), NULL);
if (TIME_INTERVAL > 0) {
// Add timer event
// Register the timer and set time in mS.
// The timer_event() function is called repeatedly until it returns FALSE.
g_timeout_add(TIME_INTERVAL, (GSourceFunc) on_timer_event, (gpointer) window);
}
gtk_window_set_default_size(GTK_WINDOW(window), WINDOW_WIDTH, WINDOW_HEIGHT);
gtk_window_set_title(GTK_WINDOW(window), WINDOW_NAME);
if (strlen(ICON_NAME) > 0) {
gtk_window_set_icon_from_file(GTK_WINDOW(window), ICON_NAME, NULL);
}
application_init();
gtk_widget_show_all(window);
gtk_main();
return 0;
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1set_1icon_1from_1file
(
JNIEnv* env,
jclass cls,
jlong _self,
jstring _filename
)
{
GtkWindow* self;
const gchar* filename;
GError* error = NULL;
// convert parameter self
self = (GtkWindow*) _self;
// convert parameter filename
filename = (const gchar*) bindings_java_getString(env, _filename);
if (filename == NULL) {
return; // Java Exception already thrown
}
// call function
gtk_window_set_icon_from_file(self, filename, &error);
// cleanup parameter self
// cleanup parameter filename
bindings_java_releaseString(filename);
// check for error
if (error) {
bindings_java_throwGlibException(env, error);
return;
}
}
static gint
luaH_window_newindex(lua_State *L, luakit_token_t token)
{
size_t len;
widget_t *w = luaH_checkwidget(L, 1);
switch(token)
{
case L_TK_TITLE:
gtk_window_set_title(GTK_WINDOW(w->widget),
luaL_checklstring(L, 3, &len));
break;
case L_TK_ICON:
gtk_window_set_icon_from_file(GTK_WINDOW(w->widget),
luaL_checklstring(L, 3, &len), NULL);
break;
default:
return 0;
}
return luaH_object_emit_property_signal(L, 1);
}
