unsigned int volk_rank_archs(const char *indices[], const int* arch_defs, unsigned int n_archs, const char* name, unsigned int arch) { unsigned int i; unsigned int best_val = 0; static struct volk_arch_pref *volk_arch_prefs; static unsigned int n_arch_prefs = 0; static int prefs_loaded = 0; if(!prefs_loaded) { n_arch_prefs = load_preferences(&volk_arch_prefs); prefs_loaded = 1; } //now look for the function name in the prefs list for(i=0; i < n_arch_prefs; i++) { if(!strncmp(name, volk_arch_prefs[i].name, 128)) { //found it return get_index(indices, n_archs, volk_arch_prefs[i].arch); } } for(i=1; i < n_archs; ++i) { if((arch_defs[i]&(!arch)) == 0) { best_val = (arch_defs[i] > arch_defs[best_val + 1]) ? i-1 : best_val; } } return best_val; }
void fe_init (void) { GConfClient *client; client = gconf_client_get_default (); gconf_client_add_dir (client, "/apps/xchat", GCONF_CLIENT_PRELOAD_NONE, NULL); g_object_unref (client); u = userlist_new (); gui.quit = FALSE; palette_init (); run_migrations (); initialize_gui_1 (); if (!preferences_exist ()) { run_setup_dialog (); } else { set_version (); } servlist_init (); initialize_gui_2 (); load_preferences (); run_main_window (opt_fullscreen); /* Force various window-related options to match our interaction model */ prefs.use_server_tab = TRUE; prefs.notices_tabs = FALSE; prefs.servernotice = TRUE; prefs.slist_skip = FALSE; /* If we don't have a specific DCC IP address, force get-from-server */ if (strlen (prefs.dcc_ip_str) == 0) { prefs.ip_from_server = TRUE; } /* Don't allow the core to autoload plugins. We use our own * method for autoloading. */ arg_skip_plugins = 1; if (not_autoconnect ()) { ConnectDialog *cd; cd = connect_dialog_new (); gtk_widget_show_all (GTK_WIDGET (cd)); } #ifdef USE_PLUGIN plugins_initialize (); #endif }
int main(int argc, char *argv[]) { init(); freemem_init(); init_breakpoints(); //tracking_init(); modules_init(); stabs_init(); modules_load_list(); arexx_open_port(); if (argc < 2 || strcmp("NOGUI", argv[1]) ) main_open_window(); load_preferences(); event_loop(); cleanup(); //tracking_cleanup(); modules_cleanup(); //remove_hook(); end(); return 0; }
/** * Run a test directly with specified user. Attempts to load preferences * with specified username and if successful, tries to get a test with * specified testname and when found, runs the test and quits. * * This is run only when program is called with two input parameters * using switch -u for username and -t for testname. * * @param user User whose preferences is to be loaded * @param testname Name of the user's test to load * * @return TRUE if user and testname was found, FALSE if either is missing or not found */ gboolean run_user_test(gchar* user, gchar* testname) { user_preference* prefs = NULL; gboolean rval = FALSE; if(!user || !testname) return rval; // Load preferences for this user if((prefs = load_preferences(user))) { // Get test and when found run it testcase* test = preference_get_test(prefs,testname); if(test) { g_print("Running test \"%s\" to %s (with %d files)\n", test->name,test->URL,g_hash_table_size(test->files)); // Init tests_initialize(test); // Run if(tests_run_test(prefs->username,test)) g_print("Test %s completed with failures.\n",test->name); else g_print("Test %s complete\n",test->name); // REset tests_reset(test); rval = TRUE; } // Test not found else { rval = FALSE; g_print("Test \"%s\" not found\n",testname); } destroy_preferences(); } else rval = FALSE; return rval; }
/* preferences pointer.. */ bool w_open_preferences_file( char *PrefName, Typecode Type) { int error = 0; bool success= true; /* allocate space for our global structure to keep track of the prefs file */ prefInfo = NULL; try { prefInfo = new preferences_info; #if defined(mac) prefInfo->PrefsFile.SetParentToPreferences(); prefInfo->PrefsFile.SetName(PrefName,Type); /* check for the preferences folder using FindFolder, creating it if necessary */ #elif defined(SDL) prefInfo->PrefsFile.SetToPreferencesDir(); prefInfo->PrefsFile += PrefName; #endif /* does the preferences file exist? */ load_preferences(); /* Uses prefInfo.. */ if(error_pending()) { short type; error= get_game_error(&type); if(type==systemError) { if (!prefInfo->PrefsFile.Exists()) { prefInfo->PrefsFile.Create(Type); prefInfo->wad = create_empty_wad(); set_game_error(systemError,prefInfo->PrefsFile.GetError()); w_write_preferences_file(); } } else { /* Something was invalid.. */ if (prefInfo->PrefsFile.Delete()) { prefInfo->wad= create_empty_wad(); set_game_error(systemError, error); w_write_preferences_file(); } set_game_error(systemError, errNone); } } } catch (...) { dprintf("In \"catch\""); set_game_error(systemError, memory_error()); } if (error) { /* if something is broken, make sure we at least return valid prefs */ if(prefInfo && !prefInfo->wad) { prefInfo->wad= create_empty_wad(); } } /* Gotta bail... */ if(!prefInfo || !prefInfo->wad) { success= false; } // dump_wad(prefInfo->wad); return success; }
int main(int argc, char *argv[]) { GtkBuilder *builder; GString *txt = g_string_new_len("", 20); char filepad[100]; unsigned short i, mask=0; GdkScreen* screen = NULL; int xx, yy, screen_width, screen_height; InitAudio(); pad = get_real_path(); // get the path of the executable sprintf(filepad, "%s/.lock", pad); setlock(filepad, 10, TRUE); // disable multiple instances for at least 10 seconds g_thread_init (NULL); display = XOpenDisplay(0); if (display == NULL) exit(1); gtk_set_locale(); gtk_init(&argc, &argv); builder = gtk_builder_new (); sprintf(filepad, "%s/%s.glade", pad, SKIN); gtk_builder_add_from_file(builder, filepad, NULL); gtk_builder_connect_signals (builder, NULL); // set widgets to be handled by the event handlers window = GW ("window"); preferences = GW ("preferences"); lookup = GW ("lookup"); fontbutton = GW ("fontbutton1"); drag = GW ("dragbar"); debug = GW ("debug"); papier = GW ("drawingarea1"); colorbutton1 = GW ("colorbutton1"); colorbutton2 = GW ("colorbutton2"); checkbutton1 = GW ("checkbutton1"); entry1 = GW ("entry1"); entry2 = GW ("entry2"); gtktable1 = GW ("table1"); checkbutton8 = GW ("checkbutton8"); checkbutton9 = GW ("checkbutton9"); textview1 = GW ("textview1"); entry16 = GW ("entry16"); combobox1 = GW ("combobox1"); scrolled = GW ("scrolledwindow2"); opacity = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "adjustment1")); speed = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "adjustment2")); textbuffer1 = GTK_TEXT_BUFFER(gtk_builder_get_object (builder, "textbuffer1")); for (i=0; i<sizeof(unsigned short); i++) { // set each bit of mask mask <<= 8; mask |= 0xFF; } // fill the struct that keeps the 7 recognize buttons & checkboxes (in preferences) for (i=0; i<7; i++) { g_string_sprintf(txt, "checkbutton%d", i+2); modebits[i].check = GTK_WIDGET(gtk_builder_get_object (builder, txt->str)); g_string_sprintf(txt, "button%d", i+3); modebits[i].button = GTK_WIDGET(gtk_builder_get_object (builder, txt->str)); switch (i) { case 0: modebits[i].bit = (GB1|GB2); modebits[i].mask = ((GB1|GB2) ^ mask); break; case 1: modebits[i].bit = BIG5; modebits[i].mask = (BIG5 ^ mask); break; case 2: modebits[i].bit = DIGITS; modebits[i].mask = (DIGITS ^ mask); break; case 3: modebits[i].bit = LOWERCASE; modebits[i].mask = (LOWERCASE ^ mask); break; case 4: modebits[i].bit = UPPERCASE; modebits[i].mask = (UPPERCASE ^ mask); break; case 5: modebits[i].bit = PUNC; modebits[i].mask = (PUNC ^ mask); break; case 6: modebits[i].bit = DEFAULT; modebits[i].mask = (DEFAULT ^ mask); break; } } // fill the structure that keeps the 13 labels for the keys (preferences) for (i=0; i<13; i++) { g_string_sprintf(txt, "button%d", i+10); conf.defkey[i].button = GTK_WIDGET(gtk_builder_get_object (builder, txt->str)); g_string_sprintf(txt, "entry%d", i+3); conf.defkey[i].entry = GTK_WIDGET(gtk_builder_get_object (builder, txt->str)); conf.defkey[i].key = 0; } // place a simple combobox for the input selection (preferences) combo = gtk_combo_box_new_text(); gtk_table_attach_defaults(GTK_TABLE(gtktable1), combo, 1, 2, 2, 3); gtk_widget_show (combo); // get events and labels for the 9 candidates for (int i=0; i< 9; i++) { g_string_sprintf(txt, "knop%d", i+1); knop[i] = GTK_WIDGET (gtk_builder_get_object (builder, txt->str)); g_string_sprintf(txt, "event%d", i+1); event[i] = GTK_WIDGET (gtk_builder_get_object (builder, txt->str)); } // set events for paste and backspace entries (preferences) g_signal_connect(entry1, "key_press_event", G_CALLBACK(on_key_press), NULL); g_signal_connect(entry1, "key_release_event", G_CALLBACK(on_key_release), NULL); g_signal_connect(entry2, "key_press_event", G_CALLBACK(on_key_press), NULL); g_signal_connect(entry2, "key_release_event", G_CALLBACK(on_key_release), NULL); if (!create_wtpen_window()) exit(1); wtpen_init(); g_object_unref (G_OBJECT (builder)); gtk_widget_show_all(GTK_WIDGET(window)); for (i=0; i<NUMKEYS; i++) hotkey[i] = 0; // reset all hotkeys // load cedict from file sprintf(filepad, "%s/data", pad); import_cedict(filepad); // load settings from file sprintf(filepad, "%s/xpen.cfg", pad); load_preferences(filepad); // set background and shape sprintf(filepad, "%s/%s.png", pad, SKIN); set_window_shape(filepad); // some styles to be used in the cedict browser (lookup window)一 gtk_text_buffer_create_tag(textbuffer1, "mark", "background", "yellow", "foreground", "black", NULL); gtk_text_buffer_create_tag(textbuffer1, "bold", "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_buffer_create_tag(textbuffer1, "character", "font", conf.font, "scale", 1.3, NULL); gtk_text_buffer_create_tag(textbuffer1, "translation", "scale", 0.9, NULL); gtk_text_buffer_create_tag(textbuffer1, "pinyin", "scale", 1.1, NULL); ready = TRUE; // let_configure_event() know that it can start its setup // start monitoring system-wide keypresses g_thread_create (intercept_key_thread, NULL, FALSE, NULL); // make sure the window positions and size are legal screen = gtk_window_get_screen(GTK_WINDOW(window)); // get screen size screen_width = gdk_screen_get_width(screen); screen_height = gdk_screen_get_height(screen); xx = MAX(MIN(screen_width-width, conf.x), 0); // set the position of the main window yy = MAX(MIN(screen_height-height, conf.y), 0); gtk_widget_set_uposition(window, xx, yy); xx = MIN(screen_width, conf.dx); // set the size of the lookup window yy = MIN(screen_height, conf.dy); gtk_widget_set_usize(lookup, xx, yy); xx = MAX(MIN(screen_width-conf.dx, conf.lx), 0); // set the position of the lookup window yy = MAX(MIN(screen_height-conf.dy, conf.ly), 0); gtk_widget_set_uposition(lookup, xx, yy); g_timeout_add (100, checkfocus, NULL); // check the inputfocus (each 1/10s) ////////////////////////////////////////////////////////////// //on_full_screen_button_pressed(); // start the full screen mode ////////////////////////////////////////////////////////////// gtk_main(); // start the main loop sprintf(filepad, "%s/.lock", pad); // remove the lock setlock(filepad, 0, FALSE); // save all settings to file sprintf(filepad, "%s/xpen.cfg", pad); save_preferences (filepad); g_free(pad); free_all(); wtpen_window_done(); wtlib_done(); SDL_CloseAudio(); SDL_Quit(); //on_full_screen_button_pressed(); return 0; }
/** * Test selection part of UI. Lists tests for this user * and awaits for selection. Runs test if it is found and * asks whether to rerun test or to quit or to return to main. * * @param user username to use for loading preferences * * @return TRUE if preferences were found and loaded */ gboolean run_test_selection(gchar* user) { user_preference* prefs = NULL; gchar* temp = (gchar*)g_try_malloc(TEMPLEN); gboolean rval = TRUE; // Load preferences for this user if((prefs = load_preferences(user))) { g_print("%d test%s loaded for %s:\n", g_sequence_get_length(prefs->tests), g_sequence_get_length(prefs->tests) > 1 ? "s " : "", prefs->username); gboolean loop = TRUE, rerun = FALSE; gchar tnumber = '\0'; // Run main loop for test selection while(loop) { gint idx = 0; GSequenceIter* iter = NULL; // If rerun of test was not selected print list of tests if(!rerun) { g_print("id\tname\tfiles\turl\n"); g_print("-------------------------------------------------------------------------------\n"); // Go through list of tests for(iter = g_sequence_get_begin_iter(prefs->tests); !g_sequence_iter_is_end(iter) ; iter = g_sequence_iter_next(iter)) { testcase* t = (testcase*)g_sequence_get(iter); // Is a test, print details if(t) { g_print(" %d\t%s\t%d\t%s\n",idx+1,t->name,g_hash_table_size(t->files),t->URL); idx++; } } g_print("\nSelect test id to run, q to quit, u to return to user selection: "); // get a char tnumber = getc(stdin); // Consume newline markers if(tnumber != '\n') temp = fgets(temp,TEMPLEN,stdin); } // Test rerun was selected else { g_print("Starting rerun of test %d\n",g_ascii_digit_value(tnumber)); rerun = FALSE; } // If input is a digit between [1...amount of tests] if(g_ascii_isdigit(tnumber) && g_ascii_digit_value(tnumber) <= g_sequence_get_length(prefs->tests) && g_ascii_digit_value(tnumber) > 0) { // Set default parser set_parser(prefs->parser); // Get iterator to at position in testlist GSequenceIter* testpos = g_sequence_get_iter_at_pos(prefs->tests, g_ascii_digit_value(tnumber)-1); // Get test testcase* test = (testcase*)g_sequence_get(testpos); g_print("Running test %c:\"%s\" to %s (with %d files)\n", tnumber,test->name,test->URL,g_hash_table_size(test->files)); // Initialize tests_initialize(test); // Run if(tests_run_test(prefs->username,test)) g_print("Test %s completed with failures.\n",test->name); else g_print("Test %s complete\n",test->name); // Clear and reset test tests_reset(test); g_print("Redo test (r) or quit (q) or go to main (m) or return to user selection (u): "); // Get char gchar response = getc(stdin); switch (response) { case 'r': rerun = TRUE; break; case 'q': loop = FALSE; break; case 'm': g_print("\n\n"); break; case 'u': loop = FALSE; rval = FALSE; break; default: g_print("Invalid selection. Return to main.\n"); rerun = FALSE; break; } // switch // Consume newline markers if(response != '\n') temp = fgets(temp,TEMPLEN,stdin); } // if else if(tnumber == 'q') loop = FALSE; else if(tnumber == 'u') { loop = FALSE; rval = FALSE; } else g_print("Invalid test id (%d)\n",g_ascii_digit_value(tnumber)); iter = NULL; } // while destroy_preferences(); } // if else { g_print("Preferences for user \"%s\" were not found\n",user); rval = FALSE; } g_free(temp); return rval; }
void decoder_init (int debug_info) { load_plugins (debug_info); load_preferences (); }
GtkWidget * yank_app_new(EYank *yank) { yank_preferences *prefs; static GtkTargetEntry drop_types[] = { { "text/uri-list", 0, 1 }, }; static gint n_drop_types = sizeof (drop_types)/sizeof (drop_types [0]); gchar *treetitle[] = { _("NoteTree"), NULL }; gchar *todotitles[] = { _("Deadline"), _("Priority"), _("Complete"), _("Title"), NULL }; GtkWidget *app; GtkWidget *scrolledwindow1; GtkWidget *scrolledwindow2; GtkWidget *scrolledwindow3; GtkWidget *hbox; GtkWidget *hbox3; GtkWidget *vbox; GtkWidget *label; GdkFont *font; GtkObject *prio_adjust; /* gint got_crash; */ GtkWidget *b_toggle_ext_flags; GtkWidget *hbox_ext_flags; GtkWidget *hpaned; hpaned = app = yank->priv->hpaned; yank_main_app(app); sp->edit_tree = NULL; sp->title_entry =NULL; sp->todo_check =NULL; sp->prio_entry =NULL; sp->de_deadline =NULL; sp->ad_complete =NULL; sp->tlabel_created =NULL; sp->tlabel_changed =NULL; sp->label_changes =NULL; sp->tlabel_expire =NULL; sp->note_id_entry =NULL; sp->text_entry =NULL; sp->note_tree =NULL; sp->b_ok =NULL; sp->b_apply =NULL; sp->b_cancel =NULL; sp->todolist =NULL; sp->notebook =NULL; sp->status =NULL; sp->prio_date_box =NULL; sp->edit_tree=NULL; yank_root_win(GTK_WINDOW(app)); /* * main tree */ scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* gtk_widget_show will be called later */ /* gtk_container_add(GTK_CONTAINER(hpaned), scrolledwindow1); */ e_paned_add1(E_PANED(hpaned), scrolledwindow1); sp->note_tree = gtk_ctree_new_with_titles(1, 0, treetitle); gtk_widget_show(sp->note_tree); gtk_container_add(GTK_CONTAINER(scrolledwindow1), sp->note_tree); gtk_clist_set_column_width(GTK_CLIST(sp->note_tree), 0, 80); gtk_clist_set_column_auto_resize(GTK_CLIST(sp->note_tree), 0, TRUE); gtk_clist_set_row_height(GTK_CLIST(sp->note_tree), 19); gtk_clist_set_selection_mode(GTK_CLIST(sp->note_tree), GTK_SELECTION_EXTENDED); gtk_clist_set_reorderable(GTK_CLIST(sp->note_tree), TRUE); gtk_clist_set_use_drag_icons(GTK_CLIST(sp->note_tree), TRUE); gtk_clist_column_titles_show(GTK_CLIST(sp->note_tree)); gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_select_row", GTK_SIGNAL_FUNC (note_tree_row_selected), NULL); gtk_signal_connect(GTK_OBJECT(sp->note_tree), "tree_unselect_row", GTK_SIGNAL_FUNC (note_tree_row_unselected), NULL); gtk_signal_connect(GTK_OBJECT(sp->note_tree), "click_column", GTK_SIGNAL_FUNC (cb_note_tree_col_selected), NULL); gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received", GTK_SIGNAL_FUNC(cb_note_tree_reordered), NULL); /* * FIXME: * dnd on the note-tree disables reordering of notes by dnd */ /* gtk_signal_connect(GTK_OBJECT(sp->note_tree), "drag_data_received", */ /* GTK_SIGNAL_FUNC(cb_note_tree_drop), NULL); */ /* gtk_drag_dest_set(sp->note_tree, GTK_DEST_DEFAULT_MOTION | */ /* GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, */ /* drop_types, n_drop_types, GDK_ACTION_COPY); */ sp->notebook = gtk_notebook_new(); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(sp->notebook), FALSE); gtk_notebook_set_show_border(GTK_NOTEBOOK(sp->notebook), FALSE); gtk_widget_show(sp->notebook); /* gtk_container_add(GTK_CONTAINER(hpaned), sp->notebook); */ e_paned_add2(E_PANED(hpaned), sp->notebook); /* * todo-list */ scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show(scrolledwindow2); gtk_container_add(GTK_CONTAINER(sp->notebook), scrolledwindow2); sp->todolist = gtk_clist_new_with_titles(4, todotitles); gtk_signal_connect(GTK_OBJECT(sp->todolist), "select_row", GTK_SIGNAL_FUNC (cb_todo_row_selected), NULL); gtk_signal_connect(GTK_OBJECT(sp->todolist), "click_column", GTK_SIGNAL_FUNC (cb_todo_col_selected), NULL); gtk_signal_connect(GTK_OBJECT(sp->todolist), "drag_data_received", GTK_SIGNAL_FUNC(cb_todo_list_drop), NULL); gtk_drag_dest_set(sp->todolist, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, drop_types, n_drop_types, GDK_ACTION_COPY); gtk_widget_show(sp->todolist); gtk_container_add(GTK_CONTAINER(scrolledwindow2), sp->todolist); gtk_clist_column_titles_show(GTK_CLIST(sp->todolist)); gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 0 , TRUE); gtk_clist_set_column_auto_resize(GTK_CLIST(sp->todolist), 3 , TRUE); gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 1, GTK_JUSTIFY_RIGHT); gtk_clist_set_column_justification(GTK_CLIST(sp->todolist), 2, GTK_JUSTIFY_RIGHT); /* * text/ data */ vbox = gtk_vbox_new(FALSE, 3); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER (sp->notebook), vbox); hbox = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3); sp->prio_date_box = gtk_vbox_new(FALSE, 3); gtk_widget_show(sp->prio_date_box); gtk_box_pack_start(GTK_BOX(vbox), sp->prio_date_box, FALSE, FALSE, 0); hbox_ext_flags = gui_ext_flags(); gtk_box_pack_start(GTK_BOX(vbox), hbox_ext_flags, FALSE, FALSE, 3); label = gtk_label_new(_("Title:")); font = gtk_widget_get_style(label)->font; gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); sp->title_entry = gtk_entry_new(); gtk_widget_set_usize(sp->title_entry, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(sp->title_entry); gtk_box_pack_start(GTK_BOX(hbox), sp->title_entry, TRUE, TRUE, 5); sp->todo_check = gtk_check_button_new_with_label(_("Done")); gtk_widget_set_usize(sp->todo_check, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(sp->todo_check); gtk_box_pack_start(GTK_BOX(hbox), sp->todo_check, FALSE, FALSE, 5); /* * button for extra flags& data */ b_toggle_ext_flags = gtk_button_new(); { GtkWidget *p_up; GtkWidget *p_down; GtkWidget *box; box = gtk_hbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(b_toggle_ext_flags), box); gtk_widget_show(box); p_up = gnome_stock_pixmap_widget_at_size( GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_UP, 12, 14); p_down = gnome_stock_pixmap_widget_at_size( GTK_WIDGET(yank_root_win(NULL)), GNOME_STOCK_BUTTON_DOWN, 12, 14); gtk_widget_hide(p_up); gtk_widget_show(p_down); gtk_container_add(GTK_CONTAINER(box), p_up); gtk_container_add(GTK_CONTAINER(box), p_down); gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "up", p_up); gtk_object_set_data(GTK_OBJECT(b_toggle_ext_flags), "down", p_down); } gtk_widget_show(b_toggle_ext_flags); gtk_box_pack_start(GTK_BOX(hbox), b_toggle_ext_flags, FALSE, FALSE, 5); gtk_signal_connect(GTK_OBJECT(b_toggle_ext_flags), "clicked", GTK_SIGNAL_FUNC(cb_toggle_ext_flags), hbox_ext_flags); /* * deadline/ prio/ complete */ { GtkWidget *prio_hbox1; GtkWidget *prio_hbox2; GtkWidget *sc_complete; prio_hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_show(prio_hbox1); gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox1, FALSE, FALSE, 0); prio_hbox2 = gtk_hbox_new(FALSE, 0); gtk_widget_show(prio_hbox2); gtk_box_pack_start(GTK_BOX(sp->prio_date_box), prio_hbox2, FALSE, FALSE, 0); label = gtk_label_new(_("Deadline:")); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5); sp->de_deadline = gnome_date_edit_new(0, 1, 1); gnome_date_edit_set_popup_range(GNOME_DATE_EDIT(sp->de_deadline), 0, 23); gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->date_entry, FALSE); gtk_widget_set_sensitive(GNOME_DATE_EDIT(sp->de_deadline)->time_entry, FALSE); gtk_widget_show(sp->de_deadline); gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->de_deadline, FALSE, FALSE, 0); label = gtk_label_new(_("Priority:")); gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(prio_hbox1), label, FALSE, FALSE, 5); prio_adjust = gtk_adjustment_new(0, 0, 9999, 1, 10, 10); sp->prio_entry = gtk_spin_button_new(GTK_ADJUSTMENT(prio_adjust), 1, 0); /* NOTE: this is note 100% ok */ gtk_widget_set_usize(GTK_WIDGET(sp->prio_entry), gdk_string_width(font, "999999") + 10, gdk_string_height(font, "W") + 10); gtk_widget_show(sp->prio_entry); gtk_box_pack_start(GTK_BOX(prio_hbox1), sp->prio_entry, FALSE, FALSE, 0); label = gtk_label_new(_("Complete:")); gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5); sp->ad_complete = gtk_adjustment_new(0, 0, 101, 1, 1, 1); sc_complete = gtk_hscale_new(GTK_ADJUSTMENT(sp->ad_complete)); gtk_scale_set_digits(GTK_SCALE(sc_complete), 0); gtk_scale_set_value_pos(GTK_SCALE(sc_complete), GTK_POS_LEFT); gtk_widget_show(sc_complete); gtk_box_pack_start(GTK_BOX(prio_hbox2), sc_complete, TRUE, TRUE, 5); label = gtk_label_new(_("%")); gtk_widget_set_usize(label, -1, gdk_string_height(font, "W") + 10); gtk_widget_show(label); gtk_box_pack_start(GTK_BOX(prio_hbox2), label, FALSE, FALSE, 5); } /* * additional note data */ sp->note_id_entry = gtk_entry_new(); /* gtk_widget_show(sp->note_id_entry); */ gtk_widget_hide(sp->note_id_entry); gtk_box_pack_start(GTK_BOX(hbox), sp->note_id_entry, FALSE, FALSE, 5); /* * note text */ scrolledwindow3 = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show(scrolledwindow3); gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow3, TRUE, TRUE, 0); sp->text_entry = gtk_text_new(NULL, NULL); gtk_text_set_editable(GTK_TEXT(sp->text_entry), TRUE); gtk_widget_show(sp->text_entry); gtk_container_add(GTK_CONTAINER(scrolledwindow3), sp->text_entry); /* text dnd */ gtk_signal_connect(GTK_OBJECT(sp->text_entry), "drag_data_received", GTK_SIGNAL_FUNC(cb_text_entry_drop), NULL); gtk_drag_dest_set(sp->text_entry, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, drop_types, n_drop_types, GDK_ACTION_COPY); hbox3 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox3); gtk_box_pack_start(GTK_BOX(vbox), hbox3, FALSE, FALSE, 3); sp->b_ok = gnome_stock_button(GNOME_STOCK_BUTTON_OK); gtk_widget_show(sp->b_ok); gtk_box_pack_start(GTK_BOX(hbox3), sp->b_ok, TRUE, FALSE, 5); gtk_signal_connect(GTK_OBJECT(sp->b_ok), "clicked", GTK_SIGNAL_FUNC(cb_b_ok), NULL); sp->b_apply = gnome_stock_button(GNOME_STOCK_BUTTON_APPLY); gtk_widget_show(sp->b_apply); gtk_box_pack_start(GTK_BOX(hbox3), sp->b_apply, TRUE, FALSE, 5); gtk_signal_connect(GTK_OBJECT(sp->b_apply), "clicked", GTK_SIGNAL_FUNC(cb_b_apply), NULL); sp->b_cancel = gnome_stock_button(GNOME_STOCK_BUTTON_CANCEL); gtk_widget_show(sp->b_cancel); gtk_box_pack_start(GTK_BOX(hbox3), sp->b_cancel, TRUE, FALSE, 5); gtk_signal_connect(GTK_OBJECT(sp->b_cancel), "clicked", GTK_SIGNAL_FUNC(cb_b_cancel), NULL); /* * a bit suboptimal */ gtk_signal_connect(GTK_OBJECT(sp->title_entry), "changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "date-changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->de_deadline), "time-changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->tlabel_expire), "time_changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->prio_entry), "changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->ad_complete), "value_changed", GTK_SIGNAL_FUNC(cb_complete_updates_done), sp->todo_check); gtk_signal_connect(GTK_OBJECT(sp->todo_check), "toggled", GTK_SIGNAL_FUNC(note_changed), NULL); gtk_signal_connect(GTK_OBJECT(sp->text_entry), "changed", GTK_SIGNAL_FUNC(note_changed), NULL); /* * keyboard-control */ gtk_signal_connect(GTK_OBJECT(sp->title_entry), "activate", GTK_SIGNAL_FUNC(cb_finished_note), NULL); gtk_signal_connect(GTK_OBJECT(sp->text_entry), "activate", GTK_SIGNAL_FUNC(cb_finished_note), NULL); /* * create pixmaps */ pix_text_xpm = gnome_pixmap_new_from_xpm_d(text_xpm); gtk_widget_show(pix_text_xpm); pix_box_xpm = gnome_pixmap_new_from_xpm_d(box_xpm); gtk_widget_show(pix_box_xpm); pix_box2_xpm = gnome_pixmap_new_from_xpm_d(box2_xpm); gtk_widget_show(pix_box2_xpm); pix_circle_xpm = gnome_pixmap_new_from_xpm_d(circle_xpm); gtk_widget_show(pix_circle_xpm); pix_circle2_xpm = gnome_pixmap_new_from_xpm_d(circle2_xpm); gtk_widget_show(pix_circle2_xpm); /* * menus */ /* gnome_app_set_contents(GNOME_APP(app), hpaned); */ /* sp->status = gnome_appbar_new(FALSE, TRUE, GNOME_PREFERENCES_USER); */ /* gnome_app_set_statusbar(GNOME_APP(app), sp->status); */ /* yank_install_menus_and_toolbar(app); */ yank_tree_item_context_menu(sp->note_tree); yank_todo_item_context_menu(sp->todolist); yank_text_item_context_menu(sp->title_entry); yank_text_item_context_menu(sp->text_entry); /* gtk_signal_connect(GTK_OBJECT(app), "delete_event", */ /* GTK_SIGNAL_FUNC(cb_delete_event), NULL); */ /* * initialize preferences * also preloads plugins */ load_preferences(); prefs = get_preferences(); gtk_text_set_word_wrap(GTK_TEXT(sp->text_entry), prefs->wordwrap); gtk_text_set_line_wrap(GTK_TEXT(sp->text_entry), prefs->linewrap); /* if (prefs->yank_width * prefs->yank_height) */ /* { */ /* gtk_window_set_default_size(GTK_WINDOW(app), prefs->yank_width, */ /* prefs->yank_height); */ /* } */ /* else */ /* { */ /* gtk_window_set_default_size(GTK_WINDOW(app), 600, 400); */ /* } */ if (prefs->use_custom_font) { if (prefs->note_font) { set_note_font_str(prefs->note_font); } if (prefs->note_tree_font) { set_note_tree_font_str(prefs->note_tree_font); } if (prefs->todolist_font) { set_todolist_font_str(prefs->todolist_font); } } else { set_default_font(); } /* * parse geometry if given */ /* if (geometry != NULL) */ /* { */ /* gint x, y, w, h; */ /* if (gnome_parse_geometry(geometry, &x, &y, &w, &h )) */ /* { */ /* if (x != -1) */ /* { */ /* gtk_widget_set_uposition(app, x, y); */ /* } */ /* */ /* if (w != -1) */ /* { */ /* gtk_window_set_default_size(GTK_WINDOW(app), w, h); */ /* } */ /* } */ /* else */ /* { */ /* g_error(_("Could not parse geometry string `%s'"), geometry); */ /* } */ /* } */ /* */ /* if (prefs->note_tree_width) */ /* { */ /* gtk_widget_set_usize(scrolledwindow1, prefs->note_tree_width, -1); */ /* } */ /* else */ /* { */ /* gtk_widget_set_usize(scrolledwindow1, 200, -1); */ /* } */ /* gtk_widget_show(scrolledwindow1); */ /* * try to read files from killed sessions */ /* got_crash = get_crash_file(); */ /* * load file from the command-line */ /* if (file != NULL && ! got_crash) */ /* { */ /* load_notes_from_cli((gchar *)file, GTK_CTREE(sp->note_tree), NULL); */ /* } */ /* * read default file */ /* if (file == NULL && ! got_crash) */ /* { */ /* get_def_file(); */ /* } */ /* * register some signal-handlers */ /* if (signal(SIGTERM, handle_sigterm) == SIG_ERR) */ /* { */ /* g_warning("Can't handle SIGTERM"); */ /* } */ /* if (signal(SIGCHLD, handle_sigchild) == SIG_ERR) */ /* { */ /* g_warning("Can't handle SIGCHILD"); */ /* } */ /* if (signal(SIGPIPE, handle_sigpipe) == SIG_ERR) */ /* { */ /* g_warning("Can't handle SIGPIPE"); */ /* } */ /* * init autosave */ /* if (prefs->auto_save_minutes) */ /* { */ /* autosave_notes(NULL); */ /* } */ return (hpaned); }
int main(int argc, char *argv[]) { GError *error = NULL; GOptionContext *context; MainWin* win; #ifdef ENABLE_NLS bindtextdomain ( GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR ); bind_textdomain_codeset ( GETTEXT_PACKAGE, "UTF-8" ); textdomain ( GETTEXT_PACKAGE ); #endif context = g_option_context_new ("- simple image viewer"); g_option_context_add_main_entries (context, opt_entries, GETTEXT_PACKAGE); g_option_context_add_group (context, gtk_get_option_group (TRUE)); if ( !g_option_context_parse (context, &argc, &argv, &error) ) { g_print( "option parsing failed: %s\n", error->message); return 1; } if( should_display_version ) { printf( "gpicview %s\n", VERSION ); return 0; } gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), PIXMAP_DIR); load_preferences(); /* Allocate and show the window. * We must show the window now in case the file open needs to put up an error dialog. */ win = (MainWin*)main_win_new(); gtk_widget_show( GTK_WIDGET(win) ); if ( pref.open_maximized ) gtk_window_maximize( (GtkWindow*)win ); // FIXME: need to process multiple files... if( files ) { if( G_UNLIKELY( *files[0] != '/' && strstr( files[0], "://" )) ) // This is an URI { char* path = g_filename_from_uri( files[0], NULL, NULL ); main_win_open( win, path, ZOOM_NONE ); g_free( path ); } else main_win_open( win, files[0], ZOOM_NONE ); if (should_start_slideshow) main_win_start_slideshow ( win ); } else { main_win_open( win, ".", ZOOM_NONE ); } gtk_main(); save_preferences(); return 0; }