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