diff -crN ./gnome-utils/configure.in /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/configure.in *** ./gnome-utils/configure.in Mon Sep 8 12:18:15 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/configure.in Thu Oct 16 14:23:38 2003 *************** *** 15,20 **** --- 15,21 ---- AC_PROG_INSTALL AC_PROG_LN_S AC_PROG_MAKE_SET + AM_PROG_LIBTOOL GNOME_COMPILE_WARNINGS *************** *** 52,58 **** dnl popt is needed for most utils dnl ***************************** ! AC_CHECK_LIB(popt, poptHelpOptions,, AC_MSG_ERROR([popt is required to build gnome-utils. You can download the latest version from ftp://people.redhat.com/sopwith/popt/])) dnl ********************************************* dnl gnome-vfs/mime-data is need for gsearchtool --- 53,59 ---- dnl popt is needed for most utils dnl ***************************** ! AC_CHECK_LIB(popt, poptGetArgs,, AC_MSG_ERROR([popt is required to build gnome-utils. You can download the latest version from ftp://people.redhat.com/sopwith/popt/])) dnl ********************************************* dnl gnome-vfs/mime-data is need for gsearchtool diff -crN ./gnome-utils/gcalc/gcalc.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gcalc/gcalc.c *** ./gnome-utils/gcalc/gcalc.c Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gcalc/gcalc.c Tue Jul 8 10:26:34 2003 *************** *** 0 **** --- 1,231 ---- + /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ + /* Simple Double precision calculator using the GnomeCalculator widget + Copyright (C) 1998 Free Software Foundation, Inc. + + Author: George Lebl + */ + + #include + #include + #include + + #include "gnome-calc.h" + + /* values for selection info */ + enum { + TARGET_STRING, + TARGET_TEXT, + TARGET_COMPOUND_TEXT + }; + + static GtkWidget *app; + static GtkWidget *calc; + static char copied_string[13]=""; + + static void + about_cb (GtkWidget *widget, gpointer data) + { + static GtkWidget *about = NULL; + GdkPixbuf *pixbuf; + GError *error = NULL; + gchar *file; + + gchar *authors[] = { + "George Lebl ", + "Bastien Nocera (fixes)", + NULL + }; + gchar *documenters[] = { + NULL + }; + /* Translator credits */ + gchar *translator_credits = _("translator_credits"); + + if (about != NULL) + { + gdk_window_show(about->window); + gdk_window_raise(about->window); + return; + } + + file = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_PIXMAP, "gnome-calc3.png", FALSE, NULL); + pixbuf = gdk_pixbuf_new_from_file (file, &error); + + if (error) { + g_warning (G_STRLOC ": cannot open %s: %s", file, error->message); + g_error_free (error); + } + g_free (file); + + about = gnome_about_new(_("GNOME Calculator"), VERSION, + _("(C) 1998 Free Software Foundation, Inc."), + _("Simple double precision calculator similar " + "to xcalc"), + (const char **)authors, + (const char **)documenters, + strcmp (translator_credits, "translator_credits") != 0 ? translator_credits : NULL, + pixbuf); + if (pixbuf) { + gdk_pixbuf_unref (pixbuf); + } + + gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (data)); + gtk_signal_connect(GTK_OBJECT(about), "destroy", + GTK_SIGNAL_FUNC(gtk_widget_destroyed), &about); + gtk_widget_show (about); + } + + static void + quit_cb (GtkWidget *widget, gpointer data) + { + gtk_main_quit (); + } + + /* Callback when the user toggles the selection */ + static void + copy_contents (GtkWidget *widget, gpointer data) + { + strcpy(copied_string, gnome_calc_get_result_string(GNOME_CALC (calc))); + g_strstrip(copied_string); + gtk_selection_owner_set (app, + GDK_SELECTION_CLIPBOARD, + GDK_CURRENT_TIME); + } + + + static void + selection_handle (GtkWidget *widget, + GtkSelectionData *selection_data, + int info, int time, + gpointer data) + { + if (info == TARGET_STRING) { + gtk_selection_data_set (selection_data, + GDK_SELECTION_TYPE_STRING, + 8*sizeof(gchar), + (guchar *)copied_string, + strlen(copied_string)); + } else if ((info == TARGET_TEXT) || (info == TARGET_COMPOUND_TEXT)) { + guchar *text; + GdkAtom encoding; + gint format; + gint new_length; + + gdk_string_to_compound_text (copied_string, &encoding, &format, + &text, &new_length); + gtk_selection_data_set (selection_data, encoding, format, + text, new_length); + gdk_free_compound_text (text); + } + } + + /* Menus */ + static GnomeUIInfo calculator_menu[] = { + GNOMEUIINFO_MENU_EXIT_ITEM(quit_cb,NULL), + GNOMEUIINFO_END + }; + + static GnomeUIInfo edit_menu[] = { + GNOMEUIINFO_MENU_COPY_ITEM(copy_contents,NULL), + GNOMEUIINFO_END + }; + + static GnomeUIInfo help_menu[] = { + GNOMEUIINFO_HELP("gnome-calculator"), + GNOMEUIINFO_MENU_ABOUT_ITEM(about_cb,NULL), + GNOMEUIINFO_END + }; + + static GnomeUIInfo gcalc_menu[] = { + { GNOME_APP_UI_SUBTREE, N_("_Calculator"), NULL, + calculator_menu, NULL, NULL, (GnomeUIPixmapType) 0, + NULL, 0, (GdkModifierType) 0, NULL }, + GNOMEUIINFO_MENU_EDIT_TREE(edit_menu), + GNOMEUIINFO_MENU_HELP_TREE(help_menu), + GNOMEUIINFO_END + }; + + static int save_session(GnomeClient *client, + gint phase, + GnomeRestartStyle save_style, + gint shutdown, + GnomeInteractStyle interact_style, + gint fast, + gpointer client_data) { + gchar *argv[]= { NULL }; + + argv[0] = (char*) client_data; + gnome_client_set_clone_command(client, 1, argv); + gnome_client_set_restart_command(client, 1, argv); + + return TRUE; + } + + static gint client_die(GnomeClient *client, gpointer client_data) + { + gtk_main_quit (); + } + + + + int + main(int argc, char *argv[]) + { + GnomeClient *client; + static GtkTargetEntry targets[] = { + { "STRING", TARGET_STRING }, + { "TEXT", TARGET_TEXT }, + { "COMPOUND_TEXT", TARGET_COMPOUND_TEXT } + }; + static gint n_targets = sizeof(targets) / sizeof(targets[0]); + + /* Initialize the i18n stuff */ + bindtextdomain(GETTEXT_PACKAGE, GNOMELOCALEDIR); + bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); + textdomain(GETTEXT_PACKAGE); + + gnome_program_init ("gnome-calculator", VERSION, LIBGNOMEUI_MODULE, + argc, argv, GNOME_PARAM_APP_DATADIR,DATADIR, NULL); + gnome_window_icon_set_default_from_file (GNOME_ICONDIR"/gnome-calc3.png"); + + app = gnome_app_new("gnome-calculator", _("Calculator")); + gtk_window_set_wmclass (GTK_WINDOW (app), "gnome-calculator", "gnome-calculator"); + gtk_window_set_resizable (GTK_WINDOW (app), TRUE); + + gtk_signal_connect(GTK_OBJECT(app), "delete_event", + GTK_SIGNAL_FUNC(quit_cb), NULL); + + /*set up the menu*/ + gnome_app_create_menus_with_data(GNOME_APP(app), gcalc_menu, app); + + calc = gnome_calc_new(); + + gnome_calc_bind_extra_keys (GNOME_CALC (calc), GTK_WIDGET (app)); + + gtk_widget_show(calc); + + gtk_selection_add_targets (GTK_WIDGET (app), GDK_SELECTION_CLIPBOARD, + targets, n_targets); + + gtk_signal_connect(GTK_OBJECT(app), "selection_get", + GTK_SIGNAL_FUNC(selection_handle), NULL); + + client = gnome_master_client(); + g_signal_connect (client, "save_yourself", + G_CALLBACK(save_session), (gpointer)argv[0]); + g_signal_connect (client, "die", + G_CALLBACK(client_die), NULL); + + gnome_app_set_contents(GNOME_APP(app), calc); + /* add calculator accel table to our window*/ + + gtk_window_add_accel_group(GTK_WINDOW(app), + gnome_calc_get_accel_group(GNOME_CALC(calc))); + + gtk_widget_show(app); + + gtk_main (); + + return 0; + } + diff -crN ./gnome-utils/gcalc/gnome-calc.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gcalc/gnome-calc.c *** ./gnome-utils/gcalc/gnome-calc.c Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gcalc/gnome-calc.c Tue Jul 8 10:26:53 2003 *************** *** 0 **** --- 1,1697 ---- + /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ + /* + * Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation + * All rights reserved. + * + * This file is part of the Gnome Library. + * + * The Gnome Library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * The Gnome Library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with the Gnome Library; see the file COPYING.LIB. If not, + * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + */ + /* + @NOTATION@ + */ + /* GnomeCalc - double precision simple calculator widget + * + * Author: George Lebl + */ + + #include + + /* needed for values of M_E and M_PI under 'gcc -ansi -pedantic' + * on GNU/Linux */ + #ifndef _BSD_SOURCE + # define _BSD_SOURCE 1 + #endif + #include + + #include + #include + #include + #include + #include /* errno */ + #include /* signal() */ + #include + #include + + #include + #include + #include + + #include "gnome-calc.h" + #include "sr.h" + + #undef GNOME_CALC_DEBUG + + typedef void (*sighandler_t)(int); + + struct _GnomeCalcPrivate { + GtkWidget *text_display; + GtkWidget *store_display; + + GtkWidget *invert_button; + GtkWidget *drg_button; + + GList *stack; + GtkAccelGroup *accel; + + gdouble result; + gdouble memory; + + gchar result_string[13]; + + unsigned int mode : 2; /* GnomeCalcMode */ + + guint add_digit : 1; /*add a digit instead of starting a new + number*/ + guint error : 1; + guint invert : 1; + + GtkTooltips *tooltips; + }; + + typedef enum { + CALCULATOR_NUMBER, + CALCULATOR_FUNCTION, + CALCULATOR_PARENTHESIS + } CalculatorActionType; + + typedef gdouble (*MathFunction1) (gdouble); + typedef gdouble (*MathFunction2) (gdouble, gdouble); + + typedef struct _CalculatorStack CalculatorStack; + struct _CalculatorStack { + CalculatorActionType type; + union { + MathFunction2 func; + gdouble number; + } d; + }; + + + + + static void gnome_calc_class_init (GnomeCalcClass *class); + static void gnome_calc_instance_init (GnomeCalc *gc); + static void gnome_calc_destroy (GtkObject *object); + static void gnome_calc_finalize (GObject *object); + + typedef struct _CalculatorButton CalculatorButton; + struct _CalculatorButton { + char *name; + GCallback signal_func; + gpointer data; + gpointer invdata; + gboolean convert_to_rad; + guint keys[10]; /*key shortcuts, 0 terminated list, + make sure to increase the number if more is needed*/ + char *tooltip; + char *tooltip_private; + }; + + typedef void (*GnomeCalcualtorResultChangedSignal) (GtkObject * object, + gdouble result, + gpointer data); + + + enum { + RESULT_CHANGED_SIGNAL, + LAST_SIGNAL + }; + + static gint gnome_calc_signals[LAST_SIGNAL]; + + static gboolean cmd_saved = FALSE; + + GNOME_CLASS_BOILERPLATE (GnomeCalc, gnome_calc, + GtkVBox, GTK_TYPE_VBOX) + + static void + gnome_calc_class_init (GnomeCalcClass *class) + { + GtkObjectClass *object_class; + GObjectClass *gobject_class; + + object_class = (GtkObjectClass *) class; + gobject_class = (GObjectClass *) class; + object_class->destroy = gnome_calc_destroy; + gobject_class->finalize = gnome_calc_finalize; + + gnome_calc_signals[RESULT_CHANGED_SIGNAL] = + gtk_signal_new("result_changed", + GTK_RUN_LAST, + GTK_CLASS_TYPE(object_class), + GTK_SIGNAL_OFFSET(GnomeCalcClass, + result_changed), + g_cclosure_marshal_VOID__DOUBLE, + GTK_TYPE_NONE, + 1, + GTK_TYPE_DOUBLE); + + class->result_changed = NULL; + } + + #ifdef GNOME_CALC_DEBUG + static void + dump_stack(GnomeCalc *gc) + { + CalculatorStack *stack; + GList *list; + + g_print ("STACK_DUMP start, we are in "); + if (gc->_priv->add_digit) + g_print ("add digit mode.\n"); + else + g_print ("normal mode\n"); + + for(list = gc->_priv->stack;list!=NULL;list = g_list_next(list)) { + stack = list->data; + if(stack == NULL) + puts("NULL"); + else if(stack->type == CALCULATOR_PARENTHESIS) + puts("("); + else if(stack->type == CALCULATOR_NUMBER) + printf("% .12g\n", stack->d.number); + else if(stack->type == CALCULATOR_FUNCTION) + puts("FUNCTION"); + else + puts("UNKNOWN"); + } + puts("STACK_DUMP end\n"); + } + #endif + + static void + stack_pop(GList **stack) + { + CalculatorStack *s; + GList *p; + + g_return_if_fail(stack); + + if(*stack == NULL) { + g_warning("Stack underflow!"); + return; + } + + s = (*stack)->data; + p = (*stack)->next; + g_list_free_1(*stack); + if(p) p->prev = NULL; + *stack = p; + g_free(s); + } + + static void + set_display (GnomeCalc *gc) + { + GtkWidget *string_text = gc->_priv->text_display; + GtkWidget *store_text = gc->_priv->store_display; + GtkTextBuffer *buffer; + GtkTextIter start, end; + + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (string_text)); + gtk_text_buffer_get_bounds (buffer, &start, &end); + gtk_text_buffer_delete (buffer, &start, &end); + gtk_text_buffer_insert_with_tags_by_name (buffer, + &end, + gc->_priv->result_string, + -1, + "x-large", + NULL); + + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (store_text)); + gtk_text_buffer_get_bounds (buffer, &start, &end); + gtk_text_buffer_delete (buffer, &start, &end); + gtk_text_buffer_insert_with_tags_by_name (buffer, + &end, + (gc->_priv->memory != 0.0) ? "m" : " ", + -1, + "x-large", + NULL); + + } + + static void + do_error(GnomeCalc *gc) + { + gc->_priv->error = TRUE; + if (errno == ERANGE) + strcpy(gc->_priv->result_string,_("inf")); + else + strcpy(gc->_priv->result_string,"e"); + + set_display (gc); + + + } + + /*we handle sigfpe's so that we can find all the errors*/ + static void + sigfpe_handler(int type) + { + /*most likely, but we don't really care what the value is*/ + errno = ERANGE; + } + + static void + reduce_stack(GnomeCalc *gc) + { + CalculatorStack *stack; + GList *list; + MathFunction2 func; + gdouble first; + gdouble second; + + if(!gc->_priv->stack) + return; + + stack = gc->_priv->stack->data; + if(stack->type!=CALCULATOR_NUMBER) + return; + + second = stack->d.number; + + list=g_list_next(gc->_priv->stack); + if(!list) + return; + + stack = list->data; + if(stack->type==CALCULATOR_PARENTHESIS) + return; + if(stack->type!=CALCULATOR_FUNCTION) { + g_warning("Corrupt GnomeCalc stack!"); + return; + } + func = stack->d.func; + + list=g_list_next(list); + if(!list) { + g_warning("Corrupt GnomeCalc stack!"); + return; + } + + stack = list->data; + if(stack->type!=CALCULATOR_NUMBER) { + g_warning("Corrupt GnomeCalc stack!"); + return; + } + first = stack->d.number; + + stack_pop(&gc->_priv->stack); + stack_pop(&gc->_priv->stack); + + errno = 0; + + { + sighandler_t old = signal(SIGFPE,sigfpe_handler); + stack->d.number = (*func)(first,second); + signal(SIGFPE,old); + } + + if(errno>0 || + finite(stack->d.number)==0) { + do_error(gc); + stack->d.number = 0; + errno = 0; + } + } + + /* Move these up for find_precedence(). */ + static gdouble + c_add(gdouble arg1, gdouble arg2) + { + return arg1+arg2; + } + + static gdouble + c_sub(gdouble arg1, gdouble arg2) + { + return arg1-arg2; + } + + static gdouble + c_mul(gdouble arg1, gdouble arg2) + { + return arg1*arg2; + } + + static gdouble + c_div(gdouble arg1, gdouble arg2) + { + if(arg2==0) { + errno=ERANGE; + return 0; + } + return arg1/arg2; + } + + static int + find_precedence(MathFunction2 f) + { + if ( f == NULL || f == c_add || f == c_sub) + return 0; + else if ( f == c_mul || f == c_div ) + return 1; + else + return 2; + } + + static void + reduce_stack_prec(GnomeCalc *gc, MathFunction2 func) + { + CalculatorStack *stack; + GList *list; + + if (gc->_priv->stack == NULL) + return; + + stack = gc->_priv->stack->data; + if ( stack->type != CALCULATOR_NUMBER ) + return; + + list = g_list_next(gc->_priv->stack); + if (!list) + return; + + stack = list->data; + if ( stack->type == CALCULATOR_PARENTHESIS ) + return; + + if ( find_precedence(func) <= find_precedence(stack->d.func) ) { + reduce_stack(gc); + reduce_stack_prec(gc,func); + } + + return; + } + + static void + push_input(GnomeCalc *gc) + { + if(gc->_priv->add_digit) { + CalculatorStack *stack; + stack = g_new(CalculatorStack,1); + stack->type = CALCULATOR_NUMBER; + stack->d.number = gc->_priv->result; + gc->_priv->stack = g_list_prepend(gc->_priv->stack,stack); + gc->_priv->add_digit = FALSE; + } + } + + static void + set_result(GnomeCalc *gc) + { + CalculatorStack *stack; + gchar buf[80]; + gchar format[20]; + gint i; + + g_return_if_fail(gc!=NULL); + + if(!gc->_priv->stack) + return; + + stack = gc->_priv->stack->data; + if(stack->type!=CALCULATOR_NUMBER) + return; + + gc->_priv->result = stack->d.number; + + /* make sure put values in a consistent manner */ + /* XXX: perhaps we can make sure the calculator works on all locales, + * but currently it will lose precision if we don't do this */ + gnome_i18n_push_c_numeric_locale (); + for (i = 12; i > 0; i--) { + g_snprintf (format, sizeof (format), "%c .%dg", '%', i); + g_snprintf (buf, sizeof (buf), format, gc->_priv->result); + if (strlen (buf) <= 12) + break; + } + gnome_i18n_pop_c_numeric_locale (); + strncpy(gc->_priv->result_string,buf,12); + gc->_priv->result_string[12]='\0'; + + set_display (gc); + gtk_signal_emit(GTK_OBJECT(gc), + gnome_calc_signals[RESULT_CHANGED_SIGNAL], + gc->_priv->result); + + } + + static void + unselect_invert(GnomeCalc *gc) + { + g_return_if_fail(gc != NULL); + g_return_if_fail(GNOME_IS_CALC(gc)); + g_return_if_fail(gc->_priv->invert_button); + + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gc->_priv->invert_button), + FALSE); + gc->_priv->invert=FALSE; + } + + static void + setup_drg_label(GnomeCalc *gc) + { + GtkButton *button; + + g_return_if_fail(gc != NULL); + g_return_if_fail(GNOME_IS_CALC(gc)); + g_return_if_fail(gc->_priv->drg_button); + + button = GTK_BUTTON(gc->_priv->drg_button); + + if(gc->_priv->mode == GNOME_CALC_DEG) + gtk_button_set_label(button, _("DEG")); + else if(gc->_priv->mode == GNOME_CALC_RAD) + gtk_button_set_label(button, _("RAD")); + else + gtk_button_set_label(button, _("GRAD")); + } + + static gdouble + convert_num(gdouble num, GnomeCalcMode from, GnomeCalcMode to) + { + if(to==from) + return num; + else if(from==GNOME_CALC_DEG) { + if(to==GNOME_CALC_RAD) { + if (fabs (num - 90) < 0.000001) + return M_PI_2; + else if (fabs (num - 180) < 0.000001) + return M_PI; + else if (fabs (num - 45) < 0.000001) + return M_PI_4; + else if (fabs (num - 360) < 0.000001) + return 2*M_PI; + return (num*M_PI)/180; + } else /*GRAD*/ + return (num*200)/180; + } + else if(from==GNOME_CALC_RAD) + if(to==GNOME_CALC_DEG) { + if (num == M_PI) + return 180; + else if (num == M_PI_2) + return 90; + else if (num == M_PI_4) + return 45; + return (num*180)/M_PI; + } else /*GRAD*/ + return (num*200)/M_PI; + else /*GRAD*/ + if(to==GNOME_CALC_DEG) + return (num*180)/200; + else /*RAD*/ + return (num*M_PI)/200; + } + + static void + no_func(GtkWidget *w, gpointer data) + { + GList *list; + static CalculatorStack saved_func, saved_num; + CalculatorStack *stack1, *stack2, *add_func, *add_num; + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + if(gc->_priv->error) + return; + + push_input(gc); + + /* if no stack, nothing happens */ + if(!gc->_priv->stack) { + unselect_invert(gc); + return; + } + + reduce_stack_prec(gc,NULL); + + if(gc->_priv->error) { + gc->_priv->error = FALSE; + return; + } + + /* = after = eg: 3+== */ + if (cmd_saved == TRUE) { + add_func = g_new(CalculatorStack, 1); + add_func->type = saved_func.type; + add_func->d = saved_func.d; + gc->_priv->stack = g_list_prepend(gc->_priv->stack, add_func); + + add_num = g_new(CalculatorStack, 1); + add_num->type = saved_num.type; + add_num->d = saved_num.d; + gc->_priv->stack = g_list_prepend(gc->_priv->stack, add_num); + gc->_priv->add_digit = FALSE; + + reduce_stack(gc); + } else { + if(gc->_priv->stack == NULL) + return; + stack1 = gc->_priv->stack->data; + + list=g_list_next(gc->_priv->stack); + if(list) { + stack2 = list->data; + + if( stack1->type == CALCULATOR_FUNCTION && + stack2->type == CALCULATOR_NUMBER) { + saved_func.type = CALCULATOR_FUNCTION; + saved_func.d = stack1->d; + + saved_num.type = CALCULATOR_NUMBER; + saved_num.d = stack2->d; + + add_num = g_new(CalculatorStack,1); + add_num->type = saved_num.type; + add_num->d = saved_num.d; + gc->_priv->stack = g_list_prepend(gc->_priv->stack, add_num); + gc->_priv->add_digit = FALSE; + + reduce_stack(gc); + cmd_saved = TRUE; + } + } + } + + set_result(gc); + + unselect_invert(gc); + } + + static void + simple_func(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + CalculatorStack *stack; + CalculatorButton *but = data; + MathFunction1 func = but->data; + MathFunction1 invfunc = but->invdata; + + g_return_if_fail(func!=NULL); + g_return_if_fail(gc!=NULL); + + cmd_saved = FALSE; + + if(gc->_priv->error) + return; + + push_input(gc); + + if(!gc->_priv->stack) { + unselect_invert(gc); + return; + } + + stack = gc->_priv->stack->data; + + if(stack->type==CALCULATOR_FUNCTION) { + stack_pop(&gc->_priv->stack); + stack = gc->_priv->stack->data; + } + + if(stack->type!=CALCULATOR_NUMBER) { + unselect_invert(gc); + return; + } + + /*only convert non inverting functions*/ + if(!gc->_priv->invert && but->convert_to_rad) + stack->d.number = convert_num(stack->d.number, + gc->_priv->mode, + GNOME_CALC_RAD); + + errno = 0; + { + sighandler_t old = signal(SIGFPE,sigfpe_handler); + if(!gc->_priv->invert || invfunc==NULL) + stack->d.number = (*func)(stack->d.number); + else + stack->d.number = (*invfunc)(stack->d.number); + signal(SIGFPE,old); + } + + if(errno>0 || + finite(stack->d.number)==0) { + do_error(gc); + gc->_priv->error = FALSE; + stack->d.number = 0; + errno = 0; + return; + } + + /*we are converting back from rad to mode*/ + if(gc->_priv->invert && but->convert_to_rad) + stack->d.number = convert_num(stack->d.number, + GNOME_CALC_RAD, + gc->_priv->mode); + + set_result(gc); + + unselect_invert(gc); + } + + static void + math_func(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + CalculatorStack *stack; + CalculatorButton *but = data; + MathFunction2 func = but->data; + MathFunction2 invfunc = but->invdata; + + g_return_if_fail(func!=NULL); + g_return_if_fail(gc!=NULL); + + cmd_saved = FALSE; + + if(gc->_priv->error) + return; + + push_input(gc); + + if(!gc->_priv->stack) { + unselect_invert(gc); + return; + } + + reduce_stack_prec(gc,func); + if(gc->_priv->error) return; + set_result(gc); + + stack = gc->_priv->stack->data; + + if(stack->type==CALCULATOR_FUNCTION) { + stack_pop(&gc->_priv->stack); + stack = gc->_priv->stack->data; + } + + if(stack->type!=CALCULATOR_NUMBER) { + unselect_invert(gc); + return; + } + + stack = g_new(CalculatorStack,1); + stack->type = CALCULATOR_FUNCTION; + if(!gc->_priv->invert || invfunc==NULL) + stack->d.func = func; + else + stack->d.func = invfunc; + + gc->_priv->stack = g_list_prepend(gc->_priv->stack,stack); + + unselect_invert(gc); + } + + static void + reset_calc(GtkWidget *w, gpointer data) + { + GnomeCalc *gc; + if(w) + gc = g_object_get_data(G_OBJECT(w), "set_data"); + else + gc = data; + + g_return_if_fail(gc!=NULL); + + cmd_saved = FALSE; + + while(gc->_priv->stack) + stack_pop(&gc->_priv->stack); + + gc->_priv->result = 0; + strcpy(gc->_priv->result_string, " 0"); + gc->_priv->memory = 0; + gc->_priv->mode = GNOME_CALC_DEG; + gc->_priv->invert = FALSE; + gc->_priv->error = FALSE; + + gc->_priv->add_digit = TRUE; + push_input(gc); + set_result(gc); + unselect_invert(gc); + setup_drg_label(gc); + } + + static void + clear_calc(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + cmd_saved = FALSE; + + /* if in add digit mode, just clear the number, otherwise clear + * state as well */ + if(!gc->_priv->add_digit) { + while(gc->_priv->stack) + stack_pop(&gc->_priv->stack); + } + + gc->_priv->result = 0; + strcpy(gc->_priv->result_string, " 0"); + gc->_priv->error = FALSE; + gc->_priv->invert = FALSE; + + gc->_priv->add_digit = TRUE; + push_input(gc); + set_result(gc); + + unselect_invert(gc); + } + + + /** + * gnome_calc_clear + * @gc: Pointer to GNOME calculator widget. + * @reset: %FALSE to zero, %TRUE to reset calculator completely + * + * Description: + * Resets the calculator back to zero. If @reset is %TRUE, results + * stored in memory and the calculator mode are cleared also. + **/ + + void + gnome_calc_clear(GnomeCalc *gc, const gboolean reset) + { + if (reset) + reset_calc(NULL, gc); + else + clear_calc(NULL, gc); + } + + static void + add_digit (GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data (G_OBJECT (w), "set_data"); + CalculatorButton *but = data; + gchar *digit = but->name; + + cmd_saved = FALSE; + + if(gc->_priv->error) + return; + + /* For "EE" where name is not what we want to add */ + if (but->data != NULL) + digit = but->data; + + g_return_if_fail(gc!=NULL); + g_return_if_fail(digit!=NULL); + + if(!gc->_priv->add_digit) { + if(gc->_priv->stack) { + CalculatorStack *stack=gc->_priv->stack->data; + if(stack->type==CALCULATOR_NUMBER) + stack_pop(&gc->_priv->stack); + } + gc->_priv->add_digit = TRUE; + gc->_priv->result_string[0] = '\0'; + } + + unselect_invert(gc); + + if(digit[0]=='e') { + if(strchr(gc->_priv->result_string,'e')) + return; + else if(strlen(gc->_priv->result_string)>9) + return; + else if(gc->_priv->result_string[0]=='\0') + strcpy(gc->_priv->result_string," 0"); + } else if(digit[0]=='.') { + if(strchr(gc->_priv->result_string,'.')) + return; + else if(strlen(gc->_priv->result_string)>10) + return; + else if(gc->_priv->result_string[0]=='\0') + strcpy(gc->_priv->result_string," 0"); + } else { /*numeric*/ + if(strlen(gc->_priv->result_string)>11) + return; + else if (strcmp (gc->_priv->result_string, " 0") == 0 || + gc->_priv->result_string[0]=='\0') + strcpy(gc->_priv->result_string," "); + } + + strcat (gc->_priv->result_string, digit); + + set_display (gc); + + /* make sure get values in a consistent manner */ + gnome_i18n_push_c_numeric_locale (); + sscanf(gc->_priv->result_string, "%lf", &gc->_priv->result); + gnome_i18n_pop_c_numeric_locale (); + } + + static gdouble + c_neg(gdouble arg) + { + return -arg; + } + + + static void + negate_val(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + char *p; + + g_return_if_fail(gc!=NULL); + + cmd_saved = FALSE; + + if(gc->_priv->error) + return; + + unselect_invert(gc); + + if(!gc->_priv->add_digit && gc->_priv->result != 0) { + simple_func(w,data); + return; + } + + if((p=strchr(gc->_priv->result_string,'e'))!=NULL) { + p++; + if(*p=='-') + *p='+'; + else + *p='-'; + } else { + if(gc->_priv->result_string[0]=='-' || + gc->_priv->result == 0) + gc->_priv->result_string[0]=' '; + else + gc->_priv->result_string[0]='-'; + } + + /* make sure get values in a consistent manner */ + gnome_i18n_pop_c_numeric_locale (); + sscanf(gc->_priv->result_string, "%lf", &gc->_priv->result); + gnome_i18n_push_c_numeric_locale (); + + set_display (gc); + } + + static gdouble + c_inv(gdouble arg1) + { + if(arg1==0) { + errno=ERANGE; + return 0; + } + return 1/arg1; + } + + static gdouble + c_pow2(gdouble arg1) + { + return pow(arg1,2); + } + + static gdouble + c_pow10(gdouble arg1) + { + return pow(10,arg1); + } + + static gdouble + c_powe(gdouble arg1) + { + return pow(M_E,arg1); + } + + static gdouble + c_fact(gdouble arg1) + { + int i; + gdouble r; + if(arg1<0) { + errno=ERANGE; + return 0; + } + i = (int)(arg1+0.5); + if((fabs(arg1-i))>1e-9) { + errno=ERANGE; + return 0; + } + for(r=1;i>0;i--) + r*=i; + + return r; + } + + static gdouble + set_result_to(GnomeCalc *gc, gdouble result) + { + gdouble old; + + if(gc->_priv->stack==NULL || + ((CalculatorStack *)gc->_priv->stack->data)->type!=CALCULATOR_NUMBER) { + gc->_priv->add_digit = TRUE; + old = gc->_priv->result; + gc->_priv->result = result; + push_input(gc); + } else { + old = ((CalculatorStack *)gc->_priv->stack->data)->d.number; + ((CalculatorStack *)gc->_priv->stack->data)->d.number = result; + } + + set_result(gc); + + return old; + } + + + /** + * gnome_calc_set + * @gc: Pointer to GNOME calculator widget. + * @result: New value of calculator buffer. + * + * Description: Sets the value stored in the calculator's result buffer to the + * given @result. + **/ + + void + gnome_calc_set(GnomeCalc *gc, gdouble result) + { + set_result_to(gc,result); + } + + static void + store_m(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + if(gc->_priv->error) + return; + + push_input(gc); + + gc->_priv->memory = gc->_priv->result; + + set_display (gc); + + unselect_invert(gc); + } + + static void + recall_m(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + if(gc->_priv->error) + return; + + set_result_to(gc,gc->_priv->memory); + + unselect_invert(gc); + } + + static void + sum_m(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + if(gc->_priv->error) + return; + + push_input(gc); + + gc->_priv->memory += gc->_priv->result; + + set_display (gc); + + unselect_invert(gc); + } + + static void + exchange_m(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + if(gc->_priv->error) + return; + + gc->_priv->memory = set_result_to(gc,gc->_priv->memory); + + unselect_invert(gc); + } + + static void + invert_toggle(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + if(gc->_priv->error) + return; + + if(GTK_TOGGLE_BUTTON(w)->active) + gc->_priv->invert=TRUE; + else + gc->_priv->invert=FALSE; + } + + static void + drg_toggle(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + GnomeCalcMode oldmode; + + g_return_if_fail(gc!=NULL); + + if(gc->_priv->error) + return; + + oldmode = gc->_priv->mode; + + if(gc->_priv->mode==GNOME_CALC_DEG) + gc->_priv->mode=GNOME_CALC_RAD; + else if(gc->_priv->mode==GNOME_CALC_RAD) + gc->_priv->mode=GNOME_CALC_GRAD; + else + gc->_priv->mode=GNOME_CALC_DEG; + + setup_drg_label(gc); + + /*convert if invert is on*/ + if(gc->_priv->invert) { + CalculatorStack *stack; + push_input(gc); + stack = gc->_priv->stack->data; + stack->d.number = convert_num(stack->d.number, + oldmode,gc->_priv->mode); + set_result(gc); + } + + unselect_invert(gc); + } + + static void + set_pi(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + if(gc->_priv->error) + return; + + set_result_to(gc,M_PI); + + unselect_invert(gc); + } + + static gboolean + maybe_run_slide_rule (GtkWidget *w, GdkEvent *event, gpointer data) + { + if (event->type == GDK_3BUTTON_PRESS) { + run_slide_rule (); + return TRUE; + } + return FALSE; + } + + static void + set_e (GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + if(gc->_priv->error) + return; + + set_result_to(gc,M_E); + + unselect_invert(gc); + } + + static void + add_parenth(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + + g_return_if_fail(gc!=NULL); + + cmd_saved = FALSE; + + if(gc->_priv->error) + return; + + if(gc->_priv->stack && + ((CalculatorStack *)gc->_priv->stack->data)->type==CALCULATOR_NUMBER) + ((CalculatorStack *)gc->_priv->stack->data)->type = + CALCULATOR_PARENTHESIS; + else { + CalculatorStack *stack; + stack = g_new(CalculatorStack,1); + stack->type = CALCULATOR_PARENTHESIS; + gc->_priv->stack = g_list_prepend(gc->_priv->stack,stack); + } + + gc->_priv->add_digit = FALSE; + unselect_invert(gc); + } + + static void + sub_parenth(GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + g_return_if_fail(gc!=NULL); + + cmd_saved = FALSE; + + if(gc->_priv->error) + return; + + push_input(gc); + reduce_stack_prec(gc,NULL); + if(gc->_priv->error) return; + set_result(gc); + + if(gc->_priv->stack) { + CalculatorStack *stack = gc->_priv->stack->data; + if(stack->type==CALCULATOR_PARENTHESIS) + stack_pop(&gc->_priv->stack); + else if(g_list_next(gc->_priv->stack)) { + stack = g_list_next(gc->_priv->stack)->data; + if(stack->type==CALCULATOR_PARENTHESIS) { + GList *n = g_list_next(gc->_priv->stack); + gc->_priv->stack = g_list_remove_link(gc->_priv->stack,n); + g_list_free_1(n); + } + } + } + + unselect_invert(gc); + } + + static double + sin_helper (double value) + { + double ret = sin (value); + + if (fabs (ret) <= fabs (sin (M_PI))) + return 0.0; + else + return ret; + } + + static double + cos_helper (double value) + { + double ret = cos (value); + if (fabs (ret) <= fabs (cos (M_PI_2))) + return 0.0; + else + return ret; + } + + static double + tan_helper (double value) + { + double ret = tan (value); + double temp1, temp2; + + if (fabs (ret) >= fabs (tan(3 * M_PI_2))) { + errno=ERANGE; + return 0.0; + } + else if (fabs (ret) <= fabs (tan(M_PI))) { + return 0.0; + } + else + return ret; + } + + static const CalculatorButton buttons[8][5] = { + { + {N_("1/x"), (GtkSignalFunc)simple_func, c_inv, NULL, FALSE, {0}, N_("Inverse"), NULL }, + {N_("x2"), (GtkSignalFunc)simple_func, c_pow2, sqrt, FALSE, {0}, N_("Square"), NULL }, + {N_("SQRT"), (GtkSignalFunc)simple_func, sqrt, c_pow2, FALSE, {'r',0}, N_("Square root"), NULL }, + {N_("CE/C"), (GtkSignalFunc)clear_calc, NULL, NULL, FALSE, {GDK_Clear,GDK_Delete,0}, N_("Clear"), NULL }, + {N_("AC"), (GtkSignalFunc)reset_calc, NULL, NULL, FALSE, {'a', GDK_Escape, 0}, N_("Reset"), NULL } + },{ + {N_("INV"), NULL, NULL, NULL, FALSE, {'i',0}, N_("Inverse trigonometry/log function"), NULL }, /*inverse button*/ + {N_("sin"), (GtkSignalFunc)simple_func, sin_helper, asin, TRUE,{'s',0}, N_("Sine"), NULL }, + {N_("cos"), (GtkSignalFunc)simple_func, cos_helper, acos, TRUE,{'c',0}, N_("Cosine"), NULL }, + {N_("tan"), (GtkSignalFunc)simple_func, tan_helper, atan, TRUE, {'t',0}, N_("Tangent"), NULL }, + /* Ugly hack so that window won't resize when selecting GRAD - there should be a better fix that this */ + {N_(" DEG "), (GtkSignalFunc)drg_toggle, NULL, NULL, FALSE, {'d',0}, N_("Switch degrees / radians / grad"), NULL } + },{ + {N_("e"), (GtkSignalFunc)set_e, NULL, NULL, FALSE, {'e',0}, N_("Base of Natural Logarithm"), NULL }, + {N_("EE"), (GtkSignalFunc)add_digit, "e+", NULL, FALSE, {0}, N_("Add digit"), NULL }, + {N_("log"), (GtkSignalFunc)simple_func, log10, c_pow10,FALSE, {0}, N_("Base 10 Logarithm"), NULL }, + {N_("ln"), (GtkSignalFunc)simple_func, log, c_powe, FALSE, {'l',0}, N_("Natural Logarithm"), NULL }, + {N_("xy"), (GtkSignalFunc)math_func, pow, NULL, FALSE, {'^',0}, N_("Power"), NULL } + },{ + {N_("PI"), (GtkSignalFunc)set_pi, NULL, NULL, FALSE, {'p',0}, N_("PI"), NULL }, + {N_("x!"), (GtkSignalFunc)simple_func, c_fact, NULL, FALSE, {'!',0}, N_("Factorial"), NULL }, + {N_("("), (GtkSignalFunc)add_parenth, NULL, NULL, FALSE, {'(',0}, N_("Opening Parenthesis"), NULL }, + {N_(")"), (GtkSignalFunc)sub_parenth, NULL, NULL, FALSE, {')',0}, N_("Closing Parenthesis"), NULL }, + {N_("/"), (GtkSignalFunc)math_func, c_div, NULL, FALSE, {'/',GDK_KP_Divide,0}, N_("Divide by"), NULL } + },{ + {N_("STO"), (GtkSignalFunc)store_m, NULL, NULL, FALSE, {0}, N_("Store the value in the\ndisplay field in memory"), NULL }, + {N_("7"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'7',GDK_KP_7,GDK_KP_Home,0}, NULL, NULL }, + {N_("8"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'8',GDK_KP_8,GDK_KP_Up,0}, NULL, NULL }, + {N_("9"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'9',GDK_KP_9,GDK_KP_Page_Up,0}, NULL, NULL }, + {N_("*"), (GtkSignalFunc)math_func, c_mul, NULL, FALSE, {'*',GDK_KP_Multiply,0}, N_("Multiply by"), NULL } + },{ + {N_("RCL"), (GtkSignalFunc)recall_m, NULL, NULL, FALSE, {0}, N_("Display the value in memory\nin the display field"), NULL }, + {N_("4"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'4',GDK_KP_4,GDK_KP_Left,0}, NULL, NULL }, + {N_("5"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'5',GDK_KP_5,GDK_KP_Begin,0}, NULL, NULL }, + {N_("6"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'6',GDK_KP_6,GDK_KP_Right,0}, NULL, NULL }, + {N_("-"), (GtkSignalFunc)math_func, c_sub, NULL, FALSE, {'-',GDK_KP_Subtract,0}, N_("Subtract"), NULL } + },{ + {N_("SUM"), (GtkSignalFunc)sum_m, NULL, NULL, FALSE, {0}, N_("Add the value in the display\nfield to the value in memory"), NULL }, + {N_("1"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'1',GDK_KP_1,GDK_KP_End,0}, NULL, NULL }, + {N_("2"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'2',GDK_KP_2,GDK_KP_Down,0}, NULL, NULL }, + {N_("3"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'3',GDK_KP_3,GDK_KP_Page_Down,0}, NULL, NULL }, + {N_("+"), (GtkSignalFunc)math_func, c_add, NULL, FALSE, {'+',GDK_KP_Add,0}, N_("Add"), NULL } + },{ + {N_("EXC"), (GtkSignalFunc)exchange_m, NULL, NULL, FALSE, {0}, N_("Exchange the values in the\ndisplay field and memory"), NULL }, + {N_("0"), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'0',GDK_KP_0,GDK_KP_Insert,0}, NULL, NULL }, + {N_("."), (GtkSignalFunc)add_digit, NULL, NULL, FALSE, {'.',GDK_KP_Decimal,',',GDK_KP_Delete,0}, N_("Decimal Point"), NULL }, + {N_("+/-"), (GtkSignalFunc)negate_val, c_neg, NULL, FALSE, {0}, N_("Change sign"), NULL }, + {N_("="), (GtkSignalFunc)no_func, NULL, NULL, FALSE, {'=',GDK_KP_Enter,0}, N_("Calculate"), NULL } + } + }; + + static void + create_button(GnomeCalc *gc, GtkWidget *table, int x, int y) + { + const CalculatorButton *but = &buttons[y][x]; + GtkWidget *w, *l; + int i; + + if(!but->name) + return; + + l = gtk_label_new (_(but->name)); + gtk_widget_show (l); + gtk_label_set_use_markup (GTK_LABEL (l), TRUE); + + if (strcmp (but->name, "INV") == 0) { + w = gtk_toggle_button_new (); + gtk_container_add (GTK_CONTAINER (w), l); + gc->_priv->invert_button = w; + g_signal_connect (G_OBJECT (w), "toggled", + G_CALLBACK (invert_toggle), gc); + } else { + w = gtk_button_new (); + gtk_container_add (GTK_CONTAINER (w), l); + g_signal_connect (G_OBJECT(w), "clicked", + but->signal_func, + (gpointer) but); + } + + if (strcmp (but->name, "e") == 0) + g_signal_connect (G_OBJECT (w), "button_press_event", + G_CALLBACK (maybe_run_slide_rule), + (gpointer) but); + + for(i=0;but->keys[i]!=0;i++) { + gtk_widget_add_accelerator(w, "clicked", + gc->_priv->accel, + but->keys[i], 0, + GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator(w, "clicked", + gc->_priv->accel, + but->keys[i], + GDK_SHIFT_MASK, + GTK_ACCEL_VISIBLE); + gtk_widget_add_accelerator(w, "clicked", + gc->_priv->accel, + but->keys[i], + GDK_LOCK_MASK, + GTK_ACCEL_VISIBLE); + } + + if (but->tooltip != NULL) { + gtk_tooltips_set_tip(GTK_TOOLTIPS(gc->_priv->tooltips), w, _(but->tooltip), but->tooltip_private); + } + + g_object_set_data(G_OBJECT(w), "set_data", gc); + gtk_widget_show(w); + gtk_table_attach(GTK_TABLE(table), w, + x, x+1, y, y+1, + GTK_FILL | GTK_EXPAND | + GTK_SHRINK, + GTK_FILL | GTK_EXPAND | GTK_SHRINK, 2, 2); + + /* if this is the DRG button, remember it's pointer */ + if(but->signal_func == G_CALLBACK (drg_toggle)) + gc->_priv->drg_button = w; + } + + static void + gnome_calc_instance_init (GnomeCalc *gc) + { + GtkWidget *hbox; + GtkWidget *table; + GtkTextBuffer *buffer; + gint x,y; + + gc->_priv = g_new0(GnomeCalcPrivate, 1); + + hbox = gtk_hbox_new (FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 2); + gtk_widget_show (hbox); + gtk_box_pack_start (GTK_BOX (gc), hbox, FALSE, FALSE, 0); + + gc->_priv->text_display = gtk_text_view_new (); + gc->_priv->store_display = gtk_text_view_new (); + + g_object_set (G_OBJECT (gc->_priv->store_display), + "cursor-visible", FALSE, NULL); + + gtk_text_view_set_editable (GTK_TEXT_VIEW (gc->_priv->store_display), FALSE); + gtk_text_view_set_justification (GTK_TEXT_VIEW (gc->_priv->store_display), + GTK_JUSTIFY_LEFT); + gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (gc->_priv->store_display), + GTK_WRAP_WORD); + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (gc->_priv->store_display)); + gtk_text_buffer_create_tag (buffer, "x-large", + "scale", PANGO_SCALE_XX_LARGE, NULL); + gtk_box_pack_start (GTK_BOX (hbox), gc->_priv->store_display, TRUE, TRUE, 0); + + gtk_text_view_set_editable (GTK_TEXT_VIEW (gc->_priv->text_display), FALSE); + gtk_text_view_set_justification (GTK_TEXT_VIEW (gc->_priv->text_display), + GTK_JUSTIFY_RIGHT); + gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (gc->_priv->text_display), + GTK_WRAP_WORD); + buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (gc->_priv->text_display)); + gtk_text_buffer_create_tag (buffer, "x-large", + "scale", PANGO_SCALE_XX_LARGE, NULL); + gtk_box_pack_end (GTK_BOX (hbox), gc->_priv->text_display, TRUE, TRUE, 0); + + gtk_widget_show (gc->_priv->text_display); + gtk_widget_show (gc->_priv->store_display); + + gc->_priv->stack = NULL; + gc->_priv->result = 0; + strcpy(gc->_priv->result_string," 0"); + gc->_priv->memory = 0; + gc->_priv->mode = GNOME_CALC_DEG; + gc->_priv->invert = FALSE; + gc->_priv->add_digit = TRUE; + gc->_priv->accel = gtk_accel_group_new(); + gc->_priv->tooltips = gtk_tooltips_new(); + + table = gtk_table_new(8,5,TRUE); + gtk_widget_show(table); + + gtk_box_pack_start(GTK_BOX(gc),table,TRUE,TRUE,0); + + for(x=0;x<5;x++) { + for(y=0;y<8;y++) { + create_button(gc, table, x, y); + } + } + + gtk_tooltips_enable (gc->_priv->tooltips); + + set_display (gc); + + } + + + /** + * gnome_calc_new: + * + * Description: Creates a calculator widget, a window with all the common + * buttons and functions found on a standard pocket calculator. + * + * Returns: Pointer to newly-created calculator widget. + **/ + + GtkWidget * + gnome_calc_new (void) + { + GnomeCalc *gcalculator; + + gcalculator = g_object_new (gnome_calc_get_type (), NULL); + + return GTK_WIDGET (gcalculator); + } + + static void + gnome_calc_destroy (GtkObject *object) + { + GnomeCalc *gc; + + /* remember, destroy can be run multiple times! */ + + g_return_if_fail (object != NULL); + g_return_if_fail (GNOME_IS_CALC (object)); + + gc = GNOME_CALC (object); + + while(gc->_priv->stack) + stack_pop(&gc->_priv->stack); + + GNOME_CALL_PARENT (GTK_OBJECT_CLASS, destroy, (object)); + } + + static void + gnome_calc_finalize (GObject *object) + { + GnomeCalc *gc; + + g_return_if_fail (object != NULL); + g_return_if_fail (GNOME_IS_CALC (object)); + + gc = GNOME_CALC (object); + + if(gc->_priv) { + g_free(gc->_priv); + gc->_priv = NULL; + } + + GNOME_CALL_PARENT (G_OBJECT_CLASS, finalize, (object)); + } + + /** + * gnome_calc_get_result + * @gc: Pointer to GNOME calculator widget + * + * Description: Gets the value of the result buffer as a double. + * This should read off whatever is currently on the display of the + * calculator. + * + * Returns: A double precision result. + **/ + + gdouble + gnome_calc_get_result (GnomeCalc *gc) + { + g_return_val_if_fail (gc, 0.0); + g_return_val_if_fail (GNOME_IS_CALC (gc), 0.0); + + return gc->_priv->result; + } + + /** + * gnome_calc_get_accel_group + * @gc: Pointer to GNOME calculator widget + * + * Description: Gets the accelerator group which you can add to + * the toplevel window or wherever you want to catch the keys for this + * widget. + * + * Returns: The accelerator group + **/ + + GtkAccelGroup * + gnome_calc_get_accel_group(GnomeCalc *gc) + { + g_return_val_if_fail (gc, NULL); + g_return_val_if_fail (GNOME_IS_CALC (gc), NULL); + + return gc->_priv->accel; + } + /** + * gnome_calc_get_result_string: + * @gc: Pointer to GNOME calculator widget + * + * Description: Gets the internal string representation of the result. + * + * Returns: Internal string pointer, do not free + **/ + const char * + gnome_calc_get_result_string(GnomeCalc *gc) + { + g_return_val_if_fail (gc, NULL); + g_return_val_if_fail (GNOME_IS_CALC (gc), NULL); + + return gc->_priv->result_string; + } + + + + + /** + * delete_digit: + * @w: + * @data: + * + * Handle the backspace event + **/ + static void + backspace_cb (GtkWidget *w, gpointer data) + { + GnomeCalc *gc = g_object_get_data(G_OBJECT(w), "set_data"); + char *old_locale; + gint length; + + g_return_if_fail (GNOME_IS_CALC (gc)); + + if(gc->_priv->error) + return; + + unselect_invert(gc); + + length = strlen (gc->_priv->result_string); + + /* The behaivor that I expect from the calculator when the backspace key + * is pressed is : + * - If i was typing a number, i expect to delete the last char + * - If i have a result already, i expect to clear the calculator + */ + if (!gc->_priv->add_digit) { + clear_calc (w, data); + return; + } + + if (atof (gc->_priv->result_string) == 0.0) + return; + + gc->_priv->result_string [length - 1] = 0; + if (atof (gc->_priv->result_string) == 0.0) { + gc->_priv->result_string [0] = ' '; + gc->_priv->result_string [1] = '0'; + gc->_priv->result_string [2] = 0; + } + + gc->_priv->result = atof (gc->_priv->result_string); + if (gc->_priv->stack) { + CalculatorStack *stack = gc->_priv->stack->data; + if (stack->type == CALCULATOR_NUMBER) + stack->d.number = gc->_priv->result; + } + + set_display (gc); + + /* make sure get values in a consistent manner */ + old_locale = g_strdup (setlocale (LC_NUMERIC, NULL)); + setlocale (LC_NUMERIC, "C"); + sscanf(gc->_priv->result_string, "%lf", &gc->_priv->result); + setlocale (LC_NUMERIC, old_locale); + g_free (old_locale); + } + + /* + * This code adds the ability to bound other keys to certain functions + * usefull for keys that can't be bound as an accelerator or functions + * that do not have a button in the calculator. Chema + */ + typedef struct _GnomeCalcExtraKeys GnomeCalcExtraKeys; + typedef void (*CalcKeypressFunc) (GtkWidget *w, gpointer data); + + struct _GnomeCalcExtraKeys { + gint key; + CalcKeypressFunc signal_func; + gpointer data; + }; + + static const GnomeCalcExtraKeys extra_keys [] = { + {GDK_BackSpace, backspace_cb, NULL}, + {GDK_Return, no_func, NULL}, + {GDK_KP_Enter, no_func, NULL}, + {GDK_Delete, clear_calc, NULL}, + {GDK_KP_Delete, add_digit, "."}, + {GDK_KP_Left, add_digit, "4"}, + {GDK_KP_4, add_digit, "4"}, + {GDK_KP_Right, add_digit, "6"}, + {GDK_KP_6, add_digit, "6"}, + {GDK_KP_Up, add_digit, "8"}, + {GDK_KP_8, add_digit, "8"}, + {GDK_KP_Down, add_digit, "2"}, + {GDK_KP_2, add_digit, "2"}, + {GDK_End, add_digit, "1"}, + {GDK_Page_Down, add_digit, "3"}, + {GDK_Home, add_digit, "7"}, + {GDK_Page_Up, add_digit, "9"} + }; + + static gboolean + event_cb (GtkWidget *widget, GdkEvent *event, gpointer calc) + { + GnomeCalc *gc; + gint i, num; + GdkEventKey *kevent; + + if (event->type != GDK_KEY_PRESS) + return FALSE; + + kevent = (GdkEventKey *)event; + + gc = (GnomeCalc *) calc; + g_return_val_if_fail (GNOME_IS_CALC (gc), FALSE); + + num = sizeof (extra_keys) / sizeof (GnomeCalcExtraKeys); + + for (i = 0; i < num; i++) { + if (kevent->keyval == extra_keys[i].key) { + CalculatorButton but = {NULL}; + CalcKeypressFunc func = extra_keys [i].signal_func; + but.data = extra_keys[i].data; + (* func) (widget, &but); + return TRUE; + } + } + + return FALSE; + } + + + void + gnome_calc_bind_extra_keys (GnomeCalc *gc, + GtkWidget *widget) + { + g_return_if_fail (GNOME_IS_CALC (gc)); + g_return_if_fail (GTK_IS_WIDGET (widget)); + + g_object_set_data (G_OBJECT (widget), "set_data", gc); + + g_signal_connect (GTK_OBJECT (widget), "event", + G_CALLBACK (event_cb), gc); + + } diff -crN ./gnome-utils/gcalc/sr.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gcalc/sr.c *** ./gnome-utils/gcalc/sr.c Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gcalc/sr.c Tue Jul 8 10:27:15 2003 *************** *** 0 **** --- 1,623 ---- + /* + * based on xcalc/sr.c from X11R3: + * + * Copyright 1988, Massachusetts Institute of Technology. + * XConsortium: sr.c,v 1.10 88/10/22 10:37:58 jim Exp + * + * Converted to ANSI C and dropped into gcalc by jwz@jwz.org, 24-Jun-2001. + */ + + /* Slide Rule */ + + /* FIXME: port this to GTK+/gdk */ + + #include "config.h" + + #include + #include + + #include + #include + #include + #include + #include + #include + #include + #include + + #include "sr.h" + + + #define SLIDETOP 26 + #define SLIDEHIGH 38 + #define WIDTH 800 + #define HEIGHT 100 + #define START 70 + #define END 20 + #define LABEL 55 + #define MAXWIDTH 32766 + + #define FOFFSET 3 + #define MAJORH 10 + #define MIDDH 7 + #define MINORH 4 + #define HALVES 5 + #define FIFTHS 15 + #define TENTHS 40 + #define LABELFIFTH 41 + #define LABELTENTHS 200 + #define LABELSPACE 20 + + #define LSCALEH 2 + #define ASCALEH 16 + #define BSCALEH 0 + #define CISCALEH 14 + #define CSCALEH 28 + #define DSCALEH 66 + #define DISCALEH 84 + + static Display *dpy; + static Window slidewid,hairlwid,blackwid; + static Window theWindow,dispwid; + static XFontStruct *kfontinfo; + static Font scalefont, sscalefont; + /*static Pixmap backgroundPix,dimBorder,IconPix; */ + static Pixmap slidePix = 0; + static Pixmap framePix = 0; + static Cursor arrow; + static GC sgc, cgc; + static int height,scalelen,width,fheight,foffset; + static int xo,hx,xm; + static int ForeColor,BackColor; + static double logtenoftwo; + + #define KFONT "*helvetica-medium-r-normal--10-*" + + + static void rescale(int w); + static void drawframe(void); + static void doscale(Window win, int high, int offset, int len, int topp); + static void dotenths(Window win, int high, int offset, int len, char *str, + int topp); + static void drawslide(void); + static void redrawslide(int x, int y, int w, int h); + static void redrawframe(int x, int y, int w, int h); + static void drawhairl(void); + static void drawnums(void); + + + #define min(a,b) ((a) < (b) ? (a) : (b)) + #define max(a,b) ((a) > (b) ? (a) : (b)) + + static void + set_sizehint (XSizeHints *hintp, int min_width, int min_height, char *geom) + { + int geom_result; + + /* set the size hints, algorithm from xlib xbiff */ + + hintp->width = hintp->min_width = min_width; + hintp->height = hintp->min_height = min_height; + hintp->flags = PMinSize; + hintp->x = hintp->y = 0; + geom_result = NoValue; + if (geom != NULL) { + geom_result = XParseGeometry (geom, &hintp->x, &hintp->y, + &hintp->width, &hintp->height); + if ((geom_result & WidthValue) && (geom_result & HeightValue)) { + hintp->width = max (hintp->width, hintp->min_width); + hintp->height = max (hintp->height, hintp->min_height); + hintp->flags |= USSize; + } + if ((geom_result & XValue) && (geom_result & YValue)) { + hintp->flags += USPosition; + } + } + if (!(hintp->flags & USSize)) { + hintp->width = min_width; + hintp->height = min_height; + hintp->flags |= PSize; + } + if (!(hintp->flags & USPosition)) { + hintp->x = hintp->y = 0; + hintp->flags |= PPosition; + } + + if (geom_result & XNegative) { + hintp->x = DisplayWidth (dpy, DefaultScreen (dpy)) + hintp->x - + hintp->width; + } + if (geom_result & YNegative) { + hintp->y = DisplayHeight (dpy, DefaultScreen (dpy)) + hintp->y - + hintp->height; + } + } + + + + /**************/ + static void + do_sr(int argc, char **argv, char *geom, int border) + { + XSizeHints szhint; + XEvent event; + XGCValues gcv; + + /* figure out sizes of keypad and display */ + + kfontinfo = XLoadQueryFont(dpy, KFONT); + + sscalefont = scalefont = kfontinfo->fid; + fheight = kfontinfo->max_bounds.ascent + FOFFSET; + foffset = kfontinfo->max_bounds.ascent; + + /* Open the main window. */ + width = WIDTH; + scalelen = width - START - END; + height = HEIGHT; + xo = -1; + hx = width/2; + logtenoftwo = log10(2.0); + + set_sizehint (&szhint, WIDTH, HEIGHT, geom); + + ForeColor = BlackPixel(dpy,DefaultScreen(dpy)); + BackColor = WhitePixel(dpy,DefaultScreen(dpy)); + + theWindow = XCreateSimpleWindow(dpy, RootWindow(dpy, DefaultScreen(dpy)), + szhint.x, szhint.y, + szhint.width, szhint.height, border, + ForeColor, BackColor); + + + XSetStandardProperties(dpy, theWindow, "Slide Rule", NULL, 0/*IconPix*/, + argv, argc, &szhint); + + blackwid = XCreateSimpleWindow(dpy, theWindow, + 0,SLIDETOP,WIDTH,SLIDEHIGH+2,0, + BackColor,ForeColor); + /* XSetWindowBackgroundPixmap(dpy, blackwid, backgroundPix); */ + + + slidewid = XCreateSimpleWindow(dpy, theWindow, + -1,SLIDETOP,WIDTH,SLIDEHIGH,1, + ForeColor, BackColor); + hairlwid = XCreateSimpleWindow(dpy, theWindow, + WIDTH/2,0,1,height,0, + BackColor, ForeColor); + dispwid = XCreateSimpleWindow(dpy, theWindow, + 0, 0, START-END, HEIGHT,1, + ForeColor, BackColor); + + gcv.foreground = ForeColor; + gcv.background = BackColor; + gcv.font = scalefont; + sgc = XCreateGC(dpy, theWindow, GCForeground|GCBackground|GCFont, &gcv); + gcv.foreground = BackColor; + gcv.background = ForeColor; + cgc = XCreateGC(dpy, theWindow, GCForeground|GCBackground|GCFont, &gcv); + + #define STDEVENTS ExposureMask|EnterWindowMask|LeaveWindowMask + #define BUTEVENTS ButtonPressMask|ButtonReleaseMask + #define MOVEVENTS Button1MotionMask|Button2MotionMask|Button3MotionMask + XSelectInput(dpy, theWindow, STDEVENTS|BUTEVENTS|MOVEVENTS); + XSelectInput(dpy, hairlwid, STDEVENTS); + XSelectInput(dpy, dispwid, STDEVENTS); + XSelectInput(dpy, slidewid, STDEVENTS|BUTEVENTS|MOVEVENTS); + XSelectInput(dpy, blackwid, STDEVENTS|BUTEVENTS); + + XMapWindow (dpy, theWindow); + XMapSubwindows(dpy, theWindow); + arrow=XCreateFontCursor(dpy, XC_hand2); + XDefineCursor (dpy, theWindow, arrow); + + + /**************** Main loop *****************/ + + while (1) { + Window wind,mwid; + int dummy, w; + + XNextEvent(dpy, &event); + + switch (event.type) { + + case Expose: { + XExposeEvent *exp_event = (XExposeEvent *) &event; + wind = exp_event->window; + + if (wind==theWindow) { + XGetGeometry(dpy, theWindow, &mwid, &dummy, &dummy, &w, &dummy, + &dummy, &dummy); + if (width != w) { + rescale(w); + break; + } + redrawframe(exp_event->x, exp_event->y, exp_event->width, + exp_event->height); + } else if (wind==slidewid) + redrawslide(exp_event->x, exp_event->y, exp_event->width, + exp_event->height); + else if (wind==hairlwid) + drawhairl(); + else if (wind==blackwid) + XClearArea (dpy, blackwid, exp_event->x, exp_event->y, + exp_event->width, exp_event->height, False); + else if (wind==dispwid) + drawnums(); + break; + } + case ButtonPress: { + XButtonPressedEvent *but_event = (XButtonPressedEvent *) &event; + + mwid = wind = but_event->window; + if (wind == slidewid || wind == blackwid) { + switch (but_event->button & 0xff) { + case Button1: + xo = (wind==slidewid?xo:0) + but_event->x - START; + break; + case Button2: + if (but_event->state & ShiftMask) + exit(0); + if (wind == slidewid) + xm = but_event->x; + break; + case Button3: + if (but_event->state & ShiftMask) + exit(0); + xo = (wind==slidewid?xo:0) + but_event->x + END - width; + break; + } + XMoveWindow(dpy, slidewid, xo - 1, SLIDETOP); + drawnums(); + break; + } + if (wind == theWindow) { + switch (but_event->button & 0xff) { + case Button1: + hx = but_event->x; + break; + case Button2: + if (but_event->state & ShiftMask) + exit(0); + if (width*2 < MAXWIDTH) + rescale(width*2); + break; + case Button3: + rescale(width/2); + } + drawhairl(); + drawnums(); + break; + } + break; + } + case MotionNotify: { + /* XPointerMovedEvent *mov_event = (XPointerMovedEvent *) &event;*/ + int x, y, newx, dummy, mask; + Window mwid; + + wind = mwid; + XQueryPointer(dpy, theWindow, &mwid, &mwid, &x, &y, &dummy, &dummy, + &mask); + while (XPending(dpy) && (XPeekEvent(dpy, &event), + (event.type == MotionNotify))) + XNextEvent(dpy, &event); + if (wind == slidewid) { + if (mask & Button1Mask) + newx = x - START; + else if (mask & Button2Mask) + newx = x + END - width; + else + newx = x - xm; + if (newx != xo) { + xo = newx; + XMoveWindow(dpy, slidewid, xo, SLIDETOP); + drawnums(); + } + } else if (wind == theWindow) { + if (mask & Button1Mask) { + newx = x; + if (newx != hx) { + hx = newx; + drawhairl(); + drawnums(); + } + } + } + break; + } + case ButtonRelease: + break; + case EnterNotify: + case LeaveNotify: { + XCrossingEvent *cross_event = (XCrossingEvent *) &event; + + if (event.type == EnterNotify) + XSetWindowBorder(dpy,theWindow,ForeColor); + else if ((cross_event->window == theWindow) && + (cross_event->detail != NotifyInferior)) { + /* XSetWindowBorderPixmap(dpy,theWindow,dimBorder);*/ + } + break; + } + case NoExpose: + break; + default: + /* printf("event type=%ld\n",(long)event.type); */ + /* XSRError("Unexpected X_Event"); */ + break; + + } /* end of switch */ + } /* end main loop */ + } + + + /***********************************/ + + static void + rescale(int w) + { + int x,y,wx,wy; + Window win; + int oldwidth, dummy; + + XGetGeometry(dpy, theWindow, &win, &wx, &wy, &oldwidth, &dummy, + &dummy, &dummy); + if (oldwidth != w) { + XQueryPointer(dpy, theWindow, &win, &win, &dummy, &dummy, &x, &y, + &dummy); + XMoveResizeWindow(dpy, theWindow, wx + x - (x * w)/oldwidth, wy, + w, HEIGHT); + } + hx = (hx * w) / width; + xo = (xo * w) / width; + width = w; + scalelen = width - START - END; + XResizeWindow(dpy, slidewid, width, SLIDEHIGH); + XResizeWindow(dpy, blackwid, width, SLIDEHIGH+2); + if (framePix) + XFreePixmap(dpy, framePix); + framePix = 0; + drawframe(); + if (slidePix) + XFreePixmap(dpy, slidePix); + slidePix = 0; + drawslide(); + XMoveWindow(dpy, slidewid, xo, SLIDETOP); + drawnums(); + drawhairl(); + } + + static void + drawmark(Window win, int x, int y, int height, int topp) + { + XDrawLine(dpy, win, sgc, x, (topp?y:y+MAJORH-height), + x, height + (topp?y:y+MAJORH-height)); + } + + static void + dolabel(Window win, int x, int y, char *str, int topp, int majorp) + { + XDrawString(dpy, win, sgc, x + 2, + (topp?y+FOFFSET+foffset:y+MAJORH-fheight+foffset), + str, strlen(str)); + } + + static void + drawframe(void) + { + int i,x,j; + char str[5]; + int midpt = scalelen/2; + + if (framePix == 0) + framePix = XCreatePixmap (dpy, theWindow, width, HEIGHT, + DefaultDepth (dpy, DefaultScreen (dpy))); + XFillRectangle(dpy, framePix, cgc, 0, 0, width, HEIGHT); + XDrawString(dpy, framePix, sgc, LABEL, LSCALEH+foffset, "L", 1); + for (i = 0; i <= 10; i++) { + sprintf(str, "%d", i); + x = START+(i*scalelen)/10; + dolabel(framePix, x, LSCALEH, str, 0, 1); + drawmark(framePix, x, LSCALEH, MAJORH, 0); + for (j = 1; j < 10; j++) + drawmark(framePix, x+(j*scalelen)/100, LSCALEH, (j==5?MIDDH:MINORH), + 0); + } + XDrawString(dpy, framePix, sgc, LABEL, ASCALEH+foffset, "A", 1); + doscale(framePix, ASCALEH, START, midpt, 0); + doscale(framePix, ASCALEH, START + midpt, scalelen - midpt, 0); + XDrawString(dpy, framePix, sgc, LABEL, DSCALEH+foffset, "D", 1); + doscale(framePix, DSCALEH, START, scalelen, 1); + XDrawString(dpy, framePix, sgc, LABEL, DISCALEH+foffset, "DI", 2); + for (i = 1; i <= 10; i++) { + x = START + scalelen * (1 - log10((float) i)) + 0.5; + sprintf(str, "%d", (i==10?1:i)); + dolabel(framePix, x, DISCALEH, str, 1, 1); + drawmark(framePix, x, DISCALEH, MAJORH, 1); + } + XCopyArea(dpy, framePix, theWindow, sgc, 0, 0, scalelen + START+END, HEIGHT, 0, 0); + } + + static void + doscale(Window win, int high, int offset, int len, int topp) + { + int i; + int xs[11]; + char str[6]; + + xs[0] = offset - 100; + for (i = 1; i <= 10; i++) + xs[i] = offset + len * log10((float) i) + 0.5; + + for (i = 1; i < 10; i++) { + if (xs[i] > xs[i-1] + LABELSPACE) { + sprintf(str, "%d", (i==10?1:i)); + dolabel(win, xs[i], high, str, topp, 1); + drawmark(win, xs[i], high, MAJORH, topp); + } else + drawmark(win, xs[i], high, MIDDH, topp); + + sprintf(str, "%d.", i); + dotenths(win, high, xs[i], xs[i+1]-xs[i], str, topp); + } + dolabel(win, xs[i], high, "1", topp, 1); + drawmark(win, xs[i], high, MAJORH, topp); + } + + static void + dotenths(Window win, int high, int offset, int len, char *str, int topp) + { + int i; + int xs[11]; + char nstr[8]; + + for (i = 0; i <= 10; i++ ) + xs[i] = offset + + len * log10((float) 1.0 + ((float) i) / 10.0) / logtenoftwo; + + if (len < HALVES) + return; + if (len < FIFTHS) { + drawmark(win, xs[5], high, MINORH, topp); + return; + } + if (len < TENTHS) { + for (i = 0; i < 10; i += 2) + drawmark(win, xs[i], high, MINORH, topp); + return; + } + if (len < LABELFIFTH) { + for (i = 0; i < 10; i++) { + drawmark(win, xs[i], high, (i==5?MIDDH:MINORH), topp); + dotenths(win, high, xs[i], xs[i+1]-xs[i], "", topp); + } + return; + } + if (len < LABELTENTHS) { + for (i = 0; i < 10; i++) { + if (i == 5) { + sprintf(nstr, "%s%d", str, 5); + dolabel(win, xs[i], high, nstr, topp, 0); + } + drawmark(win, xs[i], high, (i==5?MAJORH:MIDDH), topp); + dotenths(win, high, xs[i], xs[i+1]-xs[i], "", topp); + } + } else { + for (i = 0; i < 10; i++) { + sprintf(nstr, "%s%d", str, i); + if (i > 0) { + dolabel(win, xs[i], high, nstr, topp, 0); + drawmark(win, xs[i], high, MAJORH, topp); + } + dotenths(win, high, xs[i], xs[i+1]-xs[i], nstr, topp); + } + } + } + + + static void + drawslide(void) + { + int i,x; + char str[5]; + int midpt = scalelen/2; + + if (slidePix == 0) + slidePix = XCreatePixmap (dpy, theWindow, width, SLIDEHIGH, + DefaultDepth (dpy, DefaultScreen (dpy))); + XFillRectangle(dpy, slidePix, cgc, 0, 0, width, SLIDEHIGH); + XDrawString(dpy, slidePix, sgc, LABEL, BSCALEH+foffset, "B", 1); + doscale(slidePix, BSCALEH, START, midpt, 1); + doscale(slidePix, BSCALEH, START + midpt, scalelen - midpt, 1); + XDrawString(dpy, slidePix, sgc, LABEL, CISCALEH+foffset, "CI", 2); + for (i = 1; i <= 10; i++) { + x = START + scalelen * (1 - log10((float) i)) + 0.5; + sprintf(str, "%d", (i==10?1:i)); + dolabel(slidePix, x, CISCALEH, str, 1, 1); + drawmark(slidePix, x, CISCALEH, MAJORH, 1); + } + XDrawString(dpy, slidePix, sgc, LABEL, CSCALEH+foffset, "C", 1); + doscale(slidePix, CSCALEH, START, scalelen, 0); + XCopyArea(dpy, slidePix, slidewid, sgc, 0, 0, scalelen+START+END, SLIDEHIGH, 0, 0); + } + + static void + redrawslide(int x, int y, int w, int h) + { + if (slidePix != 0) + XCopyArea(dpy, slidePix, slidewid, sgc, 0, 0, scalelen + START + END, SLIDEHIGH, + 0, 0); + else + drawslide(); + } + + static void + redrawframe(int x, int y, int w, int h) + { + if (framePix != 0) + XCopyArea(dpy, framePix, theWindow, sgc, 0, 0, scalelen + START + END, HEIGHT, + 0, 0); + else + drawframe(); + } + + static void + drawhairl(void) + { + XMoveWindow(dpy, hairlwid, hx, 0); + XClearWindow(dpy, hairlwid); + } + + static void + drawnums(void) + { + char str[20]; /* leave room for sprintf to slop over */ + float x = ((float) (hx - START))/((float) scalelen); + float xs = ((float) (hx - START - xo))/((float) scalelen); + + XClearWindow(dpy, dispwid); + sprintf(str, "%5f", 10. * x); + XDrawImageString(dpy, dispwid, sgc, 5, LSCALEH+foffset, str, strlen(str)); + sprintf(str, "%5f", pow(100., x)); + XDrawImageString(dpy, dispwid, sgc, 5, ASCALEH+foffset, str, strlen(str)); + sprintf(str, "%5f", pow(100., xs)); + XDrawImageString(dpy, dispwid, sgc, 5, SLIDETOP+foffset + BSCALEH, str, strlen(str)); + sprintf(str, "%5f", pow(10., 1. - xs)); + XDrawImageString(dpy, dispwid, sgc, 5, SLIDETOP+foffset + CISCALEH, str, strlen(str)); + sprintf(str, "%5f", pow(10., xs)); + XDrawImageString(dpy, dispwid, sgc, 5, SLIDETOP+foffset + CSCALEH, str, strlen(str)); + sprintf(str, "%5f", pow(10., x)); + XDrawImageString(dpy, dispwid, sgc, 5, DSCALEH+foffset, str, strlen(str)); + sprintf(str, "%5f", pow(10., 1. - x)); + XDrawImageString(dpy, dispwid, sgc, 5, DISCALEH+foffset, str, strlen(str)); + } + + /* this is quite bogus */ + void + run_slide_rule (void) + { + int argc = 1; + char *argv[] = { "slide_rule", NULL }; + char *geom = ""; + int border = 5; + + if (fork () != 0) + return; + + dpy = XOpenDisplay (gdk_get_display ()); + if (dpy == NULL) + _exit (0); + + /*XSynchronize(dpy, True);*/ + do_sr(argc, argv, geom, border); + + /* FIXME: we never get here cuz the slide rule is a bit screwed */ + + XCloseDisplay (dpy); + + _exit (0); + + /*gtk_main ();*/ + } diff -crN ./gnome-utils/gdictsrc/dict.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gdictsrc/dict.c *** ./gnome-utils/gdictsrc/dict.c Mon May 19 20:46:00 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gdictsrc/dict.c Fri Nov 14 16:19:24 2003 *************** *** 1,4 **** ! /* $Id: dict.c,v 1.22 2003/05/19 19:46:00 merchan Exp $ */ /* -*- mode: c; style: k&r; c-basic-offset: 4 -*- */ /* --- 1,4 ---- ! /* $Id: dict.c,v 1.1.3.2 2003/11/14 15:19:21 vanderms Exp $ */ /* -*- mode: c; style: k&r; c-basic-offset: 4 -*- */ /* *************** *** 712,718 **** dict_context_do_dns_lookup (context); #ifdef ENABLE_IPV6 ! if (context->sockaddr.ss_family == AF_INET6) ((struct sockaddr_in6 *) &context->sockaddr)->sin6_port = htons ((port > 0) ? port : DICT_DEFAULT_PORT); else --- 712,718 ---- dict_context_do_dns_lookup (context); #ifdef ENABLE_IPV6 ! if (context->sockaddr.__ss_family == AF_INET6) ((struct sockaddr_in6 *) &context->sockaddr)->sin6_port = htons ((port > 0) ? port : DICT_DEFAULT_PORT); else *************** *** 779,785 **** if (context->channel) return 0; #ifdef ENABLE_IPV6 ! if (context->sockaddr.ss_family == AF_INET6) { if ((sock_fd = socket(AF_INET6, SOCK_STREAM, 0)) < 0) return -1; --- 779,785 ---- if (context->channel) return 0; #ifdef ENABLE_IPV6 ! if (context->sockaddr.__ss_family == AF_INET6) { if ((sock_fd = socket(AF_INET6, SOCK_STREAM, 0)) < 0) return -1; *************** *** 1155,1161 **** bcopy(&((struct sockaddr_in *) res->ai_addr)->sin_addr, &((struct sockaddr_in *) &context->sockaddr)->sin_addr, sizeof (struct in_addr)); } ! context->sockaddr.ss_family = res->ai_family; return 0; } } --- 1155,1161 ---- bcopy(&((struct sockaddr_in *) res->ai_addr)->sin_addr, &((struct sockaddr_in *) &context->sockaddr)->sin_addr, sizeof (struct in_addr)); } ! context->sockaddr.__ss_family = res->ai_family; return 0; } } diff -crN ./gnome-utils/gsearchtool/gsearchtool.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gsearchtool/gsearchtool.c *** ./gnome-utils/gsearchtool/gsearchtool.c Sat Aug 23 19:56:12 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-utils/gsearchtool/gsearchtool.c Thu Oct 16 14:23:58 2003 *************** *** 1131,1142 **** gchar *utf8 = NULL; gchar *filename = NULL; if (search_data->running != RUNNING) { ! break; } do { status = g_io_channel_read_line_string (ioc, string, NULL, &error); while (gtk_events_pending ()) { if (search_data->running == MAKE_IT_QUIT) { --- 1131,1151 ---- gchar *utf8 = NULL; gchar *filename = NULL; + if (search_data->running == MAKE_IT_STOP) { + g_string_free (string, TRUE); + goto broken_pipe; + } + if (search_data->running != RUNNING) { ! break; } do { status = g_io_channel_read_line_string (ioc, string, NULL, &error); + if (status == G_IO_STATUS_EOF) { + g_string_free (string, TRUE); + goto broken_pipe; + } while (gtk_events_pending ()) { if (search_data->running == MAKE_IT_QUIT) { *************** *** 1222,1227 **** --- 1231,1237 ---- gchar *title_bar_string = NULL; gchar *search_status = g_strdup (""); + broken_pipe: if (search_data->running == MAKE_IT_STOP) { search_status = g_strdup (_("(stopped)")); } *************** *** 1304,1309 **** --- 1314,1321 ---- do { status = g_io_channel_read_line_string (ioc, string, NULL, &error); + if (status == G_IO_STATUS_EOF) + goto broken_pipe; while (gtk_events_pending ()) { if (search_data->running == MAKE_IT_QUIT) { *************** *** 1340,1345 **** --- 1352,1358 ---- } if (condition != G_IO_IN) { + broken_pipe: if (error_msgs != NULL) {