diff -crN ./gnome-panel/applets/gen_util/GNOME_GenUtilApplet_Factory.server.in.in /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/applets/gen_util/GNOME_GenUtilApplet_Factory.server.in.in *** ./gnome-panel/applets/gen_util/GNOME_GenUtilApplet_Factory.server.in.in Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/applets/gen_util/GNOME_GenUtilApplet_Factory.server.in.in Tue Jul 8 11:46:51 2003 *************** *** 0 **** --- 1,95 ---- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff -crN ./gnome-panel/applets/gen_util/clock.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/applets/gen_util/clock.c *** ./gnome-panel/applets/gen_util/clock.c Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/applets/gen_util/clock.c Tue Jul 8 11:47:27 2003 *************** *** 0 **** --- 1,1232 ---- + /* + * GNOME time/date display module. + * (C) 1997 The Free Software Foundation + * + * Authors: George Lebl + * Gediminas Paulauskas + */ + + #include "config.h" + + #include + #include + #include + #include + #include + #include + #include + + #include + #include + + #include + #include + #include + #include + #include + + #include "clock.h" + + #include "egg-screen-help.h" + + #define INTERNETSECOND (864) + #define INTERNETBEAT (86400) + + #define N_GCONF_PREFS 6 + static const char* KEY_HOUR_FORMAT = "hour_format"; + static const char* KEY_SHOW_SECONDS = "show_seconds"; + static const char* KEY_SHOW_DATE = "show_date"; + static const char* KEY_GMT_TIME = "gmt_time"; + static const char* KEY_UNIX_TIME = "unix_time"; + static const char* KEY_INTERNET_TIME = "internet_time"; + + typedef struct _ClockData ClockData; + + struct _ClockData { + /* widgets */ + GtkWidget *applet; + GtkWidget *clockw; + GtkWidget *props; + + /* preferences */ + int hourformat; + gboolean showseconds; + gboolean showdate; + gboolean unixtime; + gboolean internettime; + gboolean gmt_time; + + /* runtime data */ + char *timeformat; + guint timeout; + int timeouttime; + PanelAppletOrient orient; + int size; + + guint listeners [N_GCONF_PREFS]; + }; + + static void update_clock (ClockData * cd, time_t current_time); + + static void set_atk_name_description (GtkWidget *widget, + const char *name, + const char *desc); + static void display_properties_dialog (BonoboUIComponent *uic, + ClockData *cd, + const gchar *verbname); + static void display_help_dialog (BonoboUIComponent *uic, + ClockData *cd, + const gchar *verbname); + static void display_about_dialog (BonoboUIComponent *uic, + ClockData *cd, + const gchar *verbname); + + static void + set_tooltip (GtkWidget *applet, + const char *tip) + { + GtkTooltips *tooltips; + + tooltips = g_object_get_data (G_OBJECT (applet), "tooltips"); + if (!tooltips) { + tooltips = gtk_tooltips_new (); + g_object_ref (tooltips); + gtk_object_sink (GTK_OBJECT (tooltips)); + g_object_set_data_full ( + G_OBJECT (applet), "tooltips", tooltips, + (GDestroyNotify) g_object_unref); + } + + gtk_tooltips_set_tip (tooltips, applet, tip, NULL); + } + + static int + clock_timeout_callback (gpointer data) + { + ClockData *cd = data; + time_t current_time; + + time (¤t_time); + + update_clock (cd, current_time); + + if (!cd->showseconds && !cd->unixtime) { + if (!cd->internettime) { + int sec = current_time % 60; + if (sec != 0 || cd->timeouttime != 60000) { + /* ensure next update is exactly on 0 seconds */ + cd->timeouttime = (60 - sec)*1000; + cd->timeout = g_timeout_add (cd->timeouttime, + clock_timeout_callback, + cd); + return FALSE; + } + } else { + struct tm *tm; + time_t bmt; + long isec; + + /* BMT (Biel Mean Time) is GMT+1 */ + bmt = current_time + 3600; + tm = gmtime (&bmt); + isec = ((tm->tm_hour*3600 + tm->tm_min*60 + tm->tm_sec)*10) % 864; + + if (isec != 0 || cd->timeouttime != INTERNETBEAT) { + /* ensure next update is exactly on beat limit */ + cd->timeouttime = (864 - isec)*100; + cd->timeout = g_timeout_add (cd->timeouttime, + clock_timeout_callback, + cd); + return FALSE; + } + } + } + + return TRUE; + } + + static float + get_itime (time_t current_time) + { + struct tm *tm; + float itime; + time_t bmt; + + /* BMT (Biel Mean Time) is GMT+1 */ + bmt = current_time + 3600; + tm = gmtime (&bmt); + itime = (tm->tm_hour*3600.0 + tm->tm_min*60.0 + tm->tm_sec)/86.4; + + return itime; + } + + static void + update_timeformat (ClockData *cd) + { + /* Show date in another line if panel is vertical, or + * horizontal but large enough to hold two lines of text + */ + #define USE_TWO_LINE_FORMAT(cd) ((cd)->orient == PANEL_APPLET_ORIENT_LEFT || \ + (cd)->orient == PANEL_APPLET_ORIENT_RIGHT || \ + (cd)->size >= GNOME_Vertigo_PANEL_MEDIUM) + + const char *time_format; + const char *date_format; + char *clock_format; + + if (cd->hourformat == 12) + time_format = cd->showseconds ? _("%l:%M:%S %p") : _("%l:%M %p"); + else + time_format = cd->showseconds ? _("%H:%M:%S") : _("%H:%M"); + + if (!cd->showdate) + clock_format = g_strdup (time_format); + + else { + date_format = _("%a %b %d"); + + if (USE_TWO_LINE_FORMAT (cd)) + /* translators: reverse the order of these arguments + * if the time should come before the + * date on a clock in your locale. + */ + clock_format = g_strdup_printf (_("%s\n%s"), + date_format, time_format); + else + /* translators: reverse the order of these arguments + * if the time should come before the + * date on a clock in your locale. + */ + clock_format = g_strdup_printf (_("%s, %s"), + date_format, time_format); + } + + g_free (cd->timeformat); + cd->timeformat = g_locale_from_utf8 (clock_format, -1, NULL, NULL, NULL); + g_free (clock_format); + + #undef USE_TWO_LINE_FORMAT + } + + /* sets accessible name and description for the widget */ + static void + set_atk_name_description (GtkWidget *widget, + const char *name, + const char *desc) + { + AtkObject *obj; + obj = gtk_widget_get_accessible (widget); + + /* return if gail is not loaded */ + if (!GTK_IS_ACCESSIBLE (obj)) + return; + + if (desc != NULL) + atk_object_set_description (obj, desc); + if (name != NULL) + atk_object_set_name (obj, name); + } + + /* sets up ATK relation between the widgets */ + static void + add_atk_relation (GtkWidget *widget, + GSList *list, + AtkRelationType type) + { + AtkRelationSet *relation_set; + AtkObject *aobj; + + aobj = gtk_widget_get_accessible (widget); + if (!GTK_IS_ACCESSIBLE (aobj)) + return; + + relation_set = atk_object_ref_relation_set (aobj); + + if (list) { + AtkObject **accessible_array; + AtkRelation *relation; + GSList *l; + guint len; + int i = 0; + + len = g_slist_length (list); + accessible_array = + (AtkObject **)g_malloc (sizeof (AtkObject *) * len); + + for (l = list, i = 0; l; l = l->next, i++) + accessible_array [i] = gtk_widget_get_accessible (l->data); + + relation = atk_relation_new (accessible_array, len, type); + atk_relation_set_add (relation_set, relation); + g_object_unref (relation); + } + } + + static void + update_clock (ClockData * cd, time_t current_time) + { + struct tm *tm; + char date[256], hour[256]; + char *utf8, *loc; + GtkTooltips *tooltips; + + if (cd->gmt_time) + tm = gmtime (¤t_time); + else + tm = localtime (¤t_time); + + if (cd->unixtime) { + if ((cd->orient == PANEL_APPLET_ORIENT_LEFT || + cd->orient == PANEL_APPLET_ORIENT_RIGHT) && + cd->size >= GNOME_Vertigo_PANEL_MEDIUM) { + g_snprintf (hour, sizeof(hour), "%lu\n%05lu", + (unsigned long)(current_time / 100000L), + (unsigned long)(current_time % 100000L)); + } else { + g_snprintf (hour, sizeof(hour), "%lu", (unsigned long)current_time); + } + } else if (cd->internettime) { + float itime = get_itime (current_time); + if (cd->showseconds) + g_snprintf (hour, sizeof (hour), "@%3.2f", itime); + else + g_snprintf (hour, sizeof (hour), "@%3.0f", itime); + } else { + if (strftime (hour, sizeof (hour), cd->timeformat, tm) <= 0) + strcpy (hour, "???"); + } + + utf8 = g_locale_to_utf8 (hour, -1, NULL, NULL, NULL); + gtk_label_set_text (GTK_LABEL (cd->clockw), utf8); + g_free (utf8); + + /* Show date in tooltip */ + loc = g_locale_from_utf8 (_("%A %B %d"), -1, NULL, NULL, NULL); + if (strftime (date, sizeof (date), loc, tm) <= 0) + strcpy (date, "???"); + g_free (loc); + + tooltips = gtk_tooltips_new (); + g_object_ref (tooltips); + gtk_object_sink (GTK_OBJECT (tooltips)); + g_object_set_data_full (G_OBJECT (cd->applet), "tooltips", tooltips, + (GDestroyNotify) g_object_unref); + + utf8 = g_locale_to_utf8 (date, -1, NULL, NULL, NULL); + set_tooltip (GTK_WIDGET (cd->applet), utf8); + g_free (utf8); + } + + static void + refresh_clock (ClockData *cd) + { + time_t current_time; + + time (¤t_time); + update_clock (cd, current_time); + } + + static void + refresh_clock_timeout(ClockData *cd) + { + time_t current_time; + + update_timeformat (cd); + + if (cd->timeout) + g_source_remove (cd->timeout); + + time (¤t_time); + update_clock (cd, current_time); + + if (cd->internettime) { + if (cd->showseconds) + cd->timeouttime = INTERNETSECOND; + else { + struct tm *tm; + time_t bmt; + long isec; + + /* BMT (Biel Mean Time) is GMT+1 */ + bmt = current_time + 3600; + tm = gmtime (&bmt); + isec = ((tm->tm_hour*3600 + tm->tm_min*60 + tm->tm_sec)*10) % 864; + cd->timeouttime = (864 - isec)*100; + } + } + else if(cd->unixtime || cd->showseconds) + cd->timeouttime = 1000; + else + cd->timeouttime = (60 - current_time % 60)*1000; + + cd->timeout = g_timeout_add (cd->timeouttime, + clock_timeout_callback, + cd); + } + + static void + destroy_clock(GtkWidget * widget, ClockData *cd) + { + GConfClient *client; + int i; + + client = gconf_client_get_default (); + + for (i = 0; i < N_GCONF_PREFS; i++) + gconf_client_notify_remove ( + client, cd->listeners [i]); + + if (cd->timeout > 0) { + g_source_remove (cd->timeout); + cd->timeout = 0; + } + + if (cd->props) { + gtk_widget_destroy (cd->props); + cd->props = NULL; + } + + g_free (cd->timeformat); + + g_free (cd); + } + + static void + create_clock_widget (ClockData *cd) + { + GtkWidget *clock; + + clock = gtk_label_new ("hmm?"); + gtk_label_set_justify (GTK_LABEL (clock), GTK_JUSTIFY_CENTER); + gtk_label_set_line_wrap (GTK_LABEL (clock), TRUE); + gtk_widget_show (clock); + + cd->clockw = clock; + + cd->props = NULL; + + cd->orient = panel_applet_get_orient (PANEL_APPLET (cd->applet)); + cd->size = panel_applet_get_size (PANEL_APPLET (cd->applet)); + + g_signal_connect (G_OBJECT(clock), "destroy", + G_CALLBACK (destroy_clock), + cd); + + set_atk_name_description (GTK_WIDGET (cd->applet), NULL, + _("Computer Clock")); + + /* Refresh the clock so that it paints its first state */ + refresh_clock_timeout(cd); + } + + /* this is when the panel orientation changes */ + + static void + applet_change_orient (PanelApplet *applet, + PanelAppletOrient orient, + ClockData *cd) + { + time_t current_time; + + time (¤t_time); + cd->orient = orient; + update_clock (cd, current_time); + } + + static void + applet_change_background (PanelApplet *applet, + PanelAppletBackgroundType type, + GdkColor *color, + GdkPixmap *pixmap, + ClockData *cd) + { + if (type == PANEL_NO_BACKGROUND) { + GtkRcStyle *rc_style; + + rc_style = gtk_rc_style_new (); + + gtk_widget_modify_style (cd->applet, rc_style); + + g_object_unref (rc_style); + + } else if (type == PANEL_COLOR_BACKGROUND) + gtk_widget_modify_bg (cd->applet, GTK_STATE_NORMAL, color); + + /* else if (type == PANEL_PIXMAP_BACKGROUND) + * FIXME: Handle this when the panel support works again + */ + } + + + /* this is when the panel size changes */ + static void + applet_change_pixel_size (PanelApplet *applet, + gint size, + ClockData *cd) + { + time_t current_time; + + time (¤t_time); + cd->size = size; + + update_timeformat (cd); + update_clock (cd, current_time); + } + + + static void + copy_time (BonoboUIComponent *uic, + ClockData *cd, + const gchar *verbname) + { + time_t current_time = time (NULL); + char string[256]; + char *utf8; + + if (cd->unixtime) { + g_snprintf (string, sizeof(string), "%lu", + (unsigned long)current_time); + } else if (cd->internettime) { + float itime = get_itime (current_time); + if (cd->showseconds) + g_snprintf (string, sizeof (string), "@%3.2f", itime); + else + g_snprintf (string, sizeof (string), "@%3.0f", itime); + } else { + struct tm *tm; + char *format; + + if (cd->hourformat == 12) { + if (cd->showseconds) + format = g_locale_from_utf8 (_("%I:%M:%S %p"), -1, NULL, NULL, NULL); + else + format = g_locale_from_utf8 (_("%I:%M %p"), -1, NULL, NULL, NULL); + } else { + if (cd->showseconds) + format = g_locale_from_utf8 (_("%H:%M:%S"), -1, NULL, NULL, NULL); + else + format = g_locale_from_utf8 (_("%H:%M"), -1, NULL, NULL, NULL); + } + + if (cd->gmt_time) + tm = gmtime (¤t_time); + else + tm = localtime (¤t_time); + + if (strftime (string, sizeof (string), format, tm) <= 0) + strcpy (string, "???"); + g_free (format); + } + + utf8 = g_locale_to_utf8 (string, -1, NULL, NULL, NULL); + gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), + utf8, -1); + g_free (utf8); + } + + static void + copy_date (BonoboUIComponent *uic, + ClockData *cd, + const gchar *verbname) + { + time_t current_time = time (NULL); + struct tm *tm; + char string[256]; + char *utf8, *loc; + + if (cd->gmt_time) + tm = gmtime (¤t_time); + else + tm = localtime (¤t_time); + + loc = g_locale_from_utf8 (_("%A, %B %d %Y"), -1, NULL, NULL, NULL); + if (strftime (string, sizeof (string), loc, tm) <= 0) + strcpy (string, "???"); + g_free (loc); + + utf8 = g_locale_to_utf8 (string, -1, NULL, NULL, NULL); + gtk_clipboard_set_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), + utf8, -1); + g_free (utf8); + } + + /* current timestamp */ + static const BonoboUIVerb clock_menu_verbs [] = { + BONOBO_UI_UNSAFE_VERB ("ClockPreferences", display_properties_dialog), + BONOBO_UI_UNSAFE_VERB ("ClockHelp", display_help_dialog), + BONOBO_UI_UNSAFE_VERB ("ClockAbout", display_about_dialog), + BONOBO_UI_UNSAFE_VERB ("ClockCopyTime", copy_time), + BONOBO_UI_UNSAFE_VERB ("ClockCopyDate", copy_date), + BONOBO_UI_VERB_END + }; + + static void + hour_format_changed (GConfClient *client, + guint cnxn_id, + GConfEntry *entry, + ClockData *clock) + { + int value; + + if (!entry->value || entry->value->type != GCONF_VALUE_INT) + return; + + value = gconf_value_get_int (entry->value); + + if (value == 12 || value == 24) + clock->hourformat = value; + else + clock->hourformat = 12; + + update_timeformat (clock); + refresh_clock (clock); + } + + static void + show_seconds_changed (GConfClient *client, + guint cnxn_id, + GConfEntry *entry, + ClockData *clock) + { + gboolean value; + + if (!entry->value || entry->value->type != GCONF_VALUE_BOOL) + return; + + value = gconf_value_get_bool (entry->value); + + clock->showseconds = (value != 0); + refresh_clock_timeout (clock); + } + + static void + show_date_changed (GConfClient *client, + guint cnxn_id, + GConfEntry *entry, + ClockData *clock) + { + gboolean value; + + if (!entry->value || entry->value->type != GCONF_VALUE_BOOL) + return; + + value = gconf_value_get_bool (entry->value); + + clock->showdate = (value != 0); + update_timeformat (clock); + refresh_clock (clock); + } + + static void + internet_time_changed (GConfClient *client, + guint cnxn_id, + GConfEntry *entry, + ClockData *clock) + { + gboolean value; + + if (!entry->value || entry->value->type != GCONF_VALUE_BOOL) + return; + + value = gconf_value_get_bool (entry->value); + + clock->internettime = (value != 0); + refresh_clock_timeout (clock); + } + + static void + unix_time_changed (GConfClient *client, + guint cnxn_id, + GConfEntry *entry, + ClockData *clock) + { + gboolean value; + + if (!entry->value || entry->value->type != GCONF_VALUE_BOOL) + return; + + value = gconf_value_get_bool (entry->value); + + clock->unixtime = (value != 0); + refresh_clock_timeout (clock); + } + + static void + gmt_time_changed (GConfClient *client, + guint cnxn_id, + GConfEntry *entry, + ClockData *clock) + { + gboolean value; + + if (!entry->value || entry->value->type != GCONF_VALUE_BOOL) + return; + + value = gconf_value_get_bool (entry->value); + + clock->gmt_time = (value != 0); + refresh_clock_timeout (clock); + } + + static void + setup_gconf (ClockData *clock) + { + GConfClient *client; + char *key; + + client = gconf_client_get_default (); + + key = panel_applet_gconf_get_full_key (PANEL_APPLET (clock->applet), + KEY_HOUR_FORMAT); + clock->listeners [0] = + gconf_client_notify_add ( + client, key, + (GConfClientNotifyFunc) hour_format_changed, + clock, NULL, NULL); + g_free (key); + + key = panel_applet_gconf_get_full_key (PANEL_APPLET (clock->applet), + KEY_SHOW_SECONDS); + clock->listeners [1] = + gconf_client_notify_add ( + client, key, + (GConfClientNotifyFunc)show_seconds_changed, + clock, NULL, NULL); + g_free (key); + + key = panel_applet_gconf_get_full_key (PANEL_APPLET (clock->applet), + KEY_SHOW_DATE); + clock->listeners [2] = + gconf_client_notify_add ( + client, key, + (GConfClientNotifyFunc) show_date_changed, + clock, NULL, NULL); + g_free (key); + + key = panel_applet_gconf_get_full_key (PANEL_APPLET (clock->applet), + KEY_GMT_TIME); + clock->listeners [3] = + gconf_client_notify_add ( + client, key, + (GConfClientNotifyFunc) gmt_time_changed, + clock, NULL, NULL); + g_free (key); + + key = panel_applet_gconf_get_full_key (PANEL_APPLET (clock->applet), + KEY_UNIX_TIME); + clock->listeners [4] = + gconf_client_notify_add ( + client, key, + (GConfClientNotifyFunc)unix_time_changed, + clock, NULL, NULL); + g_free (key); + + key = panel_applet_gconf_get_full_key (PANEL_APPLET (clock->applet), + KEY_INTERNET_TIME); + clock->listeners [5] = + gconf_client_notify_add ( + client, key, + (GConfClientNotifyFunc)internet_time_changed, + clock, NULL, NULL); + g_free (key); + } + + gboolean + fill_clock_applet(PanelApplet *applet) + { + ClockData *cd; + GError *error; + + panel_applet_add_preferences (applet, "/schemas/apps/clock_applet/prefs", NULL); + + cd = g_new0 (ClockData, 1); + + cd->applet = GTK_WIDGET (applet); + + setup_gconf (cd); + + error = NULL; + cd->hourformat = panel_applet_gconf_get_int (applet, KEY_HOUR_FORMAT, &error); + if (error || (cd->hourformat != 12 && cd->hourformat != 24)) { + /* if value is not valid, set it according to locale */ + const char *am = nl_langinfo (AM_STR); + cd->hourformat = (am[0] == '\0') ? 24 : 12; + + if (error) + g_error_free (error); + } + + cd->showseconds = panel_applet_gconf_get_bool (applet, KEY_SHOW_SECONDS, NULL); + + error = NULL; + cd->showdate = panel_applet_gconf_get_bool (applet, KEY_SHOW_DATE, &error); + if (error) { + g_error_free (error); + /* if on a small screen don't show data by default */ + if (gdk_screen_width () <= 800) + cd->showdate = FALSE; + else + cd->showdate = TRUE; + } + + cd->gmt_time = panel_applet_gconf_get_bool (applet, KEY_GMT_TIME, NULL); + cd->unixtime = panel_applet_gconf_get_bool (applet, KEY_UNIX_TIME, NULL); + cd->internettime = panel_applet_gconf_get_bool (applet, KEY_INTERNET_TIME, NULL); + + cd->timeformat = NULL; + + create_clock_widget (cd); + + gtk_container_set_border_width (GTK_CONTAINER (cd->applet), 0); + gtk_container_add (GTK_CONTAINER (cd->applet), cd->clockw); + + gtk_widget_show (cd->applet); + + /* FIXME: Update this comment. */ + /* we have to bind change_orient before we do applet_widget_add + since we need to get an initial change_orient signal to set our + initial oriantation, and we get that during the _add call */ + g_signal_connect (G_OBJECT (cd->applet), + "change_orient", + G_CALLBACK (applet_change_orient), + cd); + + /* similiar to the above in semantics*/ + g_signal_connect (G_OBJECT (cd->applet), + "change_size", + G_CALLBACK (applet_change_pixel_size), + cd); + + /* FIXME: initial background, this needs some panel-applet voodoo */ + g_signal_connect (G_OBJECT (cd->applet), + "change_background", + G_CALLBACK (applet_change_background), + cd); + + panel_applet_setup_menu_from_file (PANEL_APPLET (cd->applet), + NULL, + "GNOME_ClockApplet.xml", + NULL, + clock_menu_verbs, + cd); + + return TRUE; + } + + static void + set_datasensitive_cb (GtkWidget *w, + GtkWidget *wid) + { + gtk_widget_set_sensitive (wid, !(GTK_TOGGLE_BUTTON (w)->active)); + } + + static void + set_hour_format_cb (GtkWidget *w, + gpointer data) + { + if (GTK_TOGGLE_BUTTON (w)->active) { + ClockData *clock = g_object_get_data (G_OBJECT (w), "user_data"); + panel_applet_gconf_set_int (PANEL_APPLET (clock->applet), + KEY_HOUR_FORMAT, + GPOINTER_TO_INT (data), + NULL); + } + } + + static void + set_show_seconds_cb (GtkWidget *w, + ClockData *clock) + { + panel_applet_gconf_set_bool (PANEL_APPLET (clock->applet), + KEY_SHOW_SECONDS, + GTK_TOGGLE_BUTTON (w)->active, + NULL); + } + + static void + set_show_date_cb (GtkWidget *w, + ClockData *clock) + { + panel_applet_gconf_set_bool (PANEL_APPLET (clock->applet), + KEY_SHOW_DATE, + GTK_TOGGLE_BUTTON (w)->active, + NULL); + } + + static void + set_internettime_cb (GtkWidget *w, + ClockData *clock) + { + panel_applet_gconf_set_bool (PANEL_APPLET (clock->applet), + KEY_INTERNET_TIME, + GTK_TOGGLE_BUTTON (w)->active, + NULL); + } + + static void + set_unixtime_cb (GtkWidget *w, + ClockData *clock) + { + panel_applet_gconf_set_bool (PANEL_APPLET (clock->applet), + KEY_UNIX_TIME, + GTK_TOGGLE_BUTTON (w)->active, + NULL); + } + + static void + set_gmt_time_cb (GtkWidget *w, + ClockData *clock) + { + panel_applet_gconf_set_bool (PANEL_APPLET (clock->applet), + KEY_GMT_TIME, + GTK_TOGGLE_BUTTON (w)->active, + NULL); + } + + static void + properties_response_cb (GtkWidget *widget, + int id, + ClockData *cd) + { + + if (id == GTK_RESPONSE_HELP) { + static GnomeProgram *applet_program = NULL; + GError *error = NULL; + + if (!applet_program) { + int argc = 1; + char *argv[2] = { "clock" }; + applet_program = gnome_program_init ("clock", VERSION, + LIBGNOME_MODULE, argc, argv, + GNOME_PROGRAM_STANDARD_PROPERTIES, NULL); + } + + egg_help_display_desktop_on_screen ( + applet_program, "clock", + "clock", "clock-settings", + gtk_widget_get_screen (cd->applet), + &error); + + if (error) { + GtkWidget *dialog; + dialog = gtk_message_dialog_new (GTK_WINDOW (widget), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("There was an error displaying help: %s"), + error->message); + + g_signal_connect (G_OBJECT (dialog), "response", + G_CALLBACK (gtk_widget_destroy), + NULL); + + gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); + gtk_window_set_screen (GTK_WINDOW (dialog), + gtk_widget_get_screen (cd->applet)); + gtk_widget_show (dialog); + g_error_free (error); + } + + } else { + gtk_widget_destroy (widget); + } + + return; + } + + static void + display_properties_dialog (BonoboUIComponent *uic, + ClockData *cd, + const gchar *verbname) + { + GtkWidget *hbox; + GtkWidget *hour_frame; + GtkWidget *type_box; + GtkWidget *options_frame; + GtkWidget *vbox; + GtkWidget *twelvehour; + GtkWidget *twentyfourhour; + GtkWidget *showseconds; + GtkWidget *showdate; + GtkWidget *unixtime; + GtkWidget *internettime; + GtkWidget *use_gmt_time; + GSList *list; + char *file; + + if (cd->props) { + gtk_window_set_screen (GTK_WINDOW (cd->props), + gtk_widget_get_screen (cd->applet)); + gtk_window_present (GTK_WINDOW (cd->props)); + return; + } + + cd->props = gtk_dialog_new_with_buttons (_("Clock Preferences"), NULL, 0, + GTK_STOCK_HELP, + GTK_RESPONSE_HELP, + GTK_STOCK_CLOSE, + GTK_RESPONSE_CLOSE, + NULL); + + gtk_dialog_set_has_separator (GTK_DIALOG (cd->props), FALSE); + gtk_dialog_set_default_response (GTK_DIALOG (cd->props), GTK_RESPONSE_CLOSE); + gtk_window_set_screen (GTK_WINDOW (cd->props), + gtk_widget_get_screen (cd->applet)); + + file = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_PIXMAP, + "gnome-clock.png", TRUE, NULL); + if (file) { + GdkPixbuf *pixbuf; + pixbuf = gdk_pixbuf_new_from_file (file, NULL); + gtk_window_set_icon (GTK_WINDOW (cd->props), pixbuf); + g_object_unref (pixbuf); + g_free (file); + } + else + g_warning (G_STRLOC ": gnome-clock.png cannot be found"); + + hbox = gtk_hbox_new (FALSE, 3); + gtk_widget_show (hbox); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (cd->props)->vbox), hbox, FALSE, FALSE, 0); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 3); + + hour_frame = gtk_frame_new (_("Clock type")); + gtk_box_pack_start (GTK_BOX (hbox), hour_frame, FALSE, FALSE, 0); + gtk_widget_show (hour_frame); + gtk_container_set_border_width (GTK_CONTAINER (hour_frame), 3); + + type_box = gtk_vbox_new (FALSE, 3); + gtk_container_add (GTK_CONTAINER (hour_frame), type_box); + gtk_widget_show (type_box); + gtk_container_set_border_width (GTK_CONTAINER (type_box), 3); + + twelvehour = gtk_radio_button_new_with_mnemonic (NULL, _("_12 hour")); + gtk_box_pack_start (GTK_BOX (type_box), twelvehour, FALSE, FALSE, 0); + gtk_widget_show (twelvehour); + g_object_set_data (G_OBJECT (twelvehour), "user_data", cd); + + twentyfourhour = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (twelvehour)), + _("_24 hour")); + gtk_box_pack_start (GTK_BOX (type_box), twentyfourhour, FALSE, FALSE, 0); + gtk_widget_show (twentyfourhour); + g_object_set_data (G_OBJECT (twentyfourhour), "user_data", cd); + + unixtime = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (twelvehour)), _("UNI_X time")); + gtk_box_pack_start (GTK_BOX (type_box), unixtime, FALSE, FALSE, 0); + gtk_widget_show (unixtime); + + internettime = gtk_radio_button_new_with_mnemonic (gtk_radio_button_get_group (GTK_RADIO_BUTTON (twelvehour)), _("_Internet time")); + gtk_box_pack_start (GTK_BOX (type_box), internettime, FALSE, FALSE, 0); + gtk_widget_show (internettime); + + if (cd->unixtime) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (unixtime), TRUE); + else if (cd->internettime) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (internettime), TRUE); + else if (cd->hourformat == 12) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (twelvehour), TRUE); + else if (cd->hourformat == 24) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (twentyfourhour), TRUE); + + g_signal_connect (G_OBJECT (unixtime), "toggled", + G_CALLBACK (set_unixtime_cb), + cd); + g_signal_connect (G_OBJECT (internettime), "toggled", + G_CALLBACK (set_internettime_cb), + cd); + g_signal_connect (G_OBJECT (twelvehour), "toggled", + G_CALLBACK (set_hour_format_cb), + GINT_TO_POINTER (12)); + g_signal_connect (G_OBJECT (twentyfourhour), "toggled", + G_CALLBACK (set_hour_format_cb), + GINT_TO_POINTER (24)); + + options_frame = gtk_frame_new (""); + gtk_box_pack_start (GTK_BOX (hbox), options_frame, FALSE, FALSE, 0); + gtk_widget_show (options_frame); + gtk_container_set_border_width (GTK_CONTAINER (options_frame), 3); + gtk_frame_set_shadow_type (GTK_FRAME (options_frame), GTK_SHADOW_NONE); + + vbox = gtk_vbox_new (FALSE, 3); + gtk_container_add (GTK_CONTAINER (options_frame), vbox); + gtk_widget_show (vbox); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 3); + + showseconds = gtk_check_button_new_with_mnemonic (_("Show _seconds")); + gtk_box_pack_start (GTK_BOX (vbox), showseconds, FALSE, FALSE, 0); + gtk_widget_show (showseconds); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (showseconds), + cd->showseconds); + g_signal_connect (G_OBJECT (showseconds), "toggled", + G_CALLBACK (set_show_seconds_cb), + cd); + + showdate = gtk_check_button_new_with_mnemonic (_("Show _date")); + gtk_box_pack_start (GTK_BOX (vbox), showdate, FALSE, FALSE, 0); + gtk_widget_show (showdate); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (showdate), + cd->showdate); + g_signal_connect (G_OBJECT (showdate), "toggled", + G_CALLBACK (set_show_date_cb), + cd); + + use_gmt_time = gtk_check_button_new_with_mnemonic (_("Use _UTC")); + gtk_box_pack_start (GTK_BOX (vbox), use_gmt_time, FALSE, FALSE, 0); + gtk_widget_show (use_gmt_time); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (use_gmt_time), + cd->gmt_time); + g_signal_connect (G_OBJECT (use_gmt_time), "toggled", + G_CALLBACK (set_gmt_time_cb), + cd); + + /* Some combinations of options do not make sense */ + if (cd->unixtime) { + gtk_widget_set_sensitive (showseconds, FALSE); + gtk_widget_set_sensitive (showdate, FALSE); + gtk_widget_set_sensitive (use_gmt_time, FALSE); + } + if (cd->internettime) { + gtk_widget_set_sensitive (showdate, FALSE); + gtk_widget_set_sensitive (use_gmt_time, FALSE); + } + g_signal_connect (G_OBJECT (unixtime), "toggled", + G_CALLBACK (set_datasensitive_cb), + showseconds); + g_signal_connect (G_OBJECT (unixtime), "toggled", + G_CALLBACK (set_datasensitive_cb), + showdate); + g_signal_connect (G_OBJECT (unixtime), "toggled", + G_CALLBACK (set_datasensitive_cb), + use_gmt_time); + g_signal_connect (G_OBJECT (internettime), "toggled", + G_CALLBACK (set_datasensitive_cb), + showdate); + g_signal_connect (G_OBJECT (internettime), "toggled", + G_CALLBACK (set_datasensitive_cb), + use_gmt_time); + + g_signal_connect (G_OBJECT (cd->props), "destroy", + G_CALLBACK (gtk_widget_destroyed), &(cd->props)); + g_signal_connect (G_OBJECT (cd->props), "response", + G_CALLBACK (properties_response_cb), cd); + + /* sets up atk relation */ + list = g_slist_append (NULL, twelvehour); + list = g_slist_append (list, twentyfourhour); + add_atk_relation (use_gmt_time, list, ATK_RELATION_CONTROLLED_BY); + g_slist_free (list); + + list = g_slist_append (NULL, use_gmt_time); + add_atk_relation (twelvehour, list, ATK_RELATION_CONTROLLER_FOR); + add_atk_relation (twentyfourhour, list, ATK_RELATION_CONTROLLER_FOR); + g_slist_free (list); + + gtk_widget_show (cd->props); + } + + static void + display_help_dialog (BonoboUIComponent *uic, + ClockData *cd, + const gchar *verbname) + { + GError *error = NULL; + static GnomeProgram *applet_program = NULL; + + if (!applet_program) { + int argc = 1; + char *argv[2] = { "clock" }; + applet_program = gnome_program_init ("clock", VERSION, + LIBGNOME_MODULE, argc, argv, + GNOME_PROGRAM_STANDARD_PROPERTIES, NULL); + } + + egg_help_display_desktop_on_screen ( + applet_program, "clock", "clock",NULL, + gtk_widget_get_screen (cd->applet), + &error); + if (error) { + GtkWidget *dialog; + dialog = gtk_message_dialog_new (NULL, + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("There was an error displaying help: %s"), + error->message); + + g_signal_connect (G_OBJECT (dialog), "response", + G_CALLBACK (gtk_widget_destroy), + NULL); + + gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); + gtk_window_set_screen (GTK_WINDOW (dialog), + gtk_widget_get_screen (cd->applet)); + gtk_widget_show (dialog); + g_error_free (error); + } + } + + static void + display_about_dialog (BonoboUIComponent *uic, + ClockData *cd, + const gchar *verbname) + { + static GtkWidget *about = NULL; + GdkPixbuf *pixbuf = NULL; + gchar *file; + + static const gchar *authors[] = + { + "George Lebl ", + "Gediminas Paulauskas ", + NULL + }; + static const char *documenters[] = + { + "Dan Mueth (d-mueth@uchicago.edu)", + NULL + }; + /* Translator credits */ + const char *translator_credits = _("translator_credits"); + + if (about) { + gtk_window_set_screen (GTK_WINDOW (about), + gtk_widget_get_screen (cd->applet)); + gtk_window_present (GTK_WINDOW (about)); + return; + } + + pixbuf = NULL; + + file = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_PIXMAP, + "gnome-clock.png", TRUE, NULL); + if (file) { + pixbuf = gdk_pixbuf_new_from_file (file, NULL); + g_free (file); + } else + g_warning (G_STRLOC ": gnome-clock.png cannot be found"); + + about = gnome_about_new (_("Clock"), VERSION, + "Copyright \xc2\xa9 1998-2002 Free Software Foundation. Inc.", + _("The Clock displays the current time and date"), + authors, + documenters, + strcmp (translator_credits, "translator_credits") != 0 ? translator_credits : NULL, + pixbuf); + + gtk_window_set_wmclass (GTK_WINDOW (about), "clock", "Clock"); + gtk_window_set_screen (GTK_WINDOW (about), + gtk_widget_get_screen (cd->applet)); + + if (pixbuf) { + gtk_window_set_icon (GTK_WINDOW (about), pixbuf); + g_object_unref (pixbuf); + } + + g_signal_connect (G_OBJECT(about), "destroy", + (GCallback)gtk_widget_destroyed, &about); + + gtk_widget_show (about); + } diff -crN ./gnome-panel/applets/gen_util/mailcheck.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/applets/gen_util/mailcheck.c *** ./gnome-panel/applets/gen_util/mailcheck.c Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/applets/gen_util/mailcheck.c Tue Jul 8 11:48:03 2003 *************** *** 0 **** --- 1,2002 ---- + /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ + /* GNOME panel mail check module. + * (C) 1997, 1998, 1999, 2000 The Free Software Foundation + * (C) 2001 Eazel, Inc. + * + * Authors: Miguel de Icaza + * Jacob Berkman + * Jaka Mocnik + * Lennart Poettering + * George Lebl + * + */ + + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + + #include "popcheck.h" + #include "remote-helper.h" + #include "mailcheck.h" + + #include "egg-screen-help.h" + #include "egg-screen-exec.h" + + typedef enum { + MAILBOX_LOCAL, + MAILBOX_LOCALDIR, + MAILBOX_POP3, + MAILBOX_IMAP + } MailboxType; + + /* static GtkTooltips *tooltips;*/ + + typedef struct _MailCheck MailCheck; + struct _MailCheck { + char *mail_file; + + /* Does the user have any mail at all? */ + gboolean anymail; + + /* whether new mail has arrived */ + gboolean newmail; + + /* number of unread/total mails */ + int unreadmail; + int totalmail; + + /* whether to automatically check for mails */ + gboolean auto_update; + + /* interval to check for mails in milliseconds */ + guint update_freq; + + /* whether to set mc->newmail and mc->unreadmail to 0 if the applet was clicked */ + gboolean reset_on_clicked; + + /* execute a command when the applet is clicked (launch email prog) */ + char *clicked_cmd; + gboolean clicked_enabled; + + /* execute a command when new mail arrives (play a sound etc.) */ + char *newmail_cmd; + gboolean newmail_enabled; + + /* execute a command before checking email (fetchmail etc.) */ + char *pre_check_cmd; + gboolean pre_check_enabled; + + PanelApplet *applet; + /* This is the event box for catching events */ + GtkWidget *ebox; + + /* This holds either the drawing area or the label */ + GtkWidget *bin; + + /* The widget that holds the label with the mail information */ + GtkWidget *label; + + /* Points to whatever we have inside the bin */ + GtkWidget *containee; + + /* The drawing area */ + GtkWidget *da; + GdkPixmap *email_pixmap; + GdkBitmap *email_mask; + + /* handle for the timeout */ + int mail_timeout; + + /* how do we report the mail status */ + enum { + REPORT_MAIL_USE_TEXT, + REPORT_MAIL_USE_BITMAP, + REPORT_MAIL_USE_ANIMATION + } report_mail_mode; + + /* current frame on the animation */ + int nframe; + + /* number of frames on the pixmap */ + int frames; + + /* handle for the animation timeout handler */ + int animation_tag; + + /* for the selection routine */ + char *selected_pixmap_name; + + /* The property window */ + GtkWidget *property_window; + GtkWidget *min_spin, *sec_spin; + GtkWidget *pre_check_cmd_entry, *pre_check_cmd_check; + GtkWidget *newmail_cmd_entry, *newmail_cmd_check; + GtkWidget *clicked_cmd_entry, *clicked_cmd_check; + + /* the about box */ + GtkWidget *about; + + GtkWidget *password_dialog; + + gboolean anim_changed; + + char *mailcheck_text_only; + + char *animation_file; + + GtkWidget *mailfile_entry, *mailfile_label, *mailfile_fentry; + GtkWidget *remote_server_entry, *remote_username_entry, *remote_password_entry, *remote_folder_entry; + GtkWidget *remote_server_label, *remote_username_label, *remote_password_label, *remote_folder_label; + GtkWidget *pre_remote_command_label, *pre_remote_command_entry; + GtkWidget *remote_option_menu; + GtkWidget *play_sound_check; + + char *pre_remote_command, *remote_server, *remote_username, *remote_password, *real_password, *remote_folder; + MailboxType mailbox_type; /* local = 0; maildir = 1; pop3 = 2; imap = 3 */ + MailboxType mailbox_type_temp; + + gboolean play_sound; + + int type; /*mailcheck = 0; mailbox = 1 */ + + int size; + + gulong applet_realized_signal; + + /* see remote-helper.h */ + gpointer remote_handle; + }; + + static int mail_check_timeout (gpointer data); + static void after_mail_check (MailCheck *mc); + + static void applet_load_prefs(MailCheck *mc); + + static void set_atk_name_description (GtkWidget *widget, const gchar *name, + const gchar *description); + static void set_atk_relation (GtkWidget *label, GtkWidget *entry, AtkRelationType); + static void got_remote_answer (int mails, gpointer data); + static void null_remote_handle (gpointer data); + + #define WANT_BITMAPS(x) (x == REPORT_MAIL_USE_ANIMATION || x == REPORT_MAIL_USE_BITMAP) + + static void + set_tooltip (GtkWidget *applet, + const char *tip) + { + GtkTooltips *tooltips; + + tooltips = g_object_get_data (G_OBJECT (applet), "tooltips"); + if (!tooltips) { + tooltips = gtk_tooltips_new (); + g_object_ref (tooltips); + gtk_object_sink (GTK_OBJECT (tooltips)); + g_object_set_data_full ( + G_OBJECT (applet), "tooltips", tooltips, + (GDestroyNotify) g_object_unref); + } + + gtk_tooltips_set_tip (tooltips, applet, tip, NULL); + } + + static void + mailcheck_execute_shell (MailCheck *mailcheck, + const char *command) + { + GError *error = NULL; + + egg_screen_execute_command_line_async ( + gtk_widget_get_screen (GTK_WIDGET (mailcheck->applet)), command, &error); + if (error) { + GtkWidget *dialog; + + dialog = gtk_message_dialog_new (NULL, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("There was an error executing %s: %s"), + command, + error->message); + + g_signal_connect (dialog, "response", + G_CALLBACK (gtk_widget_destroy), + NULL); + + gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); + gtk_window_set_screen (GTK_WINDOW (dialog), + gtk_widget_get_screen (GTK_WIDGET (mailcheck->applet))); + + gtk_widget_show (dialog); + + g_error_free (error); + } + } + + static G_CONST_RETURN char * + mail_animation_filename (MailCheck *mc) + { + if (!mc->animation_file) { + mc->animation_file = + gnome_program_locate_file ( + NULL, GNOME_FILE_DOMAIN_PIXMAP, + "mailcheck/email.png", TRUE, NULL); + + return mc->animation_file; + + } else if (mc->animation_file [0]) { + if (g_file_test (mc->animation_file, G_FILE_TEST_EXISTS)) + return mc->animation_file; + + g_free (mc->animation_file); + mc->animation_file = NULL; + + return NULL; + } else + /* we are using text only, since the filename was "" */ + return NULL; + } + + static int + calc_dir_contents (char *dir) + { + DIR *dr; + struct dirent *de; + int size=0; + + dr = opendir(dir); + if (dr == NULL) + return 0; + while((de = readdir(dr))) { + if (strlen(de->d_name) < 1 || de->d_name[0] == '.') + continue; + size ++; + } + closedir(dr); + return size; + } + + static void + check_remote_mailbox (MailCheck *mc) + { + if (!mc->real_password || !mc->remote_username || !mc->remote_server) + return; + + if (mc->mailbox_type == MAILBOX_POP3) + mc->remote_handle = helper_pop3_check (got_remote_answer, + mc, + null_remote_handle, + mc->pre_remote_command, + mc->remote_server, + mc->remote_username, + mc->real_password); + else if (mc->mailbox_type == MAILBOX_IMAP) + helper_imap_check (got_remote_answer, + mc, + null_remote_handle, + mc->pre_remote_command, + mc->remote_server, + mc->remote_username, + mc->real_password, + mc->remote_folder); + } + + static void + password_response_cb (GtkWidget *dialog, + int response_id, + MailCheck *mc) + { + + switch (response_id) { + GtkWidget *entry; + + case GTK_RESPONSE_OK: + entry = g_object_get_data (G_OBJECT (dialog), "password_entry"); + mc->real_password = g_strdup (gtk_entry_get_text (GTK_ENTRY (entry))); + check_remote_mailbox (mc); + break; + } + + gtk_widget_destroy (dialog); + mc->password_dialog = NULL; + } + static void + get_remote_password (MailCheck *mc) + { + GtkWidget *dialog; + GtkWidget *hbox; + GtkWidget *label; + GtkWidget *entry; + + if (mc->password_dialog) { + gtk_window_set_screen (GTK_WINDOW (mc->password_dialog), + gtk_widget_get_screen (GTK_WIDGET (mc->applet))); + gtk_window_present (GTK_WINDOW (mc->password_dialog)); + return; + } + + mc->password_dialog = dialog = + gtk_dialog_new_with_buttons ( + _("Inbox Monitor"), NULL, 0, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); + + gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); + + label = gtk_label_new (_("You didn't set a password in the preferences for the Inbox Monitor,\nso you have to enter it each time it starts up.")); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, FALSE, FALSE, GNOME_PAD_BIG); + gtk_widget_show (label); + + hbox = gtk_hbox_new (FALSE, 1); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), + hbox, FALSE, FALSE, GNOME_PAD_SMALL); + + label = gtk_label_new_with_mnemonic (_("Please enter your mailserver's _password:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + + entry = gtk_entry_new (); + + set_atk_name_description (entry, _("Password Entry box"), ""); + set_atk_relation (entry, label, ATK_RELATION_LABELLED_BY); + gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE); + gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0); + gtk_widget_show_all (hbox); + gtk_widget_grab_focus (GTK_WIDGET (entry)); + + gtk_window_set_screen (GTK_WINDOW (dialog), + gtk_widget_get_screen (GTK_WIDGET (mc->applet))); + + g_signal_connect (dialog, "response", + G_CALLBACK (password_response_cb), mc); + + g_object_set_data (G_OBJECT (dialog), "password_entry", entry); + gtk_widget_show (GTK_WIDGET (dialog)); + } + + static void + got_remote_answer (int mails, gpointer data) + { + MailCheck *mc = data; + int old_unreadmail; + + mc->remote_handle = NULL; + + if (mails == -1) { + GtkWidget *dialog; + + /* Disable automatic updating */ + mc->auto_update = FALSE; + + if(mc->mail_timeout != 0) { + gtk_timeout_remove(mc->mail_timeout); + mc->mail_timeout = 0; + } + + /* Notify about an error and keep the current mail status */ + dialog = gtk_message_dialog_new (NULL, + 0,/* Flags */ + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("The Inbox Monitor failed to check your mails and thus automatic updating has been deactivated for now.\nMaybe you used a wrong server, username or password?")); + + gtk_window_set_screen (GTK_WINDOW (dialog), + gtk_widget_get_screen (GTK_WIDGET (mc->applet))); + + g_signal_connect_swapped (G_OBJECT (dialog), "response", + G_CALLBACK (gtk_widget_destroy), + dialog); + gtk_widget_show_all (dialog); + + } else { + old_unreadmail = mc->unreadmail; + mc->unreadmail = (signed int) (((unsigned int) mails) >> 16); + if(mc->unreadmail > old_unreadmail) /* lt */ + mc->newmail = 1; + else + mc->newmail = 0; + mc->totalmail = (signed int) (((unsigned int) mails) & 0x0000FFFFL); + mc->anymail = mc->totalmail ? 1 : 0; + + after_mail_check (mc); + } + } + + static void + applet_realized_cb (GtkWidget *widget, gpointer data) + { + MailCheck *mc = data; + mail_check_timeout (mc); + g_signal_handler_disconnect (G_OBJECT(widget), mc->applet_realized_signal); + } + + static void + null_remote_handle (gpointer data) + { + MailCheck *mc = data; + + mc->remote_handle = NULL; + } + + /* + * Get file modification time, based upon the code + * of Byron C. Darrah for coolmail and reused on fvwm95 + */ + static void + check_mail_file_status (MailCheck *mc) + { + static off_t oldsize = 0; + off_t newsize; + struct stat s; + int status; + + if ((mc->mailbox_type == MAILBOX_POP3) || + (mc->mailbox_type == MAILBOX_IMAP)) { + if (mc->remote_handle != NULL) + /* check in progress */ + return; + + if (mc->remote_password != NULL && + mc->remote_password[0] != '\0') { + g_free (mc->real_password); + mc->real_password = g_strdup (mc->remote_password); + + } else if (!mc->real_password) + get_remote_password (mc); + + check_remote_mailbox (mc); + } + else if (mc->mailbox_type == MAILBOX_LOCAL) { + status = stat (mc->mail_file, &s); + if (status < 0) { + oldsize = 0; + mc->anymail = mc->newmail = mc->unreadmail = 0; + after_mail_check (mc); + return; + } + + newsize = s.st_size; + mc->anymail = newsize > 0; + mc->unreadmail = (s.st_mtime >= s.st_atime && newsize > 0); + + if (newsize != oldsize && mc->unreadmail) + mc->newmail = 1; + else + mc->newmail = 0; + + oldsize = newsize; + + after_mail_check (mc); + } + else if (mc->mailbox_type == MAILBOX_LOCALDIR) { + int newmail, oldmail; + char tmp[1024]; + g_snprintf(tmp, sizeof (tmp), "%s/new", mc->mail_file); + newmail = calc_dir_contents(tmp); + g_snprintf(tmp, sizeof (tmp), "%s/cur", mc->mail_file); + oldmail = calc_dir_contents(tmp); + mc->newmail = newmail > oldsize; + mc->unreadmail = newmail; + oldsize = newmail; + mc->anymail = newmail || oldmail; + mc->totalmail = newmail + oldmail; + + after_mail_check (mc); + } + } + + static gboolean + mailcheck_load_animation (MailCheck *mc, const char *fname) + { + int width, height; + int pbwidth, pbheight; + GdkPixbuf *pb; + + if (mc->email_pixmap) + g_object_unref (mc->email_pixmap); + + if (mc->email_mask) + g_object_unref (mc->email_mask); + + mc->email_pixmap = NULL; + mc->email_mask = NULL; + + pb = gdk_pixbuf_new_from_file (fname, NULL); + if (!pb) + return FALSE; + + pbwidth = gdk_pixbuf_get_width (pb); + pbheight = gdk_pixbuf_get_height (pb); + + if(pbheight != mc->size) { + GdkPixbuf *pbt; + height = mc->size; + width = pbwidth*((double)height/pbheight); + + pbt = gdk_pixbuf_scale_simple(pb, width, height, + GDK_INTERP_NEAREST); + g_object_unref (pb); + pb = pbt; + } else { + width = pbwidth; + height = pbheight; + } + + /* yeah, they have to be square, in case you were wondering :-) */ + mc->frames = width / height; + if (mc->frames < 3) + return FALSE; + else if (mc->frames == 3) + mc->report_mail_mode = REPORT_MAIL_USE_BITMAP; + else + mc->report_mail_mode = REPORT_MAIL_USE_ANIMATION; + mc->nframe = 0; + + mc->email_pixmap = gdk_pixmap_new (gdk_screen_get_root_window ( + gtk_widget_get_screen (GTK_WIDGET (mc->applet))), + width, height, -1); + + gdk_pixbuf_render_to_drawable (pb, + mc->email_pixmap, + mc->da->style->black_gc, + 0, 0, 0, 0, + width, height, + GDK_RGB_DITHER_NORMAL, + 0, 0); + + g_object_unref (pb); + + return TRUE; + } + + static int + next_frame (gpointer data) + { + MailCheck *mc = data; + + mc->nframe = (mc->nframe + 1) % mc->frames; + if (mc->nframe == 0) + mc->nframe = 1; + + gtk_widget_queue_draw (mc->da); + + return TRUE; + } + + static void + after_mail_check (MailCheck *mc) + { + static const char *supinfo[] = {"mailcheck", "new-mail", NULL}; + char *text; + + if (mc->anymail){ + if(mc->mailbox_type == MAILBOX_LOCAL) { + if(mc->newmail) + text = g_strdup(_("You have new mail.")); + else + text = g_strdup(_("You have mail.")); + } + else { + if(mc->unreadmail) + text = g_strdup_printf(_("%d/%d messages"), mc->unreadmail, mc->totalmail); + else + text = g_strdup_printf(_("%d messages"), mc->totalmail); + } + } + else + text = g_strdup_printf(_("No mail.")); + + if (mc->newmail) { + if(mc->play_sound) + gnome_triggers_vdo("You've got new mail!", "program", supinfo); + + if (mc->newmail_enabled && + mc->newmail_cmd && + (strlen(mc->newmail_cmd) > 0)) + mailcheck_execute_shell (mc, mc->newmail_cmd); + } + + switch (mc->report_mail_mode) { + case REPORT_MAIL_USE_ANIMATION: + if (mc->anymail){ + if (mc->unreadmail){ + if (mc->animation_tag == 0){ + mc->animation_tag = gtk_timeout_add (150, next_frame, mc); + mc->nframe = 1; + } + } else { + if (mc->animation_tag != 0){ + gtk_timeout_remove (mc->animation_tag); + mc->animation_tag = 0; + } + mc->nframe = 1; + } + } else { + if (mc->animation_tag != 0){ + gtk_timeout_remove (mc->animation_tag); + mc->animation_tag = 0; + } + mc->nframe = 0; + } + + gtk_widget_queue_draw (mc->da); + + break; + case REPORT_MAIL_USE_BITMAP: + if (mc->anymail){ + if (mc->newmail) + mc->nframe = 2; + else + mc->nframe = 1; + } else + mc->nframe = 0; + + gtk_widget_queue_draw (mc->da); + + break; + case REPORT_MAIL_USE_TEXT: + gtk_label_set_text (GTK_LABEL (mc->label), text); + break; + } + + set_tooltip (GTK_WIDGET (mc->applet), text); + g_free (text); + } + + static gboolean + mail_check_timeout (gpointer data) + { + MailCheck *mc = data; + + if (mc->pre_check_enabled && + mc->pre_check_cmd && + (strlen(mc->pre_check_cmd) > 0)){ + /* + * if we have to execute a command before checking for mail, we + * remove the mail-check timeout and re-add it after the command + * returns, just in case the execution takes too long. + */ + + if(mc->mail_timeout != 0) { + gtk_timeout_remove (mc->mail_timeout); + mc->mail_timeout = 0; + } + + mailcheck_execute_shell (mc, mc->pre_check_cmd); + + mc->mail_timeout = gtk_timeout_add(mc->update_freq, mail_check_timeout, mc); + } + + check_mail_file_status (mc); + + if (mc->auto_update) + return TRUE; + else + /* This handler should just run once */ + return FALSE; + } + + /* + * this gets called when we have to redraw the nice icon + */ + static gint + icon_expose (GtkWidget *widget, GdkEventExpose *event, gpointer data) + { + MailCheck *mc = data; + int h = mc->size; + + gdk_draw_drawable ( + mc->da->window, mc->da->style->black_gc, + mc->email_pixmap, mc->nframe * h, + 0, 0, 0, h, h); + + return TRUE; + } + + static gint + exec_clicked_cmd (GtkWidget *widget, GdkEventButton *event, gpointer data) + { + MailCheck *mc = data; + gboolean retval = FALSE; + + if (event->button == 1) { + + if (mc->clicked_enabled && mc->clicked_cmd && (strlen(mc->clicked_cmd) > 0)) + mailcheck_execute_shell (mc, mc->clicked_cmd); + + if (mc->reset_on_clicked) { + mc->newmail = mc->unreadmail = 0; + after_mail_check (mc); + } + + retval = TRUE; + } + return(retval); + } + + static void + mailcheck_destroy (GtkWidget *widget, gpointer data) + { + MailCheck *mc = data; + + mc->bin = NULL; + + if (mc->property_window != NULL) + gtk_widget_destroy (mc->property_window); + if (mc->about != NULL) + gtk_widget_destroy (mc->about); + + gtk_widget_unref (mc->da); + + g_free (mc->pre_check_cmd); + g_free (mc->newmail_cmd); + g_free (mc->clicked_cmd); + + g_free (mc->remote_server); + g_free (mc->pre_remote_command); + g_free (mc->remote_username); + g_free (mc->remote_password); + g_free (mc->remote_folder); + g_free (mc->real_password); + + g_free (mc->animation_file); + g_free (mc->mail_file); + + if (mc->email_pixmap) + g_object_unref (mc->email_pixmap); + + if (mc->email_mask) + g_object_unref (mc->email_mask); + + if (mc->mail_timeout != 0) + gtk_timeout_remove (mc->mail_timeout); + + if (mc->animation_tag != 0) + gtk_timeout_remove (mc->animation_tag); + + if (mc->remote_handle != NULL) + helper_whack_handle (mc->remote_handle); + + /* just for sanity */ + memset(mc, 0, sizeof(MailCheck)); + + g_free(mc); + } + + static GtkWidget * + create_mail_widgets (MailCheck *mc) + { + const char *fname; + + fname = mail_animation_filename (mc); + + mc->ebox = gtk_event_box_new(); + gtk_widget_set_events(mc->ebox, + gtk_widget_get_events(mc->ebox) | + GDK_BUTTON_PRESS_MASK); + gtk_widget_show (mc->ebox); + + /* + * This is so that the properties dialog is destroyed if the + * applet is removed from the panel while the dialog is + * active. + */ + g_signal_connect (G_OBJECT (mc->ebox), "destroy", + (GtkSignalFunc) mailcheck_destroy, + mc); + + mc->bin = gtk_hbox_new (0, 0); + gtk_container_add(GTK_CONTAINER(mc->ebox), mc->bin); + + gtk_widget_show (mc->bin); + + if (mc->auto_update) + mc->mail_timeout = gtk_timeout_add (mc->update_freq, mail_check_timeout, mc); + else + mc->mail_timeout = 0; + + /* The drawing area */ + mc->da = gtk_drawing_area_new (); + gtk_widget_ref (mc->da); + + gtk_widget_set_size_request (mc->da, mc->size, mc->size); + + g_signal_connect (G_OBJECT(mc->da), "expose_event", (GtkSignalFunc)icon_expose, mc); + gtk_widget_show (mc->da); + + /* The label */ + mc->label = gtk_label_new (""); + gtk_widget_show (mc->label); + gtk_widget_ref (mc->label); + + if (fname != NULL && + WANT_BITMAPS (mc->report_mail_mode) && + mailcheck_load_animation (mc, fname)) { + mc->containee = mc->da; + } else { + mc->report_mail_mode = REPORT_MAIL_USE_TEXT; + mc->containee = mc->label; + } + + gtk_container_add (GTK_CONTAINER (mc->bin), mc->containee); + + return mc->ebox; + } + + static void + load_new_pixmap (MailCheck *mc) + { + gtk_widget_hide (mc->containee); + gtk_container_remove (GTK_CONTAINER (mc->bin), mc->containee); + + if (mc->selected_pixmap_name == mc->mailcheck_text_only) { + mc->report_mail_mode = REPORT_MAIL_USE_TEXT; + mc->containee = mc->label; + g_free(mc->animation_file); + mc->animation_file = NULL; + } else { + char *fname; + char *full; + + fname = g_build_filename ("mailcheck", mc->selected_pixmap_name, NULL); + full = gnome_program_locate_file ( + NULL, GNOME_FILE_DOMAIN_PIXMAP, + fname, TRUE, NULL); + free (fname); + + if(full != NULL && + mailcheck_load_animation (mc, full)) { + mc->containee = mc->da; + g_free(mc->animation_file); + mc->animation_file = full; + } else { + g_free (full); + mc->report_mail_mode = REPORT_MAIL_USE_TEXT; + mc->containee = mc->label; + g_free(mc->animation_file); + mc->animation_file = NULL; + } + } + + mail_check_timeout (mc); + + gtk_container_add (GTK_CONTAINER (mc->bin), mc->containee); + gtk_widget_show (mc->containee); + } + + static void + animation_selected (GtkMenuItem *item, gpointer data) + { + MailCheck *mc = g_object_get_data(G_OBJECT(item), "MailCheck"); + mc->selected_pixmap_name = data; + + load_new_pixmap (mc); + panel_applet_gconf_set_string(mc->applet, "animation_file", + mc->animation_file ? mc->animation_file : "", NULL); + } + + static void + mailcheck_new_entry (MailCheck *mc, GtkWidget *menu, GtkWidget *item, char *s) + { + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + + g_object_set_data (G_OBJECT (item), "MailCheck", mc); + + g_signal_connect_data (item, "activate", G_CALLBACK (animation_selected), + g_strdup (s), (GClosureNotify) g_free, 0); + } + + static GtkWidget * + mailcheck_get_animation_menu (MailCheck *mc) + { + GtkWidget *omenu, *menu, *item; + struct dirent *e; + char *dname; + DIR *dir; + char *basename = NULL; + int i = 0, select_item = 0; + + dname = gnome_program_locate_file ( + NULL, GNOME_FILE_DOMAIN_PIXMAP, + "mailcheck", FALSE, NULL); + + mc->selected_pixmap_name = mc->mailcheck_text_only; + omenu = gtk_option_menu_new (); + menu = gtk_menu_new (); + + item = gtk_menu_item_new_with_label (mc->mailcheck_text_only); + gtk_widget_show (item); + mailcheck_new_entry (mc, menu, item, mc->mailcheck_text_only); + + if (mc->animation_file != NULL) + basename = g_path_get_basename (mc->animation_file); + else + basename = NULL; + + i = 1; + dir = opendir (dname); + if (dir){ + while ((e = readdir (dir)) != NULL){ + char *s; + + if (! (strstr (e->d_name, ".xpm") || + strstr (e->d_name, ".png") || + strstr (e->d_name, ".gif") || + strstr (e->d_name, ".jpg"))) + continue; + + s = g_strdup (e->d_name); + /* FIXME the string s will be freed in a second so + ** this should be a strdup */ + if (!mc->selected_pixmap_name) + mc->selected_pixmap_name = s; + if (basename && strcmp (basename, e->d_name) == 0) + select_item = i; + item = gtk_menu_item_new_with_label (s); + + i++; + gtk_widget_show (item); + + mailcheck_new_entry (mc,menu, item, s); + + g_free (s); + } + closedir (dir); + } + gtk_option_menu_set_menu (GTK_OPTION_MENU (omenu), menu); + gtk_option_menu_set_history (GTK_OPTION_MENU (omenu), select_item); + gtk_widget_show (omenu); + + g_free (dname); + g_free (basename); + + return omenu; + } + + static void + make_check_widgets_sensitive(MailCheck *mc) + { + gtk_widget_set_sensitive (GTK_WIDGET (mc->min_spin), mc->auto_update); + gtk_widget_set_sensitive (GTK_WIDGET (mc->sec_spin), mc->auto_update); + } + + static void + make_remote_widgets_sensitive(MailCheck *mc) + { + gboolean b = mc->mailbox_type != MAILBOX_LOCAL && + mc->mailbox_type != MAILBOX_LOCALDIR; + gboolean f = mc->mailbox_type == MAILBOX_IMAP; + + gtk_widget_set_sensitive (mc->mailfile_fentry, !b); + gtk_widget_set_sensitive (mc->mailfile_label, !b); + + gtk_widget_set_sensitive (mc->remote_server_entry, b); + gtk_widget_set_sensitive (mc->remote_password_entry, b); + gtk_widget_set_sensitive (mc->remote_username_entry, b); + gtk_widget_set_sensitive (mc->remote_folder_entry, f); + gtk_widget_set_sensitive (mc->remote_server_label, b); + gtk_widget_set_sensitive (mc->remote_password_label, b); + gtk_widget_set_sensitive (mc->remote_username_label, b); + gtk_widget_set_sensitive (mc->remote_folder_label, f); + gtk_widget_set_sensitive (mc->pre_remote_command_entry, b); + gtk_widget_set_sensitive (mc->pre_remote_command_label, b); + } + + static void + mail_file_changed (GtkEntry *entry, gpointer data) + { + MailCheck *mc = data; + gchar *text; + + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + if (!text) + return; + + if (mc->mail_file); + g_free (mc->mail_file); + + mc->mail_file = text; + panel_applet_gconf_set_string(mc->applet, "mail_file", mc->mail_file, NULL); + } + + static void + remote_server_changed (GtkEntry *entry, gpointer data) + { + MailCheck *mc = data; + gchar *text; + + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + if (!text) + return; + + if (mc->remote_server); + g_free (mc->remote_server); + + mc->remote_server = text; + panel_applet_gconf_set_string(mc->applet, "remote_server", + mc->remote_server, NULL); + } + + static void + remote_username_changed (GtkEntry *entry, gpointer data) + { + MailCheck *mc = data; + gchar *text; + + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + if (!text) + return; + + if (mc->remote_username); + g_free (mc->remote_username); + + mc->remote_username = text; + panel_applet_gconf_set_string(mc->applet, "remote_username", + mc->remote_username, NULL); + } + + static void + remote_password_changed (GtkEntry *entry, gpointer data) + { + MailCheck *mc = data; + gchar *text; + + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + if (!text) + return; + + if (mc->remote_password); + g_free (mc->remote_password); + + mc->remote_password = text; + panel_applet_gconf_set_string(mc->applet, "remote_password", + mc->remote_password, NULL); + } + + static void + remote_folder_changed (GtkEntry *entry, gpointer data) + { + MailCheck *mc = data; + gchar *text; + + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + if (!text) + return; + + if (mc->remote_folder); + g_free (mc->remote_folder); + + mc->remote_folder = text; + panel_applet_gconf_set_string(mc->applet, "remote_folder", + mc->remote_folder, NULL); + } + + static void + pre_remote_command_changed (GtkEntry *entry, gpointer data) + { + MailCheck *mc = data; + gchar *text; + + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + if (!text) + return; + + if (mc->pre_remote_command); + g_free (mc->pre_remote_command); + + mc->pre_remote_command = text; + panel_applet_gconf_set_string(mc->applet, "pre_remote_command", + mc->pre_remote_command, NULL); + } + + static void + set_mailbox_selection (GtkWidget *widget, gpointer data) + { + MailCheck *mc = g_object_get_data(G_OBJECT(widget), "MailCheck"); + mc->mailbox_type = GPOINTER_TO_INT(data); + panel_applet_gconf_set_int(mc->applet, "mailbox_type", + (gint)mc->mailbox_type, NULL); + make_remote_widgets_sensitive(mc); + + if ((mc->mailbox_type != MAILBOX_POP3) && + (mc->mailbox_type != MAILBOX_IMAP) && + (mc->remote_handle != NULL)) { + helper_whack_handle (mc->remote_handle); + mc->remote_handle = NULL; + } + gtk_label_set_text (GTK_LABEL (mc->label), _("Status not updated")); + set_tooltip (GTK_WIDGET (mc->applet), _("Status not updated")); + } + + static void + pre_check_toggled (GtkToggleButton *button, gpointer data) + { + MailCheck *mc = data; + + mc->pre_check_enabled = gtk_toggle_button_get_active (button); + panel_applet_gconf_set_bool(mc->applet, "exec_enabled", + mc->pre_check_enabled, NULL); + gtk_widget_set_sensitive (mc->pre_check_cmd_entry, mc->pre_check_enabled); + + } + + static void + pre_check_changed (GtkEntry *entry, gpointer data) + { + MailCheck *mc = data; + gchar *text; + + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + if (!text) + return; + + if (mc->pre_check_cmd) + g_free (mc->pre_check_cmd); + mc->pre_check_cmd = g_strdup (text); + panel_applet_gconf_set_string(mc->applet, "exec_command", + mc->pre_check_cmd, NULL); + g_free (text); + + } + + static void + newmail_toggled (GtkToggleButton *button, gpointer data) + { + MailCheck *mc = data; + + mc->newmail_enabled = gtk_toggle_button_get_active (button); + panel_applet_gconf_set_bool(mc->applet, "newmail_enabled", + mc->newmail_enabled, NULL); + gtk_widget_set_sensitive (mc->newmail_cmd_entry, mc->newmail_enabled); + + } + + static void + newmail_changed (GtkEntry *entry, gpointer data) + { + MailCheck *mc = data; + gchar *text; + + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + if (!text) + return; + + if (mc->newmail_cmd) + g_free (mc->newmail_cmd); + mc->newmail_cmd = g_strdup (text); + panel_applet_gconf_set_string(mc->applet, "newmail_command", + mc->newmail_cmd, NULL); + g_free (text); + + } + + static void + clicked_toggled (GtkToggleButton *button, gpointer data) + { + MailCheck *mc = data; + + mc->clicked_enabled = gtk_toggle_button_get_active (button); + panel_applet_gconf_set_bool(mc->applet, "clicked_enabled", + mc->clicked_enabled, NULL); + gtk_widget_set_sensitive (mc->clicked_cmd_entry, mc->clicked_enabled); + + } + + static void + clicked_changed (GtkEntry *entry, gpointer data) + { + MailCheck *mc = data; + gchar *text; + + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + if (!text) + return; + + if (mc->clicked_cmd) + g_free (mc->clicked_cmd); + mc->clicked_cmd = g_strdup (text); + panel_applet_gconf_set_string(mc->applet, "clicked_command", mc->clicked_cmd, NULL); + g_free (text); + + } + + static void + reset_on_clicked_toggled (GtkToggleButton *button, gpointer data) + { + MailCheck *mc = data; + + mc->reset_on_clicked = gtk_toggle_button_get_active (button); + panel_applet_gconf_set_bool(mc->applet, "reset_on_clicked", + mc->reset_on_clicked, NULL); + + } + + static void + auto_update_toggled (GtkToggleButton *button, gpointer data) + { + MailCheck *mc = data; + + mc->auto_update = gtk_toggle_button_get_active (button); + + if(mc->mail_timeout != 0) { + gtk_timeout_remove(mc->mail_timeout); + mc->mail_timeout = 0; + } + if(mc->auto_update) + mc->mail_timeout = gtk_timeout_add(mc->update_freq, mail_check_timeout, mc); + + make_check_widgets_sensitive(mc); + panel_applet_gconf_set_bool(mc->applet, "auto_update", mc->auto_update, NULL); + + /* + * check the mail right now, so we don't have to wait + * for the first timeout + */ + mail_check_timeout (mc); + } + + static void + update_spin_changed (GtkSpinButton *spin, gpointer data) + { + MailCheck *mc = data; + + mc->update_freq = 1000 * (guint)(gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (mc->sec_spin)) + 60 * gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (mc->min_spin))); + + if (mc->update_freq == 0) { + gtk_spin_button_set_value(GTK_SPIN_BUTTON (mc->sec_spin), 0.0); + gtk_spin_button_set_value(GTK_SPIN_BUTTON (mc->min_spin), 1.0); + mc->update_freq = 60*1000; + } + if(mc->mail_timeout != 0) + gtk_timeout_remove (mc->mail_timeout); + mc->mail_timeout = gtk_timeout_add (mc->update_freq, mail_check_timeout, mc); + panel_applet_gconf_set_int(mc->applet, "update_frequency", mc->update_freq, NULL); + } + + static void + sound_toggled (GtkToggleButton *button, gpointer data) + { + MailCheck *mc = data; + + mc->play_sound = gtk_toggle_button_get_active (button); + panel_applet_gconf_set_bool(mc->applet, "play_sound", mc->play_sound, NULL); + } + + static GtkWidget * + mailbox_properties_page(MailCheck *mc) + { + GtkWidget *vbox, *hbox, *l, *l2, *item, *label, *entry; + + mc->type = 1; + + vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); + gtk_widget_show (vbox); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + label = gtk_label_new_with_mnemonic(_("Mailbox _resides on:")); + gtk_widget_show(label); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + + mc->remote_option_menu = l = gtk_option_menu_new(); + set_atk_relation (mc->remote_option_menu, label, ATK_RELATION_LABELLED_BY); + + l2 = gtk_menu_new(); + item = gtk_menu_item_new_with_label(_("Local mailspool")); + gtk_widget_show(item); + g_object_set_data(G_OBJECT(item), "MailCheck", mc); + g_signal_connect (G_OBJECT(item), "activate", + G_CALLBACK(set_mailbox_selection), + GINT_TO_POINTER(MAILBOX_LOCAL)); + gtk_menu_shell_append (GTK_MENU_SHELL (l2), item); + + item = gtk_menu_item_new_with_label(_("Local maildir")); + gtk_widget_show(item); + g_object_set_data(G_OBJECT(item), "MailCheck", mc); + g_signal_connect (G_OBJECT(item), "activate", + G_CALLBACK(set_mailbox_selection), + GINT_TO_POINTER(MAILBOX_LOCALDIR)); + gtk_menu_shell_append (GTK_MENU_SHELL (l2), item); + + item = gtk_menu_item_new_with_label(_("Remote POP3-server")); + gtk_widget_show(item); + g_object_set_data(G_OBJECT(item), "MailCheck", mc); + g_signal_connect (G_OBJECT(item), "activate", + G_CALLBACK(set_mailbox_selection), + GINT_TO_POINTER(MAILBOX_POP3)); + + gtk_menu_shell_append (GTK_MENU_SHELL (l2), item); + item = gtk_menu_item_new_with_label(_("Remote IMAP-server")); + gtk_widget_show(item); + g_object_set_data(G_OBJECT(item), "MailCheck", mc); + g_signal_connect (G_OBJECT(item), "activate", + G_CALLBACK(set_mailbox_selection), + GINT_TO_POINTER(MAILBOX_IMAP)); + gtk_menu_shell_append (GTK_MENU_SHELL (l2), item); + + gtk_widget_show(l2); + + gtk_option_menu_set_menu(GTK_OPTION_MENU(l), l2); + gtk_option_menu_set_history(GTK_OPTION_MENU(l), mc->mailbox_type_temp = mc->mailbox_type); + gtk_widget_show(l); + + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + mc->mailfile_label = l = gtk_label_new_with_mnemonic(_("Mail _spool file:")); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + mc->mailfile_fentry = l = gnome_file_entry_new ("spool_file", _("Browse")); + entry = gnome_file_entry_gtk_entry (GNOME_FILE_ENTRY (mc->mailfile_fentry)); + set_atk_relation (entry, mc->mailfile_label, ATK_RELATION_LABELLED_BY); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, TRUE, TRUE, 0); + + mc->mailfile_entry = l = gnome_file_entry_gtk_entry(GNOME_FILE_ENTRY (l)); + gtk_entry_set_text(GTK_ENTRY(l), mc->mail_file); + g_signal_connect(G_OBJECT(l), "changed", + G_CALLBACK(mail_file_changed), mc); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + mc->remote_server_label = l = gtk_label_new_with_mnemonic(_("Mail s_erver:")); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + mc->remote_server_entry = l = gtk_entry_new(); + + set_atk_name_description (mc->remote_server_entry, _("Mail Server Entry box"), ""); + set_atk_relation (mc->remote_server_entry, mc->remote_server_label, ATK_RELATION_LABELLED_BY); + if (mc->remote_server) + gtk_entry_set_text(GTK_ENTRY(l), mc->remote_server); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, TRUE, TRUE, 0); + + g_signal_connect(G_OBJECT(l), "changed", + G_CALLBACK(remote_server_changed), mc); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + mc->remote_username_label = l = gtk_label_new_with_mnemonic(_("_Username:")); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + mc->remote_username_entry = l = gtk_entry_new(); + if (mc->remote_username) + gtk_entry_set_text(GTK_ENTRY(l), mc->remote_username); + + set_atk_name_description (mc->remote_username_entry, _("Username Entry box"), ""); + set_atk_relation (mc->remote_username_entry, mc->remote_username_label, ATK_RELATION_LABELLED_BY); + + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + g_signal_connect(G_OBJECT(l), "changed", + G_CALLBACK(remote_username_changed), mc); + + mc->remote_password_label = l = gtk_label_new_with_mnemonic(_("_Password:")); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + mc->remote_password_entry = l = gtk_entry_new(); + if (mc->remote_password) + gtk_entry_set_text(GTK_ENTRY(l), mc->remote_password); + + set_atk_name_description (mc->remote_password_entry, _("Password Entry box"), ""); + set_atk_relation (mc->remote_password_entry, mc->remote_password_label, ATK_RELATION_LABELLED_BY); + gtk_entry_set_visibility(GTK_ENTRY (l), FALSE); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + g_signal_connect(G_OBJECT(l), "changed", + G_CALLBACK(remote_password_changed), mc); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + mc->remote_folder_label = l = gtk_label_new_with_mnemonic(_("_Folder:")); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + mc->remote_folder_entry = l = gtk_entry_new(); + if (mc->remote_folder) + gtk_entry_set_text(GTK_ENTRY(l), mc->remote_folder); + + set_atk_name_description (mc->remote_folder_entry, _("Folder Entry box"), ""); + set_atk_relation (mc->remote_folder_entry, mc->remote_folder_label, ATK_RELATION_LABELLED_BY); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + g_signal_connect(G_OBJECT(l), "changed", + G_CALLBACK(remote_folder_changed), mc); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + mc->pre_remote_command_label = l = gtk_label_new_with_mnemonic(_("C_ommand to run before checking for mail:")); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + mc->pre_remote_command_entry = l = gtk_entry_new(); + if (mc->pre_remote_command) + gtk_entry_set_text(GTK_ENTRY(l), mc->pre_remote_command); + + set_atk_name_description (mc->pre_remote_command_entry, _("Command Entry box"), ""); + set_atk_relation (mc->pre_remote_command_entry, mc->pre_remote_command_label, ATK_RELATION_LABELLED_BY); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, TRUE, TRUE, 0); + + g_signal_connect(G_OBJECT(l), "changed", + G_CALLBACK(pre_remote_command_changed), mc); + + make_remote_widgets_sensitive(mc); + + return vbox; + } + + static GtkWidget * + mailcheck_properties_page (MailCheck *mc) + { + GtkWidget *vbox, *hbox, *l, *table, *frame, *check_box, *animation_option_menu; + GtkObject *freq_a; + + mc->type = 0; + + vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); + gtk_widget_show (vbox); + + frame = gtk_frame_new (_("Execute")); + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); + gtk_widget_show (frame); + + table = gtk_table_new (3, 2, FALSE); + gtk_table_set_col_spacings (GTK_TABLE (table), GNOME_PAD/2); + gtk_table_set_row_spacings (GTK_TABLE (table), GNOME_PAD/2); + gtk_container_set_border_width (GTK_CONTAINER (table), GNOME_PAD/2); + gtk_widget_show(table); + gtk_container_add (GTK_CONTAINER (frame), table); + + l = gtk_check_button_new_with_mnemonic(_("Before each _update:")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(l), mc->pre_check_enabled); + g_signal_connect(G_OBJECT(l), "toggled", + G_CALLBACK(pre_check_toggled), mc); + gtk_widget_show(l); + mc->pre_check_cmd_check = l; + + gtk_table_attach (GTK_TABLE (table), mc->pre_check_cmd_check, + 0, 1, 0, 1, GTK_FILL, 0, 0, 0); + + + mc->pre_check_cmd_entry = gtk_entry_new(); + if(mc->pre_check_cmd) + gtk_entry_set_text(GTK_ENTRY(mc->pre_check_cmd_entry), + mc->pre_check_cmd); + set_atk_name_description (mc->pre_check_cmd_entry, _("Command to execute before each update"), ""); + set_atk_relation (mc->pre_check_cmd_entry, mc->pre_check_cmd_check, ATK_RELATION_CONTROLLED_BY); + set_atk_relation (mc->pre_check_cmd_check, mc->pre_check_cmd_entry, ATK_RELATION_CONTROLLER_FOR); + gtk_widget_set_sensitive (mc->pre_check_cmd_entry, mc->pre_check_enabled); + g_signal_connect(G_OBJECT(mc->pre_check_cmd_entry), "changed", + G_CALLBACK(pre_check_changed), mc); + gtk_widget_show(mc->pre_check_cmd_entry); + gtk_table_attach_defaults (GTK_TABLE (table), mc->pre_check_cmd_entry, + 1, 2, 0, 1); + + l = gtk_check_button_new_with_mnemonic (_("When new mail _arrives:")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(l), mc->newmail_enabled); + g_signal_connect(G_OBJECT(l), "toggled", + G_CALLBACK(newmail_toggled), mc); + gtk_widget_show(l); + gtk_table_attach (GTK_TABLE (table), l, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); + mc->newmail_cmd_check = l; + + mc->newmail_cmd_entry = gtk_entry_new(); + if (mc->newmail_cmd) { + gtk_entry_set_text(GTK_ENTRY(mc->newmail_cmd_entry), + mc->newmail_cmd); + } + set_atk_name_description (mc->newmail_cmd_entry, _("Command to execute when new mail arrives"), ""); + set_atk_relation (mc->newmail_cmd_entry, mc->newmail_cmd_check, ATK_RELATION_CONTROLLED_BY); + set_atk_relation (mc->newmail_cmd_check, mc->newmail_cmd_entry, ATK_RELATION_CONTROLLER_FOR); + gtk_widget_set_sensitive (mc->newmail_cmd_entry, mc->newmail_enabled); + g_signal_connect(G_OBJECT (mc->newmail_cmd_entry), "changed", + G_CALLBACK(newmail_changed), mc); + gtk_widget_show(mc->newmail_cmd_entry); + gtk_table_attach_defaults (GTK_TABLE (table), mc->newmail_cmd_entry, + 1, 2, 1, 2); + + l = gtk_check_button_new_with_mnemonic (_("When clicke_d:")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(l), mc->clicked_enabled); + g_signal_connect(G_OBJECT(l), "toggled", + G_CALLBACK(clicked_toggled), mc); + gtk_widget_show(l); + gtk_table_attach (GTK_TABLE (table), l, 0, 1, 2, 3, GTK_FILL, 0, 0, 0); + mc->clicked_cmd_check = l; + + mc->clicked_cmd_entry = gtk_entry_new(); + if(mc->clicked_cmd) { + gtk_entry_set_text(GTK_ENTRY(mc->clicked_cmd_entry), + mc->clicked_cmd); + } + set_atk_name_description (mc->clicked_cmd_entry, _("Command to execute when clicked"), ""); + set_atk_relation (mc->clicked_cmd_entry, mc->clicked_cmd_check, ATK_RELATION_CONTROLLED_BY); + set_atk_relation (mc->clicked_cmd_check, mc->clicked_cmd_entry, ATK_RELATION_CONTROLLER_FOR); + gtk_widget_set_sensitive (mc->clicked_cmd_entry, mc->clicked_enabled); + g_signal_connect(G_OBJECT(mc->clicked_cmd_entry), "changed", + G_CALLBACK(clicked_changed), mc); + gtk_widget_show(mc->clicked_cmd_entry); + gtk_table_attach_defaults (GTK_TABLE (table), mc->clicked_cmd_entry, + 1, 2, 2, 3); + + l = gtk_check_button_new_with_mnemonic (_("Set the number of unread mails to _zero")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(l), mc->reset_on_clicked); + g_signal_connect(G_OBJECT(l), "toggled", + G_CALLBACK(reset_on_clicked_toggled), mc); + gtk_widget_show(l); + gtk_table_attach (GTK_TABLE (table), l, 1, 2, 3, 4, GTK_FILL, 0, 0, 0); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + check_box = l = gtk_check_button_new_with_mnemonic (_("Check for mail _every")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(l), mc->auto_update); + g_signal_connect(G_OBJECT(l), "toggled", + G_CALLBACK(auto_update_toggled), mc); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + gtk_widget_show(l); + + freq_a = gtk_adjustment_new((float)((mc->update_freq/1000)/60), 0, 1440, 1, 5, 5); + mc->min_spin = gtk_spin_button_new( GTK_ADJUSTMENT (freq_a), 1, 0); + g_signal_connect (G_OBJECT (mc->min_spin), "value_changed", + G_CALLBACK (update_spin_changed), mc); + gtk_box_pack_start (GTK_BOX (hbox), mc->min_spin, FALSE, FALSE, 0); + set_atk_name_description (mc->min_spin, _("minutes"), _("Choose time interval in minutes to check mail")); + set_atk_relation (mc->min_spin, check_box, ATK_RELATION_CONTROLLED_BY); + gtk_widget_show(mc->min_spin); + + l = gtk_label_new (_("minutes")); + set_atk_relation (mc->min_spin, l, ATK_RELATION_LABELLED_BY); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + freq_a = gtk_adjustment_new((float)((mc->update_freq/1000)%60), 0, 59, 1, 5, 5); + mc->sec_spin = gtk_spin_button_new (GTK_ADJUSTMENT (freq_a), 1, 0); + g_signal_connect (G_OBJECT (mc->sec_spin), "value_changed", + G_CALLBACK (update_spin_changed), mc); + gtk_box_pack_start (GTK_BOX (hbox), mc->sec_spin, FALSE, FALSE, 0); + set_atk_name_description (mc->sec_spin, _("seconds"), _("Choose time interval in seconds to check mail")); + set_atk_relation (mc->sec_spin, check_box, ATK_RELATION_CONTROLLED_BY); + gtk_widget_show(mc->sec_spin); + + l = gtk_label_new (_("seconds")); + set_atk_relation (mc->sec_spin, l, ATK_RELATION_LABELLED_BY); + gtk_widget_show(l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + set_atk_relation (check_box, mc->min_spin, ATK_RELATION_CONTROLLER_FOR); + set_atk_relation (check_box, mc->sec_spin, ATK_RELATION_CONTROLLER_FOR); + + mc->play_sound_check = gtk_check_button_new_with_mnemonic(_("Play a _sound when new mail arrives")); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mc->play_sound_check), mc->play_sound); + g_signal_connect(G_OBJECT(mc->play_sound_check), "toggled", + G_CALLBACK(sound_toggled), mc); + gtk_widget_show(mc->play_sound_check); + gtk_box_pack_start(GTK_BOX (vbox), mc->play_sound_check, FALSE, FALSE, 0); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + gtk_widget_show (hbox); + + l = gtk_label_new_with_mnemonic (_("Select a_nimation")); + gtk_misc_set_alignment (GTK_MISC (l), 0.0, 0.5); + gtk_widget_show (l); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + animation_option_menu = mailcheck_get_animation_menu (mc); + gtk_box_pack_start (GTK_BOX (hbox), animation_option_menu, FALSE, FALSE, 0); + set_atk_relation (animation_option_menu, l, ATK_RELATION_LABELLED_BY); + make_check_widgets_sensitive(mc); + + return vbox; + } + + static void + phelp_cb (GtkDialog *w, gint tab, MailCheck *mc) + { + GError *error = NULL; + static GnomeProgram *applet_program = NULL; + + if (!applet_program) { + int argc = 1; + char *argv[2] = { "mailcheck" }; + applet_program = gnome_program_init ("mailcheck", VERSION, + LIBGNOME_MODULE, argc, argv, + GNOME_PROGRAM_STANDARD_PROPERTIES, NULL); + } + + egg_help_display_desktop_on_screen ( + applet_program, "mailcheck", "mailcheck", "mailcheck-prefs", + gtk_widget_get_screen (GTK_WIDGET (mc->applet)), + &error); + if (error) { + GtkWidget *dialog; + dialog = gtk_message_dialog_new (GTK_WINDOW (w), + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("There was an error displaying help: %s"), + error->message); + + g_signal_connect (G_OBJECT (dialog), "response", + G_CALLBACK (gtk_widget_destroy), + NULL); + + gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); + gtk_window_set_screen (GTK_WINDOW (dialog), + gtk_widget_get_screen (GTK_WIDGET (mc->applet))); + gtk_widget_show (dialog); + g_error_free (error); + } + } + + static void + response_cb (GtkDialog *dialog, gint id, MailCheck *mc) + { + if (id == GTK_RESPONSE_HELP) { + phelp_cb (dialog, id, mc); + return; + } + + gtk_widget_destroy (GTK_WIDGET (dialog)); + mc->property_window = NULL; + } + + + static void + mailcheck_properties (BonoboUIComponent *uic, MailCheck *mc, const gchar *verbname) + { + GtkWidget *p; + GtkWidget *notebook; + + if (mc->property_window) { + gtk_window_set_screen (GTK_WINDOW (mc->property_window), + gtk_widget_get_screen (GTK_WIDGET (mc->applet))); + gtk_window_present (GTK_WINDOW (mc->property_window)); + return; + } + + mc->property_window = gtk_dialog_new_with_buttons (_("Inbox Monitor Preferences"), + NULL, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_STOCK_CLOSE, + GTK_RESPONSE_CLOSE, + GTK_STOCK_HELP, + GTK_RESPONSE_HELP, + NULL); + gtk_dialog_set_default_response (GTK_DIALOG (mc->property_window), GTK_RESPONSE_CLOSE); + gnome_window_icon_set_from_file (GTK_WINDOW (mc->property_window), + GNOME_ICONDIR"/gnome-mailcheck.png"); + gtk_window_set_screen (GTK_WINDOW (mc->property_window), + gtk_widget_get_screen (GTK_WIDGET (mc->applet))); + + notebook = gtk_notebook_new (); + gtk_widget_show (notebook); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (mc->property_window)->vbox), notebook, + TRUE, TRUE, 0); + p = mailcheck_properties_page (mc); + gtk_notebook_append_page (GTK_NOTEBOOK (notebook), p, + gtk_label_new_with_mnemonic (_("_Mail check"))); + + p = mailbox_properties_page (mc); + gtk_notebook_append_page (GTK_NOTEBOOK (notebook), p, + gtk_label_new_with_mnemonic (_("Mail_box"))); + + g_signal_connect (G_OBJECT (mc->property_window), "response", + G_CALLBACK (response_cb), mc); + gtk_widget_show (GTK_DIALOG (mc->property_window)->vbox); + gtk_widget_show (mc->property_window); + } + + static void + check_callback (BonoboUIComponent *uic, gpointer data, const gchar *verbname) + { + MailCheck *mc = data; + + mail_check_timeout(mc); + } + + static void + applet_load_prefs(MailCheck *mc) + { + mc->animation_file = panel_applet_gconf_get_string(mc->applet, "animation_file", NULL); + if(!mc->animation_file) { + g_free(mc->animation_file); + mc->animation_file = NULL; + } + + mc->auto_update = panel_applet_gconf_get_bool(mc->applet, "auto_update", NULL); + mc->reset_on_clicked = panel_applet_gconf_get_bool (mc->applet, "reset_on_clicked", NULL); + mc->update_freq = panel_applet_gconf_get_int(mc->applet, "update_frequency", NULL); + mc->pre_check_cmd = panel_applet_gconf_get_string(mc->applet, "exec_command", NULL); + mc->pre_check_enabled = panel_applet_gconf_get_bool(mc->applet, "exec_enabled", NULL); + mc->newmail_cmd = panel_applet_gconf_get_string(mc->applet, "newmail_command", NULL); + mc->newmail_enabled = panel_applet_gconf_get_bool(mc->applet, "newmail_enabled", NULL); + mc->clicked_cmd = panel_applet_gconf_get_string(mc->applet, "clicked_command", NULL); + mc->clicked_enabled = panel_applet_gconf_get_bool(mc->applet, "clicked_enabled", NULL); + mc->remote_server = panel_applet_gconf_get_string(mc->applet, "remote_server", NULL); + mc->pre_remote_command = panel_applet_gconf_get_string(mc->applet, "pre_remote_command", NULL); + mc->remote_username = panel_applet_gconf_get_string(mc->applet, "remote_username", NULL); + if(!mc->remote_username) { + g_free(mc->remote_username); + mc->remote_username = g_strdup(g_getenv("USER")); + } + mc->remote_password = panel_applet_gconf_get_string(mc->applet, "remote_password", NULL); + mc->remote_folder = panel_applet_gconf_get_string(mc->applet, "remote_folder", NULL); + mc->mailbox_type = panel_applet_gconf_get_int(mc->applet, "mailbox_type", NULL); + mc->mail_file = panel_applet_gconf_get_string (mc->applet, "mail_file", NULL); + mc->play_sound = panel_applet_gconf_get_bool(mc->applet, "play_sound", NULL); + } + + static void + mailcheck_about(BonoboUIComponent *uic, MailCheck *mc, const gchar *verbname) + { + GdkPixbuf *pixbuf = NULL; + gchar *file; + + static const gchar *authors [] = + { + "Miguel de Icaza ", + "Jacob Berkman ", + "Jaka Mocnik ", + "Lennart Poettering ", + NULL + }; + const char *documenters [] = { + NULL + }; + const char *translator_credits = _("translator_credits"); + + if (mc->about) { + gtk_window_set_screen (GTK_WINDOW (mc->about), + gtk_widget_get_screen (GTK_WIDGET (mc->applet))); + gtk_window_present (GTK_WINDOW (mc->about)); + return; + } + + file = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_PIXMAP, "gnome-mailcheck.png", TRUE, NULL); + pixbuf = gdk_pixbuf_new_from_file (file, NULL); + g_free (file); + + mc->about = gnome_about_new (_("Inbox Monitor"), "1.1", + "Copyright \xc2\xa9 1998-2002 Free Software Foundation, Inc.", + _("Inbox Monitor notifies you when new mail arrives in your mailbox"), + authors, + documenters, + strcmp (translator_credits, "translator_credits") != 0 ? translator_credits : NULL, + pixbuf); + + gtk_window_set_wmclass (GTK_WINDOW (mc->about), "mailcheck", "Mailcheck"); + gtk_window_set_screen (GTK_WINDOW (mc->about), + gtk_widget_get_screen (GTK_WIDGET (mc->applet))); + + gnome_window_icon_set_from_file (GTK_WINDOW (mc->about), + GNOME_ICONDIR"/gnome-mailcheck.png"); + + g_signal_connect( G_OBJECT(mc->about), "destroy", + G_CALLBACK(gtk_widget_destroyed), &mc->about ); + gtk_widget_show(mc->about); + } + + /*this is when the panel size changes */ + static void + applet_change_pixel_size(PanelApplet * w, gint size, gpointer data) + { + MailCheck *mc = data; + const char *fname; + + if(mc->report_mail_mode == REPORT_MAIL_USE_TEXT) + return; + + mc->size = size; + fname = mail_animation_filename (mc); + + gtk_widget_set_size_request (GTK_WIDGET(mc->da), size, size); + + if (!fname) + return; + + mailcheck_load_animation (mc, fname); + } + + static void + help_callback (BonoboUIComponent *uic, MailCheck *mc, const gchar *verbname) + { + GError *error = NULL; + static GnomeProgram *applet_program = NULL; + + if (!applet_program) { + int argc = 1; + char *argv[2] = { "mailcheck" }; + applet_program = gnome_program_init ("mailcheck", VERSION, + LIBGNOME_MODULE, argc, argv, + GNOME_PROGRAM_STANDARD_PROPERTIES, NULL); + } + + egg_help_display_desktop_on_screen ( + applet_program, "mailcheck", "mailcheck",NULL, + gtk_widget_get_screen (GTK_WIDGET (mc->applet)), + &error); + if (error) { + GtkWidget *dialog; + dialog = gtk_message_dialog_new (NULL, + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("There was an error displaying help: %s"), + error->message); + + g_signal_connect (G_OBJECT (dialog), "response", + G_CALLBACK (gtk_widget_destroy), + NULL); + + gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); + gtk_window_set_screen (GTK_WINDOW (dialog), + gtk_widget_get_screen (GTK_WIDGET (mc->applet))); + gtk_widget_show (dialog); + g_error_free (error); + } + } + + static void + set_atk_name_description (GtkWidget *widget, const gchar *name, + const gchar *description) + { + AtkObject *aobj; + + aobj = gtk_widget_get_accessible (widget); + /* Check if gail is loaded */ + if (GTK_IS_ACCESSIBLE (aobj) == FALSE) + return; + atk_object_set_name (aobj, name); + atk_object_set_description (aobj, description); + } + + static void + set_atk_relation (GtkWidget *widget1, GtkWidget *widget2, AtkRelationType relation_type) + { + AtkObject *atk_widget1; + AtkObject *atk_widget2; + AtkRelationSet *relation_set; + AtkRelation *relation; + AtkObject *targets[1]; + + atk_widget1 = gtk_widget_get_accessible (widget1); + atk_widget2 = gtk_widget_get_accessible (widget2); + + /* Set the label-for relation only if label-by is being set */ + if (relation_type == ATK_RELATION_LABELLED_BY) + gtk_label_set_mnemonic_widget (GTK_LABEL (widget2), widget1); + + /* Check if gail is loaded */ + if (GTK_IS_ACCESSIBLE (atk_widget1) == FALSE) + return; + + /* Set the labelled-by relation */ + relation_set = atk_object_ref_relation_set (atk_widget1); + targets[0] = atk_widget2; + relation = atk_relation_new (targets, 1, relation_type); + atk_relation_set_add (relation_set, relation); + g_object_unref (G_OBJECT (relation)); + } + + static const BonoboUIVerb mailcheck_menu_verbs [] = { + BONOBO_UI_UNSAFE_VERB ("Preferences", mailcheck_properties), + BONOBO_UI_UNSAFE_VERB ("Help", help_callback), + BONOBO_UI_UNSAFE_VERB ("About", mailcheck_about), + BONOBO_UI_UNSAFE_VERB ("Check", check_callback), + BONOBO_UI_VERB_END + }; + + gboolean + fill_mailcheck_applet(PanelApplet *applet) + { + GtkWidget *mailcheck; + MailCheck *mc; + + + mc = g_new0(MailCheck, 1); + mc ->applet = applet; + mc->animation_file = NULL; + mc->property_window = NULL; + mc->anim_changed = FALSE; + mc->anymail = mc->unreadmail = mc->newmail = FALSE; + mc->mail_timeout = 0; + mc->animation_tag = 0; + mc->password_dialog = NULL; + + /*initial state*/ + mc->report_mail_mode = REPORT_MAIL_USE_ANIMATION; + + mc->mail_file = NULL; + + if (mc->mail_file == NULL) { + const char *mail_file = g_getenv ("MAIL"); + if (mail_file == NULL) { + const char *user = g_getenv ("USER"); + if (user == NULL) + return FALSE; + + mc->mail_file = g_strdup_printf ("/var/spool/mail/%s", + user); + } else + mc->mail_file = g_strdup (mail_file); + } + + panel_applet_add_preferences (applet, "/schemas/apps/mailcheck_applet/prefs", NULL); + applet_load_prefs(mc); + + mc->mailcheck_text_only = _("Text only"); + + mc->size = panel_applet_get_size (applet); + + g_signal_connect(G_OBJECT(applet), "change_size", + G_CALLBACK(applet_change_pixel_size), + mc); + + mailcheck = create_mail_widgets (mc); + gtk_widget_show(mailcheck); + + gtk_container_add (GTK_CONTAINER (applet), mailcheck); + + g_signal_connect(G_OBJECT(mc->ebox), "button_press_event", + G_CALLBACK(exec_clicked_cmd), mc); + + + panel_applet_setup_menu_from_file (applet, + NULL, + "GNOME_MailCheckApplet.xml", + NULL, + mailcheck_menu_verbs, + mc); + + gtk_label_set_text (GTK_LABEL (mc->label), _("Status not updated")); + set_tooltip (GTK_WIDGET (mc->applet), _("Status not updated")); + set_atk_name_description (GTK_WIDGET (mc->applet), _("Mail check"), + _("Mail check notifies you when new mail arrives in your mailbox")); + gtk_widget_show_all (GTK_WIDGET (applet)); + + /* + * check the mail if the applet is realized. Checking the mail + * right now (in case the applet is not realized), will give us + * wrong screen value. + */ + + if (GTK_WIDGET_REALIZED (GTK_WIDGET (applet))) + mail_check_timeout (mc); + else + mc->applet_realized_signal = + g_signal_connect (G_OBJECT(applet), "realize", + G_CALLBACK(applet_realized_cb), mc); + + return(TRUE); + } diff -crN ./gnome-panel/configure.in /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/configure.in *** ./gnome-panel/configure.in Tue Sep 9 15:53:50 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/configure.in Fri Oct 17 10:03:15 2003 *************** *** 179,184 **** --- 179,190 ---- AC_MSG_ERROR(libpng is required for gnome-panel)], -lm -lz) AC_SUBST(PNG_LIBS) + dnl Check for popt + + AC_CHECK_LIB(popt, poptGetArgs, [POPT_LIBS="-lpopt"], + AC_MSG_ERROR([popt is required to build gnome-panel. + You can download the latest version from ftp://ftp.rpm.org/pub/rpm/dist/rpm-4.0.x/])) + AC_SUBST(POPT_LIBS) dnl Place to look for KDE menus diff -crN ./gnome-panel/gnome-panel/Makefile.am /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/Makefile.am *** ./gnome-panel/gnome-panel/Makefile.am Fri Sep 5 14:17:12 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/Makefile.am Fri Oct 17 10:03:23 2003 *************** *** 203,209 **** $(X_LIBS) \ $(PANEL_LIBS) \ $(XINERAMA_LIBS) \ ! -lpopt gnome_panel_LDFLAGS = -export-dynamic --- 203,209 ---- $(X_LIBS) \ $(PANEL_LIBS) \ $(XINERAMA_LIBS) \ ! $(POPT_LIBS) gnome_panel_LDFLAGS = -export-dynamic *************** *** 216,223 **** $(X_LIBS) \ $(PANELCONFIG_LIBS) ! gnome_panel_preferences_LDFLAGS = \ ! -export-dynamic gnome_desktop_item_edit_SOURCES = \ gnome-desktop-item-edit.c \ --- 216,222 ---- $(X_LIBS) \ $(PANELCONFIG_LIBS) ! gnome_panel_preferences_LDFLAGS = -export-dynamic gnome_desktop_item_edit_SOURCES = \ gnome-desktop-item-edit.c \ *************** *** 234,240 **** gnome_desktop_item_edit_LDADD = \ $(X_LIBS) \ $(PANEL_LIBS) \ ! -lpopt gnome_panel_screenshot_SOURCES = \ gnome-panel-screenshot.c --- 233,239 ---- gnome_desktop_item_edit_LDADD = \ $(X_LIBS) \ $(PANEL_LIBS) \ ! $(POPT_LIBS) gnome_panel_screenshot_SOURCES = \ gnome-panel-screenshot.c diff -crN ./gnome-panel/gnome-panel/basep-widget.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/basep-widget.c *** ./gnome-panel/gnome-panel/basep-widget.c Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/basep-widget.c Tue Jul 8 11:50:26 2003 *************** *** 0 **** --- 1,2629 ---- + /* Gnome panel: basep widget + * (C) 1997 the Free Software Foundation + * + * Authors: George Lebl + * Jacob Berkman + */ + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include + #include "panel-marshal.h" + #include "panel-widget.h" + #include "basep-widget.h" + #include "panel-util.h" + #include "panel-config-global.h" + #include "foobar-widget.h" + #include "drawer-widget.h" + #include "border-widget.h" + #include "edge-widget.h" + #include "aligned-widget.h" + #include "xstuff.h" + #include "multiscreen-stuff.h" + #include "panel-typebuiltins.h" + #include "panel-gconf.h" + #include "panel-stock-icons.h" + + extern GSList *panel_list; + + extern int panels_to_sync; + + /*global settings*/ + + extern GtkTooltips *panel_tooltips; + extern GlobalConfig global_config; + + static GtkWindowClass *basep_widget_parent_class = NULL; + static GtkObjectClass *basep_pos_parent_class = NULL; + + static void basep_widget_class_init (BasePWidgetClass *klass); + static void basep_widget_instance_init (BasePWidget *basep); + + static void basep_pos_class_init (BasePPosClass *klass); + static void basep_pos_instance_init (BasePPos *pos); + + /* Forward declare some static functions for use in the class init */ + static void basep_widget_mode_change (BasePWidget *basep, BasePMode mode); + static void basep_widget_state_change (BasePWidget *basep, BasePState state); + static void basep_widget_real_screen_change (BasePWidget *basep, int screen, int monitor); + static gboolean basep_widget_popup_panel_menu (BasePWidget *basep); + static void basep_widget_size_request (GtkWidget *widget, GtkRequisition *requisition); + static void basep_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation); + static void basep_widget_realize (GtkWidget *w); + static void basep_widget_map (GtkWidget *w); + static gboolean basep_enter_notify (GtkWidget *widget, GdkEventCrossing *event); + static gboolean basep_leave_notify (GtkWidget *widget, GdkEventCrossing *event); + static void basep_style_set (GtkWidget *widget, GtkStyle *previous_style); + static void basep_widget_destroy (GtkObject *o); + static int basep_widget_focus_in_event (GtkWidget *widget, + GdkEventFocus *event); + + static void basep_widget_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); + static void basep_widget_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); + + static BasePPosClass * basep_widget_get_pos_class (BasePWidget *basep); + + enum { + /*TYPE_CHANGE_SIGNAL,*/ + MOVE_FOCUS_OUT_SIGNAL, + MODE_CHANGE_SIGNAL, + STATE_CHANGE_SIGNAL, + SCREEN_CHANGE_SIGNAL, + POPUP_PANEL_MENU_SIGNAL, + WIDGET_LAST_SIGNAL + }; + + enum { + PROP_0, + PROP_MODE, + PROP_STATE, + PROP_LEVEL, + PROP_AVOID_ON_MAXIMIZE, + PROP_HIDEBUTTONS_ENABLED, + PROP_HIDEBUTTON_PIXMAPS_ENABLED + }; + + #define PANEL_SLOW_STEP_SIZE 10 + #define PANEL_MEDIUM_STEP_SIZE 60 + #define PANEL_FAST_STEP_SIZE 80 + + /************************ + widget core + ************************/ + + GType + basep_widget_get_type (void) + { + static GType object_type = 0; + if (object_type == 0) { + static const GTypeInfo object_info = { + sizeof (BasePWidgetClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) basep_widget_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (BasePWidget), + 0, /* n_preallocs */ + (GInstanceInitFunc) basep_widget_instance_init + }; + object_type = g_type_register_static + (GTK_TYPE_WINDOW, "BasePWidget", &object_info, 0); + basep_widget_parent_class = g_type_class_ref (GTK_TYPE_WINDOW); + } + return object_type; + } + + static guint basep_widget_signals[WIDGET_LAST_SIGNAL] = { 0 }; + + static void + basep_widget_class_init (BasePWidgetClass *klass) + { + GObjectClass *object_class = (GObjectClass *) klass; + GtkObjectClass *gtk_object_class = (GtkObjectClass *) klass; + GtkWidgetClass *widget_class = (GtkWidgetClass *) klass; + GtkBindingSet *binding_set; + + binding_set = gtk_binding_set_by_class (klass); + + basep_widget_parent_class = g_type_class_ref (gtk_window_get_type ()); + + klass->mode_change = basep_widget_mode_change; + klass->state_change = basep_widget_state_change; + klass->screen_change = basep_widget_real_screen_change; + klass->popup_panel_menu = basep_widget_popup_panel_menu; + + widget_class->size_request = basep_widget_size_request; + widget_class->size_allocate = basep_widget_size_allocate; + widget_class->realize = basep_widget_realize; + widget_class->map = basep_widget_map; + widget_class->enter_notify_event = basep_enter_notify; + widget_class->leave_notify_event = basep_leave_notify; + widget_class->focus_in_event = basep_widget_focus_in_event; + widget_class->style_set = basep_style_set; + + gtk_object_class->destroy = basep_widget_destroy; + + object_class->set_property = basep_widget_set_property; + object_class->get_property = basep_widget_get_property; + + g_object_class_install_property (object_class, + PROP_MODE, + g_param_spec_enum ("mode", + _("Mode"), + _("Mode of this panel"), + PANEL_TYPE_PMODE, + BASEP_EXPLICIT_HIDE, + G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_STATE, + g_param_spec_enum ("state", + _("State"), + _("Current state of this panel"), + PANEL_TYPE_PSTATE, + BASEP_SHOWN, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_HIDEBUTTONS_ENABLED, + g_param_spec_boolean ("hidebuttons_enabled", + _("Hidebuttons enabled"), + _("Are hidebuttons (buttons that hide or show the panel) enabled?"), + TRUE, + G_PARAM_READWRITE)); + + g_object_class_install_property (object_class, + PROP_HIDEBUTTON_PIXMAPS_ENABLED, + g_param_spec_boolean ("hidebutton_pixmaps_enabled", + _("Hidebutton pixmaps enabled"), + _("Hidebuttons have pixmaps"), + TRUE, + G_PARAM_READWRITE)); + + /*basep_widget_signals[TYPE_CHANGE_SIGNAL] = + g_signal_new ("type_change", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (BasePWidgetClass, type_change), + NULL, + NULL, + g_cclosure_marshal_VOID__ENUM, + G_TYPE_NONE, + 1, + PANEL_TYPE_OBJECT_TYPE); */ + + basep_widget_signals[MODE_CHANGE_SIGNAL] = + g_signal_new ("mode_change", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (BasePWidgetClass, mode_change), + NULL, + NULL, + g_cclosure_marshal_VOID__ENUM, + G_TYPE_NONE, + 1, + PANEL_TYPE_PMODE); + + basep_widget_signals[STATE_CHANGE_SIGNAL] = + g_signal_new ("state_change", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (BasePWidgetClass, state_change), + NULL, + NULL, + g_cclosure_marshal_VOID__ENUM, + G_TYPE_NONE, + 1, + PANEL_TYPE_PSTATE); + + basep_widget_signals [SCREEN_CHANGE_SIGNAL] = + g_signal_new ("screen_change", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (BasePWidgetClass, screen_change), + NULL, + NULL, + panel_marshal_VOID__INT_INT, + G_TYPE_NONE, + 2, + G_TYPE_INT, + G_TYPE_INT); + + basep_widget_signals [POPUP_PANEL_MENU_SIGNAL] = + g_signal_new ("popup_panel_menu", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (BasePWidgetClass, popup_panel_menu), + NULL, + NULL, + panel_marshal_BOOLEAN__VOID, + G_TYPE_BOOLEAN, + 0); + + gtk_binding_entry_add_signal (binding_set, GDK_F10, GDK_CONTROL_MASK, + "popup_panel_menu", 0); + } + + static void + basep_widget_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) + { + + /* Does nothing yet */ + } + + static void + basep_widget_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) + { + BasePWidget *basep; + + basep = BASEP_WIDGET (object); + + switch (prop_id) { + case PROP_MODE: + basep->mode = g_value_get_enum (value); + break; + case PROP_STATE: + basep->state = g_value_get_enum (value); + break; + case PROP_HIDEBUTTONS_ENABLED: + basep->hidebuttons_enabled = g_value_get_boolean (value); + break; + case PROP_HIDEBUTTON_PIXMAPS_ENABLED: + basep->hidebutton_pixmaps_enabled = g_value_get_boolean (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } + } + + void + basep_widget_screen_size_changed (BasePWidget *basep, + GdkScreen *screen) + { + GtkWindow *window; + int w, h; + int x, y; + + window = GTK_WINDOW (basep); + + basep_widget_get_pos (basep, &x, &y); + basep_widget_get_size (basep, &w, &h); + + gtk_window_move (window, x, y); + + gtk_window_set_resizable (window, TRUE); + gtk_widget_set_size_request (GTK_WIDGET (basep), w, h); + gtk_window_resize (window, w, h); + } + + static void + basep_widget_realize (GtkWidget *w) + { + BasePWidget *basep = BASEP_WIDGET (w); + BasePPosClass *klass; + + g_return_if_fail (BASEP_IS_WIDGET (basep)); + + gtk_window_set_wmclass (GTK_WINDOW (basep), + "panel_window", "Panel"); + + GTK_WIDGET_CLASS (basep_widget_parent_class)->realize (w); + + basep_widget_update_winhints (basep); + xstuff_set_no_group_and_no_input (w->window); + + panel_set_frame_colors (PANEL_WIDGET (basep->panel), + basep->frame, + basep->hidebutton_n, + basep->hidebutton_e, + basep->hidebutton_w, + basep->hidebutton_s); + + if (basep->strut_left != 0 || + basep->strut_right != 0 || + basep->strut_top != 0 || + basep->strut_bottom != 0) { + xstuff_set_wmspec_strut (w->window, + basep->strut_left, + basep->strut_right, + basep->strut_top, + basep->strut_bottom); + } + + klass = basep_widget_get_pos_class (basep); + g_return_if_fail (klass); + if (klass->realize != NULL) + klass->realize (w); + } + + static void + basep_widget_map (GtkWidget *w) + { + BasePWidget *basep = BASEP_WIDGET (w); + + g_return_if_fail (BASEP_IS_WIDGET (basep)); + + if (GTK_WIDGET_CLASS (basep_widget_parent_class)->map != NULL) + GTK_WIDGET_CLASS (basep_widget_parent_class)->map (w); + + basep_widget_update_winhints (basep); + } + + static void + basep_widget_size_request (GtkWidget *widget, + GtkRequisition *requisition) + { + GtkRequisition chreq; + + BasePWidget *basep = BASEP_WIDGET(widget); + BasePPosClass *klass = basep_widget_get_pos_class (basep); + + g_assert (klass); + + if (basep->request_cube) { + requisition->width = requisition->height = + PANEL_MINIMUM_WIDTH; + basep->request_cube = FALSE; + return; + } + + gtk_widget_size_request (basep->ebox, &chreq); + + /* this typically only does stuff on edge panels */ + if (klass->get_size) { + int w,h; + w = chreq.width; + h = chreq.height; + klass->get_size(basep, &w, &h); + chreq.width = w; + chreq.height = h; + } + + if (basep->state != BASEP_SHOWN) { + int w,h; + PanelOrient hide_orient = + klass->get_hide_orient (basep); + w = chreq.width; + h = chreq.height; + klass->get_hide_size (basep, hide_orient, &w, &h); + chreq.width = w; + chreq.height = h; + } + + requisition->width = chreq.width; + requisition->height = chreq.height; + } + + static void + basep_widget_size_allocate (GtkWidget *widget, + GtkAllocation *allocation) + { + GtkAllocation challoc; + GtkRequisition chreq; + + BasePWidget *basep = BASEP_WIDGET(widget); + BasePPosClass *klass = basep_widget_get_pos_class (basep); + + /*we actually want to ignore the size_reqeusts since they + are sometimes a cube for the flicker prevention*/ + + gtk_widget_size_request (basep->ebox, &chreq); + + if (klass->get_size) { + int w,h; + w = chreq.width; + h = chreq.height; + klass->get_size(basep, &w, &h); + chreq.width = w; + chreq.height = h; + } + if (klass->get_pos) { + int x,y; + klass->get_pos (basep, &x, &y, + chreq.width, + chreq.height); + allocation->x = x; + allocation->y = y; + } + + allocation->width = challoc.width = chreq.width; + allocation->height = challoc.height = chreq.height; + challoc.x = challoc.y = 0; + + basep->shown_alloc = *allocation; + + if (basep->state != BASEP_SHOWN) { + int w,h,x,y; + PanelOrient hide_orient = + klass->get_hide_orient (basep); + + w = allocation->width; + h = allocation->height; + klass->get_hide_size (basep, hide_orient, &w, &h); + allocation->width = w; + allocation->height = h; + + x = allocation->x; + y = allocation->y; + klass->get_hide_pos (basep, hide_orient, + &x, &y, + basep->shown_alloc.width, + basep->shown_alloc.height); + allocation->x = x; + allocation->y = y; + + basep_widget_get_position (basep, hide_orient, + &x, &y, + allocation->width, + allocation->height); + challoc.x = x; + challoc.y = y; + } + + if (basep->keep_in_screen) { + gint16 max; + + max = multiscreen_width (basep->screen, basep->monitor) - + allocation->width + + multiscreen_x (basep->screen, basep->monitor); + + if (allocation->x < multiscreen_x (basep->screen, basep->monitor)) + allocation->x = multiscreen_x (basep->screen, basep->monitor); + else if (allocation->x > max) + allocation->x = max; + + + max = multiscreen_height (basep->screen, basep->monitor) - + allocation->height + + multiscreen_y (basep->screen, basep->monitor); + + if (allocation->y < multiscreen_y (basep->screen, basep->monitor)) + allocation->y = multiscreen_y (basep->screen, basep->monitor); + else if (allocation->y > max) + allocation->y = max; + + } + widget->allocation = *allocation; + + if (GTK_WIDGET_REALIZED(widget)) { + xstuff_set_pos_size (widget->window, + allocation->x, + allocation->y, + allocation->width, + allocation->height); + } + + gtk_widget_size_allocate (basep->ebox, &challoc); + + /* FIXME: this should be handled in a nicer way */ + if (BORDER_IS_WIDGET (basep)) { + int left = 0, right = 0, top = 0, bottom = 0; + switch (BORDER_POS (basep->pos)->edge) { + case BORDER_LEFT: + if (basep->mode == BASEP_AUTO_HIDE) + left = global_config.minimized_size ; + else + left = basep->shown_alloc.width; + left += allocation->x; + break; + case BORDER_RIGHT: + if (basep->mode == BASEP_AUTO_HIDE) + right = global_config.minimized_size ; + else + right = basep->shown_alloc.width; + right += multiscreen_width (basep->screen, basep->monitor) - + (allocation->x + allocation->width); + break; + case BORDER_TOP: + if (basep->mode == BASEP_AUTO_HIDE) + top = global_config.minimized_size ; + else + top = basep->shown_alloc.height; + top += allocation->y; + break; + case BORDER_BOTTOM: + if (basep->mode == BASEP_AUTO_HIDE) + bottom = global_config.minimized_size ; + else + bottom = basep->shown_alloc.height; + bottom += multiscreen_height (basep->screen, basep->monitor) - + (allocation->y + allocation->height); + break; + } + if (basep->strut_left != left || + basep->strut_right != right || + basep->strut_top != top || + basep->strut_bottom != bottom) { + basep->strut_left = left; + basep->strut_right = right; + basep->strut_top = top; + basep->strut_bottom = bottom; + if (GTK_WIDGET_REALIZED (widget)) { + xstuff_set_wmspec_strut (widget->window, + left, right, + top, bottom); + } + } + } else if (basep->strut_left != 0 || + basep->strut_right != 0 || + basep->strut_top != 0 || + basep->strut_bottom != 0) { + /* If not border widget and it seems to be + * set to some bad values just whack the + * _NET_WM_STRUT */ + basep->strut_left = + basep->strut_right = + basep->strut_top = + basep->strut_bottom = 0; + if (GTK_WIDGET_REALIZED (widget)) { + xstuff_delete_property (widget->window, + "_NET_WM_STRUT"); + } + } + } + + static void + basep_widget_mode_change (BasePWidget *basep, BasePMode old_mode) + { + if (BORDER_IS_WIDGET (basep)) + basep_border_queue_recalc (basep->screen, basep->monitor); + } + + static void + set_tip (GtkWidget *widget, gboolean showing) + { + if (showing) + gtk_tooltips_set_tip (panel_tooltips, widget, + _("Hide this panel"), NULL); + else + gtk_tooltips_set_tip (panel_tooltips, widget, + _("Show this panel"), NULL); + } + + static void + setup_hidebuttons (BasePWidget *basep) + { + /* + * If the state is SHOWN or HIDDEN_LEFT or HIDDEN_RIGHT + * we update the tooltips on the buttons, and sensitivity. Offscreen + * stuff is insensitive. + */ + if (basep->state == BASEP_SHOWN) { + gtk_widget_set_sensitive (basep->panel, TRUE); + gtk_widget_set_sensitive (basep->hidebutton_w, TRUE); + gtk_widget_set_sensitive (basep->hidebutton_n, TRUE); + gtk_widget_set_sensitive (basep->hidebutton_s, TRUE); + gtk_widget_set_sensitive (basep->hidebutton_e, TRUE); + + set_tip (basep->hidebutton_w, TRUE); + set_tip (basep->hidebutton_n, TRUE); + set_tip (basep->hidebutton_s, TRUE); + set_tip (basep->hidebutton_e, TRUE); + + /* move focus nicely in case orientation changed on us */ + if (PANEL_WIDGET (basep->panel)->orient == + GTK_ORIENTATION_VERTICAL) { + if (GTK_WINDOW (basep)->focus_widget == basep->hidebutton_e) + gtk_window_set_focus (GTK_WINDOW (basep), + basep->hidebutton_s); + else if (GTK_WINDOW (basep)->focus_widget == basep->hidebutton_w) + gtk_window_set_focus (GTK_WINDOW (basep), + basep->hidebutton_n); + } else { + if (GTK_WINDOW (basep)->focus_widget == basep->hidebutton_n) + gtk_window_set_focus (GTK_WINDOW (basep), + basep->hidebutton_w); + else if (GTK_WINDOW (basep)->focus_widget == basep->hidebutton_s) + gtk_window_set_focus (GTK_WINDOW (basep), + basep->hidebutton_e); + } + } else if (basep->state == BASEP_HIDDEN_LEFT) { + GtkWidget *hb; + gboolean set_focus = FALSE; + + if (PANEL_WIDGET (basep->panel)->orient == + GTK_ORIENTATION_VERTICAL) { + hb = basep->hidebutton_s; + if (GTK_WINDOW (basep)->focus_widget == basep->hidebutton_n || + GTK_WINDOW (basep)->focus_widget == basep->hidebutton_e || + GTK_WINDOW (basep)->focus_widget == basep->hidebutton_w) + set_focus = TRUE; + } else { + hb = basep->hidebutton_e; + if (GTK_WINDOW (basep)->focus_widget == basep->hidebutton_w || + GTK_WINDOW (basep)->focus_widget == basep->hidebutton_n || + GTK_WINDOW (basep)->focus_widget == basep->hidebutton_s) + set_focus = TRUE; + } + + + gtk_widget_set_sensitive (basep->panel, FALSE); + + gtk_widget_set_sensitive (basep->hidebutton_w, FALSE); + gtk_widget_set_sensitive (basep->hidebutton_n, FALSE); + gtk_widget_set_sensitive (basep->hidebutton_s, FALSE); + gtk_widget_set_sensitive (basep->hidebutton_e, FALSE); + + set_tip (hb, FALSE); + gtk_widget_set_sensitive (hb, TRUE); + if (set_focus) + gtk_window_set_focus (GTK_WINDOW (basep), hb); + } else if (basep->state == BASEP_HIDDEN_RIGHT) { + GtkWidget *hb; + gboolean set_focus = FALSE; + + if (PANEL_WIDGET (basep->panel)->orient == + GTK_ORIENTATION_VERTICAL) { + hb = basep->hidebutton_n; + if (GTK_WINDOW (basep)->focus_widget == basep->hidebutton_s || + GTK_WINDOW (basep)->focus_widget == basep->hidebutton_e || + GTK_WINDOW (basep)->focus_widget == basep->hidebutton_w) + set_focus = TRUE; + } else { + hb = basep->hidebutton_w; + if (GTK_WINDOW (basep)->focus_widget == basep->hidebutton_e || + GTK_WINDOW (basep)->focus_widget == basep->hidebutton_n || + GTK_WINDOW (basep)->focus_widget == basep->hidebutton_s) + set_focus = TRUE; + } + + gtk_widget_set_sensitive (basep->panel, FALSE); + + gtk_widget_set_sensitive (basep->hidebutton_w, FALSE); + gtk_widget_set_sensitive (basep->hidebutton_n, FALSE); + gtk_widget_set_sensitive (basep->hidebutton_s, FALSE); + gtk_widget_set_sensitive (basep->hidebutton_e, FALSE); + + set_tip (hb, FALSE); + gtk_widget_set_sensitive (hb, TRUE); + if (set_focus) + gtk_window_set_focus (GTK_WINDOW (basep), hb); + } + } + + + static void + basep_widget_state_change (BasePWidget *basep, BasePState old_state) + { + if (BORDER_IS_WIDGET (basep)) + basep_border_queue_recalc (basep->screen, basep->monitor); + + setup_hidebuttons (basep); + } + + static void + basep_widget_real_screen_change (BasePWidget *basep, + int old_screen, + int old_monitor) + { + if (basep->screen != old_screen) { + gtk_widget_hide (GTK_WIDGET (basep)); + gtk_window_set_screen ( + GTK_WINDOW (basep), + panel_screen_from_number (basep->screen)); + gtk_widget_show (GTK_WIDGET (basep)); + } + + basep_border_queue_recalc (old_screen, old_monitor); + + /* this will queue border recalc in the new screen */ + gtk_widget_queue_resize (GTK_WIDGET (basep)); + panels_to_sync = TRUE; + + update_config_screen (basep); + } + + /* pos core */ + + static BasePPosClass * + basep_widget_get_pos_class (BasePWidget *basep) { + BasePPosClass *klass; + + g_return_val_if_fail (BASEP_IS_WIDGET(basep), NULL); + g_return_val_if_fail (BASEP_IS_POS(basep->pos), NULL); + + klass = BASEP_POS_GET_CLASS(basep); + + g_return_val_if_fail (BASEP_IS_POS_CLASS (klass), NULL); + + return klass; + } + + GType + basep_pos_get_type (void) + { + static GType object_type = 0; + if (object_type == 0) { + static const GTypeInfo object_info = { + sizeof (BasePPosClass), + (GBaseInitFunc) NULL, + (GBaseFinalizeFunc) NULL, + (GClassInitFunc) basep_pos_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (BasePPos), + 0, /* n_preallocs */ + (GInstanceInitFunc) basep_pos_instance_init + }; + object_type = g_type_register_static + (G_TYPE_OBJECT, "BasePPos", &object_info, 0); + basep_pos_parent_class = g_type_class_ref (G_TYPE_OBJECT); + } + return object_type; + } + + static void + basep_pos_get_hide_size (BasePWidget *basep, + PanelOrient hide_orient, + int *w, int *h) + { + switch (hide_orient) { + case PANEL_ORIENT_UP: + case PANEL_ORIENT_DOWN: + *h = (basep->state == BASEP_AUTO_HIDDEN) + ? global_config.minimized_size + : get_requisition_height (basep->hidebutton_n); + break; + case PANEL_ORIENT_RIGHT: + case PANEL_ORIENT_LEFT: + *w = (basep->state == BASEP_AUTO_HIDDEN) + ? global_config.minimized_size + : get_requisition_width (basep->hidebutton_e); + break; + } + *w = MAX (*w, 1); + *h = MAX (*h, 1); + } + + static void + basep_pos_get_hide_pos (BasePWidget *basep, + PanelOrient hide_orient, + int *x, int *y, + int w, int h) + { + switch (hide_orient) { + case PANEL_ORIENT_UP: + case PANEL_ORIENT_LEFT: + break; + case PANEL_ORIENT_RIGHT: + *x += w - ((basep->state == BASEP_AUTO_HIDDEN) + ? global_config.minimized_size + : get_requisition_width (basep->hidebutton_w)); + break; + case PANEL_ORIENT_DOWN: + *y += h - ((basep->state == BASEP_AUTO_HIDDEN) + ? global_config.minimized_size + : get_requisition_height (basep->hidebutton_s)); + break; + } + } + + static void + basep_pos_class_init (BasePPosClass *klass) + { + basep_pos_parent_class = g_type_class_ref (gtk_object_get_type ()); + + klass->get_hide_size = basep_pos_get_hide_size; + klass->get_hide_pos = basep_pos_get_hide_pos; + } + + /* nothing to see here... */ + static void + basep_pos_instance_init (BasePPos *pos) + { + return; + } + + static int + basep_widget_focus_in_event (GtkWidget *widget, + GdkEventFocus *event) + { + #if 0 + BasePWidget *basep = BASEP_WIDGET (widget); + + /* FIXME: #89180 - we should show explicitly hidden + * panels here. + * + * When we have focus and hit ctrl-alt-tab with + * Metacity, it does a grab and we a FocusChange + * event because gdk doesn't ignore NotifyGrab + * FocusChange events. See #ifdefed out case + * in gdkevents-x11.c. This is detailed in #89179, + * which blocks #89180. + */ + else if (basep->state == BASEP_HIDDEN_LEFT || + basep->state == BASEP_HIDDEN_RIGHT) + basep_widget_explicit_show (basep); + #endif + + return GTK_WIDGET_CLASS (basep_widget_parent_class)->focus_in_event (widget, event); + } + + static BasePWidget * + find_non_drawer_parent_panel (BasePWidget *basep) + { + BasePWidget *retval = NULL; + Drawer *drawer; + GtkWidget *panel_parent; + + g_assert (DRAWER_IS_WIDGET (basep)); + + drawer = drawer_widget_get_drawer (DRAWER_WIDGET (basep)); + if (!drawer) + return NULL; + + panel_parent = PANEL_WIDGET (drawer->button->parent)->panel_parent; + + if (BASEP_IS_WIDGET (panel_parent)) + retval = BASEP_WIDGET (panel_parent); + else if (FOOBAR_IS_WIDGET (panel_parent)) + return NULL; + + if (DRAWER_IS_WIDGET (retval)) + retval = find_non_drawer_parent_panel (retval); + + return retval; + } + + static gboolean + basep_leave_notify (GtkWidget *widget, + GdkEventCrossing *event) + { + BasePWidget *basep = BASEP_WIDGET (widget); + + if (event->detail == GDK_NOTIFY_INFERIOR) + return FALSE; + + if (DRAWER_IS_WIDGET (basep)) + basep = find_non_drawer_parent_panel (basep); + + if (basep) + basep_widget_queue_autohide (basep); + + if (GTK_WIDGET_CLASS (basep_widget_parent_class)->leave_notify_event) + return GTK_WIDGET_CLASS (basep_widget_parent_class)->leave_notify_event (widget, event); + else + return FALSE; + } + + static gboolean + basep_enter_notify (GtkWidget *widget, + GdkEventCrossing *event) + { + BasePWidget *basep = BASEP_WIDGET (widget); + + if (basep->state == BASEP_AUTO_HIDDEN && + event->detail != GDK_NOTIFY_INFERIOR) { + + g_assert (basep->mode == BASEP_AUTO_HIDE); + + if (basep->leave_notify_timer_tag != 0) { + g_source_remove (basep->leave_notify_timer_tag); + basep->leave_notify_timer_tag = 0; + } + + basep_widget_queue_autoshow (basep); + } + + if (GTK_WIDGET_CLASS (basep_widget_parent_class)->enter_notify_event) + return GTK_WIDGET_CLASS (basep_widget_parent_class)->enter_notify_event (widget, event); + else + return FALSE; + } + + void + basep_widget_get_position (BasePWidget *basep, PanelOrient hide_orient, + int *x, int *y, int w, int h) + { + *x = *y = 0; + switch(hide_orient) { + case PANEL_ORIENT_UP: + if(h < basep->shown_alloc.height) + *y = h - basep->shown_alloc.height; + break; + case PANEL_ORIENT_LEFT: + if(w < basep->shown_alloc.width) + *x = w - basep->shown_alloc.width; + break; + default: + break; + } + } + + static void + basep_widget_set_ebox_orient(BasePWidget *basep, + PanelOrient hide_orient) + { + XSetWindowAttributes xattributes; + + switch(hide_orient) { + case PANEL_ORIENT_UP: + case PANEL_ORIENT_LEFT: + xattributes.win_gravity = SouthEastGravity; + break; + case PANEL_ORIENT_DOWN: + case PANEL_ORIENT_RIGHT: + default: + xattributes.win_gravity = NorthWestGravity; + break; + } + + XChangeWindowAttributes (GDK_WINDOW_XDISPLAY(basep->ebox->window), + GDK_WINDOW_XWINDOW(basep->ebox->window), + CWWinGravity, &xattributes); + + } + + static int + move_step(int src, int dest, long start_time, long end_time, long cur_time) + { + double n, d, percentage; + + if(src == dest) + return dest; + + n = cur_time-start_time; + d = end_time-start_time; + + if(n1.0) + percentage = 1.0; + } else + percentage = 1.0; + + return src + ((dest - src)*percentage); + } + + void + basep_widget_do_hiding(BasePWidget *basep, PanelOrient hide_orient, + int leftover, PanelSpeed animation_step) + { + GtkWidget *wid; + int ox,oy,ow,oh; + int x,y,w,h; + int dx,dy,dw,dh; + int diff; + int step; + + g_return_if_fail(BASEP_IS_WIDGET(basep)); + + switch (animation_step) { + case PANEL_SPEED_SLOW: + step = PANEL_SLOW_STEP_SIZE; + break; + case PANEL_SPEED_MEDIUM: + step = PANEL_MEDIUM_STEP_SIZE; + break; + case PANEL_SPEED_FAST: + step = PANEL_FAST_STEP_SIZE; + break; + default: + step = PANEL_MEDIUM_STEP_SIZE; + break; + } + + wid = GTK_WIDGET(basep); + + ox = x = basep->shown_alloc.x; + oy = y = basep->shown_alloc.y; + ow = w = basep->shown_alloc.width; + oh = h = basep->shown_alloc.height; + + switch(hide_orient) { + case PANEL_ORIENT_UP: + diff = h-leftover; + dx = x; + dy = y; + dw = w; + dh = leftover; + break; + case PANEL_ORIENT_DOWN: + diff = h-leftover; + dx = x; + dy = y+h-leftover; + dw = w; + dh = leftover; + break; + case PANEL_ORIENT_LEFT: + diff = w-leftover; + dx = x; + dy = y; + dw = leftover; + dh = h; + break; + case PANEL_ORIENT_RIGHT: + diff = w-leftover; + dx = x+w-leftover; + dy = y; + dw = leftover; + dh = h; + break; + default: + /*fix warning*/ dx = dy = dw = dh = 0; + diff = 1; + g_assert_not_reached(); + break; + } + + if (global_config.enable_animations && step != 0) { + GTimeVal tval; + long start_secs; + long start_time; + long end_time; + long cur_time; + + g_get_current_time(&tval); + + start_secs = tval.tv_sec; + start_time = tval.tv_usec; + + end_time = start_time + + (diff/1000.0)*200*(10001-(step*step)); + + basep_widget_set_ebox_orient(basep, hide_orient); + + while(x != dx || + y != dy || + w != dw || + h != dh) { + g_get_current_time(&tval); + + cur_time = ((tval.tv_sec-start_secs)*1000000) + + tval.tv_usec; + + x = move_step(ox,dx,start_time,end_time,cur_time); + y = move_step(oy,dy,start_time,end_time,cur_time); + w = move_step(ow,dw,start_time,end_time,cur_time); + h = move_step(oh,dh,start_time,end_time,cur_time); + xstuff_set_pos_size (wid->window, x, y, w, h); + g_usleep (1000); + } + + xstuff_set_pos_size (wid->window, + dx, dy, dw, dh); + basep_widget_set_ebox_orient(basep, -1); + } + + gtk_widget_queue_resize(wid); + gtk_widget_queue_draw (basep->table); + } + + void + basep_widget_do_showing(BasePWidget *basep, PanelOrient hide_orient, + int leftover, PanelSpeed animation_step) + { + GtkWidget *wid; + int x,y, dx,dy, ox,oy; + int w,h, dw,dh, ow,oh; + int diff; + int step; + + g_return_if_fail(BASEP_IS_WIDGET(basep)); + + switch (animation_step) { + case PANEL_SPEED_MEDIUM: + step = PANEL_MEDIUM_STEP_SIZE; + break; + case PANEL_SPEED_SLOW: + step = PANEL_SLOW_STEP_SIZE; + break; + case PANEL_SPEED_FAST: + step = PANEL_FAST_STEP_SIZE; + break; + default: + step = PANEL_MEDIUM_STEP_SIZE; + } + + wid = GTK_WIDGET(basep); + + ox = dx = x = basep->shown_alloc.x; + oy = dy = y = basep->shown_alloc.y; + dw = basep->shown_alloc.width; + dh = basep->shown_alloc.height; + + switch(hide_orient) { + case PANEL_ORIENT_UP: + ow = w = dw; + oh = h = leftover; + diff = dh-leftover; + break; + case PANEL_ORIENT_DOWN: + oy = y + dh - leftover; + ow = w = dw; + oh = h = leftover; + diff = dh-leftover; + break; + case PANEL_ORIENT_LEFT: + ow = w = leftover; + oh = h = dh; + diff = dw-leftover; + break; + case PANEL_ORIENT_RIGHT: + ox = x + dw - leftover; + ow = w = leftover; + oh = h = dh; + diff = dw-leftover; + break; + default: + /*fix warning*/ dx = dy = ow = oh = w = h = 0; + diff = 1; + g_assert_not_reached(); + break; + } + + if (global_config.enable_animations && step != 0) { + int i; + GTimeVal tval; + long start_secs; + long start_time; + long end_time; + long cur_time; + + g_get_current_time(&tval); + + start_secs = tval.tv_sec; + start_time = tval.tv_usec; + + end_time = start_time + + (diff/1000.0)*200*(10001-(step*step)); + + basep_widget_set_ebox_orient(basep, hide_orient); + gdk_window_show(wid->window); + xstuff_set_pos_size (wid->window, + ox, oy, ow, oh); + + gtk_widget_show_now(wid); + + gdk_window_show(wid->window); + i = 0; + while(x != dx || + y != dy || + w != dw || + h != dh) { + g_get_current_time(&tval); + + cur_time = ((tval.tv_sec-start_secs)*1000000) + + tval.tv_usec; + + x = move_step(ox,dx,start_time,end_time,cur_time); + y = move_step(oy,dy,start_time,end_time,cur_time); + w = move_step(ow,dw,start_time,end_time,cur_time); + h = move_step(oh,dh,start_time,end_time,cur_time); + xstuff_set_pos_size (wid->window, x, y, w, h); + + /*drawing the entire table flickers, so don't + do it often*/ + /* FIXME: does it still flicker? */ + /* FIXME: sometimes this updates, sometimes it doesn't + * see bug #81654 */ + if (i++ % 10) { + /* FIXME: is invalidation needed, and if so it should only be + * partial */ + gdk_window_invalidate_rect (basep->panel->window, + NULL, TRUE); + gdk_window_process_updates (basep->panel->window, TRUE); + } else { + gdk_window_invalidate_rect (GTK_WIDGET (basep)->window, + NULL, TRUE); + gdk_window_process_updates (GTK_WIDGET (basep)->window, TRUE); + } + gdk_flush(); + g_usleep (1000); + } + + xstuff_set_pos_size (wid->window, + dx, dy, dw, dh); + + basep_widget_set_ebox_orient(basep, -1); + } + + gtk_widget_queue_draw (basep->table); + gtk_widget_queue_resize (wid); + } + + + static GtkWidget * + make_hidebutton (BasePWidget *basep, + const char *arrow_stock_id, + gboolean horizontal) + { + GtkWidget *button; + GtkWidget *pixmap; + + button = gtk_button_new (); + GTK_WIDGET_UNSET_FLAGS (button, GTK_CAN_DEFAULT); + + if (horizontal) + gtk_widget_set_size_request (button, -1, PANEL_MINIMUM_WIDTH); + else + gtk_widget_set_size_request (button, PANEL_MINIMUM_WIDTH, -1); + + pixmap = gtk_image_new_from_stock ( + arrow_stock_id, panel_button_icon_get_size ()); + gtk_widget_show (pixmap); + + gtk_container_add (GTK_CONTAINER (button), pixmap); + g_object_set_data (G_OBJECT (button), "gnome_disable_sound_events", + GINT_TO_POINTER (TRUE)); + + set_tip (button, TRUE); + + return button; + } + + static void + basep_widget_destroy (GtkObject *o) + { + BasePWidget *basep = BASEP_WIDGET (o); + /* check if there's a timeout set, and delete it if + * there was */ + if (basep->leave_notify_timer_tag != 0) + g_source_remove (basep->leave_notify_timer_tag); + basep->leave_notify_timer_tag = 0; + + if (basep->pos) { + if (BORDER_IS_WIDGET (basep)) + basep_border_queue_recalc ( + basep->screen, basep->monitor); + g_object_unref (basep->pos); + } + basep->pos = NULL; + + if (GTK_OBJECT_CLASS (basep_widget_parent_class)->destroy) + GTK_OBJECT_CLASS (basep_widget_parent_class)->destroy (o); + + } + + static void + reparent_button_widgets(GtkWidget *w, gpointer data) + { + GdkWindow *newwin = data; + if(BUTTON_IS_WIDGET (w)) { + GtkButton *button = GTK_BUTTON (w); + /* we can just reparent them all to 0,0 as the next thing + * that will happen is a queue_resize and on size allocate + * they will be put into their proper place */ + gdk_window_reparent(button->event_window, newwin, 0, 0); + } + } + + void + basep_widget_redo_window(BasePWidget *basep) + { + GtkWindow *window; + GtkWidget *widget; + GdkWindowAttr attributes; + gint attributes_mask; + GdkWindow *oldwin; + GdkWindow *newwin; + gboolean comp; + + comp = xstuff_is_compliant_wm(); + if(comp == basep->compliant_wm) + return; + + window = GTK_WINDOW(basep); + widget = GTK_WIDGET(basep); + + basep->compliant_wm = comp; + if(basep->compliant_wm) { + window->type = GTK_WINDOW_TOPLEVEL; + attributes.window_type = GDK_WINDOW_TOPLEVEL; + } else { + window->type = GTK_WINDOW_POPUP; + attributes.window_type = GDK_WINDOW_TEMP; + } + + if(!widget->window) + return; + + /* this is mostly copied from gtkwindow.c realize method */ + attributes.title = window->title; + attributes.wmclass_name = window->wmclass_name; + attributes.wmclass_class = window->wmclass_class; + attributes.width = widget->allocation.width; + attributes.height = widget->allocation.height; + attributes.wclass = GDK_INPUT_OUTPUT; + attributes.visual = gtk_widget_get_visual (widget); + attributes.colormap = gtk_widget_get_colormap (widget); + attributes.event_mask = gtk_widget_get_events (widget); + attributes.event_mask |= (GDK_EXPOSURE_MASK | + GDK_KEY_PRESS_MASK | + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK | + GDK_FOCUS_CHANGE_MASK | + GDK_STRUCTURE_MASK); + + attributes_mask = GDK_WA_VISUAL | GDK_WA_COLORMAP; + attributes_mask |= (window->title ? GDK_WA_TITLE : 0); + attributes_mask |= (window->wmclass_name ? GDK_WA_WMCLASS : 0); + + oldwin = widget->window; + + newwin = gdk_window_new(NULL, &attributes, attributes_mask); + gdk_window_set_user_data(newwin, window); + + xstuff_set_no_group_and_no_input (newwin); + + /* reparent our main panel window */ + gdk_window_reparent(basep->ebox->window, newwin, 0, 0); + /* reparent all the base event windows as they are also children of + * the basep */ + gtk_container_foreach(GTK_CONTAINER(basep->panel), + reparent_button_widgets, + newwin); + + + widget->window = newwin; + + gdk_window_set_user_data(oldwin, NULL); + gdk_window_destroy(oldwin); + + widget->style = gtk_style_attach(widget->style, widget->window); + gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL); + + GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED); + + gtk_widget_queue_resize(widget); + + basep_widget_update_winhints (basep); + + if (basep->strut_left != 0 || + basep->strut_right != 0 || + basep->strut_top != 0 || + basep->strut_bottom != 0) { + xstuff_set_wmspec_strut (widget->window, + basep->strut_left, + basep->strut_right, + basep->strut_top, + basep->strut_bottom); + } + + gtk_drag_dest_set (widget, 0, NULL, 0, 0); + + gtk_widget_map(widget); + } + + + static void + basep_widget_instance_init (BasePWidget *basep) + { + basep->screen = 0; + basep->monitor = 0; + + /*if we set the gnomewm hints it will have to be changed to TOPLEVEL*/ + basep->compliant_wm = xstuff_is_compliant_wm(); + if(basep->compliant_wm) + GTK_WINDOW(basep)->type = GTK_WINDOW_TOPLEVEL; + else + GTK_WINDOW(basep)->type = GTK_WINDOW_POPUP; + + GTK_WINDOW(basep)->allow_shrink = TRUE; + GTK_WINDOW(basep)->allow_grow = TRUE; + + /*don't let us close the window*/ + + g_signal_connect(G_OBJECT(basep),"delete_event", + G_CALLBACK (gtk_true), NULL); + + basep->shown_alloc.x = basep->shown_alloc.y = + basep->shown_alloc.width = basep->shown_alloc.height = 0; + + /*this makes the popup "pop down" once the button is released*/ + gtk_widget_set_events(GTK_WIDGET(basep), + gtk_widget_get_events(GTK_WIDGET(basep)) | + GDK_BUTTON_RELEASE_MASK); + + basep->ebox = gtk_event_box_new(); + gtk_container_add(GTK_CONTAINER(basep),basep->ebox); + gtk_widget_show(basep->ebox); + + basep->table = gtk_table_new(3,3,FALSE); + gtk_widget_set_direction (basep->table, GTK_TEXT_DIR_LTR); + gtk_container_add(GTK_CONTAINER(basep->ebox),basep->table); + gtk_widget_show(basep->table); + + basep->frame = gtk_frame_new(NULL); + gtk_frame_set_shadow_type(GTK_FRAME(basep->frame),GTK_SHADOW_OUT); + + gtk_table_attach(GTK_TABLE(basep->table),basep->frame,1,2,1,2, + GTK_FILL|GTK_EXPAND|GTK_SHRINK, + GTK_FILL|GTK_EXPAND|GTK_SHRINK, + 0,0); + + basep->innerebox = gtk_event_box_new(); + + gtk_table_attach(GTK_TABLE(basep->table),basep->innerebox,1,2,1,2, + GTK_FILL|GTK_EXPAND|GTK_SHRINK, + GTK_FILL|GTK_EXPAND|GTK_SHRINK, + 0,0); + + g_object_set (G_OBJECT (basep), + "mode", BASEP_EXPLICIT_HIDE, + "state", BASEP_SHOWN, + "hidebuttons_enabled", TRUE, + "hidebutton_pixmaps_enabled", TRUE, + NULL); + + basep->leave_notify_timer_tag = 0; + basep->autohide_inhibit = FALSE; + basep->drawers_open = 0; + } + + static void + show_hidebutton_pixmap (GtkWidget *hidebutton, gboolean show) + { + GtkWidget *pixmap = GTK_BIN (hidebutton)->child; + + if (pixmap == NULL) + return; + + if (show) + gtk_widget_show (pixmap); + else + gtk_widget_hide (pixmap); + } + + static void + basep_widget_show_hidebutton_pixmaps (BasePWidget *basep) + { + gboolean show = basep->hidebutton_pixmaps_enabled; + show_hidebutton_pixmap (basep->hidebutton_n, show); + show_hidebutton_pixmap (basep->hidebutton_e, show); + show_hidebutton_pixmap (basep->hidebutton_w, show); + show_hidebutton_pixmap (basep->hidebutton_s, show); + } + + void + basep_widget_update_winhints (BasePWidget *basep) + { + GtkWidget *w = GTK_WIDGET (basep); + + gtk_window_set_decorated (GTK_WINDOW (w), FALSE); + gtk_window_stick (GTK_WINDOW (w)); + + xstuff_set_wmspec_dock_hints (w->window, + (basep->mode == BASEP_AUTO_HIDE)); + + /* FIXME: non-compliance should be tested! */ + + if (BASEP_POS_GET_CLASS (basep)->update_winhints != NULL) + BASEP_POS_GET_CLASS (basep)->update_winhints (basep); + + } + + void + basep_update_frame (BasePWidget *basep) + { + PanelWidget *panel; + gboolean hide_frame = FALSE; + + g_return_if_fail (PANEL_IS_WIDGET (basep->panel)); + + panel = PANEL_WIDGET (basep->panel); + + if (panel->background.type == PANEL_BACK_IMAGE || + panel->background.type == PANEL_BACK_COLOR) + hide_frame = TRUE; + + if (hide_frame && GTK_WIDGET_VISIBLE (basep->frame)) { + gtk_widget_show (basep->innerebox); + gtk_widget_reparent (GTK_WIDGET (panel), basep->innerebox); + gtk_widget_hide (basep->frame); + } else if (!hide_frame && !GTK_WIDGET_VISIBLE (basep->frame)) { + gtk_widget_show (basep->frame); + gtk_widget_reparent (GTK_WIDGET (panel), basep->frame); + gtk_widget_hide (basep->innerebox); + } + } + + static void + basep_back_change (PanelWidget *panel, gpointer data) + { + BasePWidget *basep = BASEP_WIDGET (data); + basep_update_frame (basep); + + panel_set_frame_colors (panel, + basep->frame, + basep->hidebutton_n, + basep->hidebutton_e, + basep->hidebutton_w, + basep->hidebutton_s); + } + + static void + basep_orient_change (PanelWidget *panel, gpointer data) + { + BasePWidget *basep = BASEP_WIDGET (data); + setup_hidebuttons (basep); + } + + static void + basep_style_set (GtkWidget *widget, GtkStyle *previous_style) + { + BasePWidget *basep; + PanelWidget *panel; + + g_return_if_fail (BASEP_IS_WIDGET (widget)); + + basep = BASEP_WIDGET (widget); + + g_return_if_fail (basep->panel != NULL); + g_return_if_fail (PANEL_IS_WIDGET (basep->panel)); + + panel = PANEL_WIDGET (basep->panel); + + if (GTK_WIDGET_CLASS (basep_widget_parent_class)->style_set) + GTK_WIDGET_CLASS (basep_widget_parent_class)->style_set (widget, previous_style); + + panel_set_frame_colors (panel, + basep->frame, + basep->hidebutton_n, + basep->hidebutton_e, + basep->hidebutton_w, + basep->hidebutton_s); + } + + static void + basep_widget_north_clicked (GtkWidget *widget, gpointer data) + { + BasePWidget *basep = data; + BasePPosClass *klass = + basep_widget_get_pos_class (basep); + + gtk_widget_set_state (widget, GTK_STATE_NORMAL); + gtk_widget_queue_draw (widget); + + if (klass && klass->north_clicked) + klass->north_clicked(basep); + } + + static void + basep_widget_south_clicked (GtkWidget *widget, gpointer data) + { + BasePWidget *basep = data; + BasePPosClass *klass = + basep_widget_get_pos_class (basep); + + gtk_widget_set_state (widget, GTK_STATE_NORMAL); + gtk_widget_queue_draw (widget); + + if (klass && klass->south_clicked) + klass->south_clicked(basep); + } + + static void + basep_widget_east_clicked (GtkWidget *widget, gpointer data) + { + BasePWidget *basep = data; + BasePPosClass *klass = + basep_widget_get_pos_class (basep); + + gtk_widget_set_state (widget, GTK_STATE_NORMAL); + gtk_widget_queue_draw (widget); + + if (klass && klass->east_clicked) + klass->east_clicked(basep); + } + + static void + basep_widget_west_clicked (GtkWidget *widget, gpointer data) + { + BasePWidget *basep = data; + BasePPosClass *klass = + basep_widget_get_pos_class (basep); + + gtk_widget_set_state (widget, GTK_STATE_NORMAL); + gtk_widget_queue_draw (widget); + + if (klass && klass->west_clicked) + klass->west_clicked(basep); + } + + GtkWidget* + basep_widget_construct (const char *panel_id, + BasePWidget *basep, + gboolean packed, + gboolean reverse_arrows, + int screen, + int monitor, + GtkOrientation orient, + int sz, + BasePMode mode, + BasePState state, + gboolean hidebuttons_enabled, + gboolean hidebutton_pixmaps_enabled, + PanelBackgroundType back_type, + const char *back_pixmap, + gboolean fit_pixmap_bg, + gboolean stretch_pixmap_bg, + gboolean rotate_pixmap_bg, + PanelColor *back_color) + { + BasePPosClass *klass = basep_widget_get_pos_class (basep); + GList *focus_chain = NULL; + int x = 0, y = 0; + + gtk_window_set_screen (GTK_WINDOW (basep), + panel_screen_from_number (screen)); + + basep->panel = panel_widget_new(panel_id, + packed, + orient, + sz, + back_type, + back_pixmap, + fit_pixmap_bg, + stretch_pixmap_bg, + rotate_pixmap_bg, + back_color); + + g_signal_connect_after (G_OBJECT (basep->panel), "orient_change", + G_CALLBACK (basep_orient_change), + basep); + + g_signal_connect_after (G_OBJECT (basep->panel), "back_change", + G_CALLBACK (basep_back_change), + basep); + + PANEL_WIDGET(basep->panel)->panel_parent = GTK_WIDGET(basep); + PANEL_WIDGET(basep->panel)->drop_widget = GTK_WIDGET(basep); + + gtk_widget_show(basep->panel); + + if (back_type != PANEL_BACK_IMAGE && + back_type != PANEL_BACK_COLOR) { + gtk_widget_show (basep->frame); + gtk_container_add (GTK_CONTAINER (basep->frame), basep->panel); + } else { + gtk_widget_show (basep->innerebox); + gtk_container_add (GTK_CONTAINER (basep->innerebox), basep->panel); + } + + /*we add all the hide buttons to the table here*/ + /*WEST*/ + basep->hidebutton_w = make_hidebutton(basep, + reverse_arrows? + PANEL_STOCK_ARROW_RIGHT: + PANEL_STOCK_ARROW_LEFT, + TRUE); + gtk_table_attach(GTK_TABLE(basep->table),basep->hidebutton_w, + 0,1,1,2,GTK_FILL,GTK_FILL,0,0); + g_signal_connect (G_OBJECT (basep->hidebutton_w), "clicked", + G_CALLBACK (basep_widget_west_clicked), + basep); + /*NORTH*/ + basep->hidebutton_n = make_hidebutton(basep, + reverse_arrows? + PANEL_STOCK_ARROW_DOWN: + PANEL_STOCK_ARROW_UP, + FALSE); + gtk_table_attach(GTK_TABLE(basep->table),basep->hidebutton_n, + 1,2,0,1,GTK_FILL,GTK_FILL,0,0); + g_signal_connect (G_OBJECT (basep->hidebutton_n), "clicked", + G_CALLBACK (basep_widget_north_clicked), + basep); + /*EAST*/ + basep->hidebutton_e = make_hidebutton(basep, + reverse_arrows? + PANEL_STOCK_ARROW_LEFT: + PANEL_STOCK_ARROW_RIGHT, + TRUE); + gtk_table_attach(GTK_TABLE(basep->table),basep->hidebutton_e, + 2,3,1,2,GTK_FILL,GTK_FILL,0,0); + g_signal_connect (G_OBJECT (basep->hidebutton_e), "clicked", + G_CALLBACK (basep_widget_east_clicked), + basep); + /*SOUTH*/ + basep->hidebutton_s = make_hidebutton (basep, + reverse_arrows ? + PANEL_STOCK_ARROW_UP: + PANEL_STOCK_ARROW_DOWN, + FALSE); + gtk_table_attach(GTK_TABLE(basep->table), basep->hidebutton_s, + 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); + g_signal_connect (G_OBJECT (basep->hidebutton_s), "clicked", + G_CALLBACK (basep_widget_south_clicked), + basep); + + basep->screen = screen; + basep->monitor = monitor; + + basep->hidebuttons_enabled = hidebuttons_enabled; + basep->hidebutton_pixmaps_enabled = hidebutton_pixmaps_enabled; + + /* + * Set focus chain so that focus goes initially to panel. + */ + focus_chain = g_list_prepend (focus_chain, basep->hidebutton_s); + focus_chain = g_list_prepend (focus_chain, basep->hidebutton_e); + focus_chain = g_list_prepend (focus_chain, basep->hidebutton_n); + focus_chain = g_list_prepend (focus_chain, basep->hidebutton_w); + focus_chain = g_list_prepend (focus_chain, basep->frame); + focus_chain = g_list_prepend (focus_chain, basep->innerebox); + gtk_container_set_focus_chain (GTK_CONTAINER (basep->table), focus_chain); + g_list_free (focus_chain); + + basep_widget_set_hidebuttons (basep); + basep_widget_show_hidebutton_pixmaps (basep); + + basep->mode = mode; + basep->state = state; + + g_object_ref (basep->pos); + basep->pos->basep = basep; + + if (state == BASEP_AUTO_HIDDEN && + mode != BASEP_AUTO_HIDE) + basep->state = BASEP_SHOWN; + + /* setup the hide buttons stuff according to state */ + setup_hidebuttons (basep); + + basep_update_frame (basep); + + if (klass->get_pos) + klass->get_pos (basep, &x, &y, + PANEL_MINIMUM_WIDTH, + PANEL_MINIMUM_WIDTH); + gtk_window_move (GTK_WINDOW (basep), x, y); + + return GTK_WIDGET (basep); + } + + void + basep_widget_change_params (BasePWidget *basep, + int screen, + int monitor, + GtkOrientation orient, + int sz, + BasePMode mode, + BasePState state, + gboolean hidebuttons_enabled, + gboolean hidebutton_pixmaps_enabled, + PanelBackgroundType back_type, + const char *pixmap_name, + gboolean fit_pixmap_bg, + gboolean stretch_pixmap_bg, + gboolean rotate_pixmap_bg, + PanelColor *back_color) + { + g_return_if_fail(GTK_WIDGET_REALIZED(GTK_WIDGET(basep))); + + if (PANEL_WIDGET (basep->panel)->orient != orient) + basep->request_cube = TRUE; + + basep->hidebuttons_enabled = hidebuttons_enabled; + basep->hidebutton_pixmaps_enabled = hidebutton_pixmaps_enabled; + + if (state == BASEP_AUTO_HIDDEN && + mode != BASEP_AUTO_HIDE) + state = BASEP_SHOWN; + + if (mode != basep->mode) { + BasePMode old_mode = basep->mode; + basep->mode = mode; + if (mode == BASEP_AUTO_HIDE) + basep_widget_queue_autohide (basep); + g_signal_emit (G_OBJECT(basep), + basep_widget_signals[MODE_CHANGE_SIGNAL], + 0, old_mode); + } + + if (state != basep->state) { + BasePState old_state = basep->state; + basep->state = state; + if (state != BASEP_AUTO_HIDDEN) + basep_widget_autoshow (basep); + g_signal_emit (G_OBJECT(basep), + basep_widget_signals[STATE_CHANGE_SIGNAL], + 0, old_state); + panels_to_sync = TRUE; + } + + panel_widget_change_params(PANEL_WIDGET(basep->panel), + orient, + sz, + back_type, + pixmap_name, + fit_pixmap_bg, + stretch_pixmap_bg, + rotate_pixmap_bg, + back_color); + + basep_widget_set_hidebuttons (basep); + basep_widget_show_hidebutton_pixmaps (basep); + + basep_widget_screen_change (basep, screen, monitor); + + gtk_widget_queue_resize (GTK_WIDGET (basep)); + } + + #if FIXME + gboolean + basep_widget_convert_to (BasePWidget *basep, + PanelType type) + { + BasePPosClass *klass = + basep_widget_get_pos_class (basep); + BasePPos *old_pos, *new_pos; + gint16 x=0, y=0; + gboolean temp_keep; + + g_return_val_if_fail (BASEP_IS_WIDGET(basep), FALSE); + + g_return_val_if_fail (create_panel_type[type], FALSE); + + basep_widget_get_pos(basep, &x, &y); + + old_pos = basep->pos; + new_pos = gtk_type_new (create_panel_type[type] ()); + + if (!new_pos) + return FALSE; + + basep->pos = new_pos; + new_pos->basep = basep; + + g_object_unref (G_OBJECT (old_pos)); + + klass = basep_widget_get_pos_class (basep); + if (klass->pre_convert_hook) + klass->pre_convert_hook (basep); + + temp_keep = basep->keep_in_screen; + basep->keep_in_screen = FALSE; + gtk_widget_set_uposition (GTK_WIDGET (basep), -100, -100); + gdk_flush (); + basep_widget_set_pos (basep, -100, -100); + gdk_flush (); + g_print ("-------------------------------------\n"); + basep_widget_set_pos (basep, x, y); + basep->keep_in_screen = temp_keep; + g_signal_emit (G_OBJECT(basep), + basep_widget_signals[TYPE_CHANGE_SIGNAL], + 0, type); + + /*gtk_widget_queue_resize (GTK_WIDGET (basep));*/ + return TRUE; + } + #endif + + void + basep_widget_enable_buttons (BasePWidget *basep, + gboolean enabled) + { + gtk_widget_set_sensitive (basep->hidebutton_n, enabled); + gtk_widget_set_sensitive (basep->hidebutton_e, enabled); + gtk_widget_set_sensitive (basep->hidebutton_w, enabled); + gtk_widget_set_sensitive (basep->hidebutton_s, enabled); + } + + void + basep_widget_set_hidebuttons (BasePWidget *basep) + { + BasePPosClass *klass = basep_widget_get_pos_class (basep); + if (!basep->hidebuttons_enabled) { + gtk_widget_hide(basep->hidebutton_n); + gtk_widget_hide(basep->hidebutton_e); + gtk_widget_hide(basep->hidebutton_w); + gtk_widget_hide(basep->hidebutton_s); + + /* if we removed hidebuttons we need to show ourselves, + * except for the drawers case that is */ + if ((basep->state == BASEP_HIDDEN_LEFT || + basep->state == BASEP_HIDDEN_RIGHT) && + ! DRAWER_IS_WIDGET (basep)) + basep_widget_explicit_show (basep); + } else { + g_return_if_fail (klass && klass->set_hidebuttons); + klass->set_hidebuttons(basep); + } + } + + /* FIXME: perhaps we could get rid of the MOVING state, it's kind of + * useless, isn't it? */ + void + basep_widget_explicit_hide (BasePWidget *basep, BasePState state) + { + BasePState old_state; + + g_assert ( (state == BASEP_HIDDEN_RIGHT) || + (state == BASEP_HIDDEN_LEFT) ); + + if ((basep->state != BASEP_SHOWN)) + return; + + if (basep->moving) + return; + + basep->moving = TRUE; + + old_state = basep->state; + basep->state = state; + + g_signal_emit (G_OBJECT (basep), + basep_widget_signals[STATE_CHANGE_SIGNAL], + 0, old_state); + panels_to_sync = TRUE; + + /* if the app did any updating of the interface, flush that for us*/ + gdk_flush(); + + if (GTK_WIDGET_REALIZED(GTK_WIDGET(basep))) { + BasePPosClass *klass = basep_widget_get_pos_class (basep); + PanelOrient hide_orient; + int w, h, size; + + hide_orient = klass->get_hide_orient (basep); + basep_widget_get_size (basep, &w, &h); + klass->get_hide_size (basep, + hide_orient, + &w, &h); + + size = (hide_orient == PANEL_ORIENT_UP || + hide_orient == PANEL_ORIENT_DOWN) ? + h : w; + + basep_widget_update_winhints (basep); + basep_widget_do_hiding (basep, hide_orient, + size, + global_config.animation_speed); + } + + /* + * If the button being hidden has focus move it to the button which + * remains shown. + */ + if (state == BASEP_HIDDEN_RIGHT) { + if (gtk_widget_is_focus (basep->hidebutton_e)) + gtk_widget_grab_focus (basep->hidebutton_w); + else if (gtk_widget_is_focus (basep->hidebutton_s)) + gtk_widget_grab_focus (basep->hidebutton_n); + } else if (state == BASEP_HIDDEN_LEFT) { + if (gtk_widget_is_focus (basep->hidebutton_w)) + gtk_widget_grab_focus (basep->hidebutton_e); + else if (gtk_widget_is_focus (basep->hidebutton_n)) + gtk_widget_grab_focus (basep->hidebutton_s); + } + + basep->moving = FALSE; + + basep_widget_update_winhints (basep); + } + + void + basep_widget_explicit_show (BasePWidget *basep) + { + BasePState old_state; + + if ( (basep->state != BASEP_HIDDEN_LEFT && + basep->state != BASEP_HIDDEN_RIGHT)) + return; + + if (basep->moving) + return; + + basep->moving = TRUE; + + if (GTK_WIDGET_REALIZED(GTK_WIDGET(basep))) { + BasePPosClass *klass = basep_widget_get_pos_class (basep); + PanelOrient hide_orient; + int w, h, size; + + hide_orient = klass->get_hide_orient (basep); + basep_widget_get_size (basep, &w, &h); + klass->get_hide_size (basep, + hide_orient, + &w, &h); + + size = (hide_orient == PANEL_ORIENT_UP || + hide_orient == PANEL_ORIENT_DOWN) ? + h : w; + + basep_widget_update_winhints (basep); + basep_widget_do_showing (basep, hide_orient, + size, + global_config.animation_speed); + + } + + basep->moving = FALSE; + old_state = basep->state; + basep->state = BASEP_SHOWN; + basep_widget_update_winhints (basep); + + g_signal_emit (G_OBJECT(basep), + basep_widget_signals[STATE_CHANGE_SIGNAL], + 0, old_state); + panels_to_sync = TRUE; + } + + gboolean + basep_widget_autoshow (gpointer data) + { + BasePState old_state; + BasePWidget *basep = data; + + g_return_val_if_fail (BASEP_IS_WIDGET(basep), FALSE); + + if (basep->moving) + return TRUE; + + if ( (basep->mode != BASEP_AUTO_HIDE) || + (basep->state != BASEP_AUTO_HIDDEN)) + return TRUE; + + basep->moving = TRUE; + + if (GTK_WIDGET_REALIZED(basep)) { + BasePPosClass *klass = basep_widget_get_pos_class (basep); + PanelOrient hide_orient; + int w, h, size; + + hide_orient = klass->get_hide_orient (basep); + basep_widget_get_size (basep, &w, &h); + klass->get_hide_size (basep, + hide_orient, + &w, &h); + + size = (hide_orient == PANEL_ORIENT_UP || + hide_orient == PANEL_ORIENT_DOWN) ? + h : w; + + basep_widget_update_winhints (basep); + basep_widget_do_showing (basep, + hide_orient, + size, + global_config.animation_speed); + } + + basep->moving = FALSE; + + old_state = basep->state; + basep->state = BASEP_SHOWN; + basep_widget_update_winhints (basep); + + g_signal_emit (G_OBJECT(basep), + basep_widget_signals[STATE_CHANGE_SIGNAL], + 0, old_state); + + basep->enter_notify_timer_tag = 0; + return FALSE; + } + + /* FIXME - there's a problem if the show and hide delays are set to 0 */ + + void + basep_widget_queue_autoshow (BasePWidget *basep) + { + /* check if there's already a timeout set, and delete it if + * there was */ + + if (basep->moving) + return; + + if (basep->leave_notify_timer_tag != 0) { + g_source_remove (basep->leave_notify_timer_tag); + basep->leave_notify_timer_tag = 0; + } + + if (basep->enter_notify_timer_tag != 0) { + g_source_remove (basep->enter_notify_timer_tag); + } + + if ((basep->mode != BASEP_AUTO_HIDE) || + (basep->state == BASEP_SHOWN)) + return; + + if (global_config.show_delay <= 0) + basep->enter_notify_timer_tag = + g_idle_add (basep_widget_autoshow, basep); + else + basep->enter_notify_timer_tag = + g_timeout_add (global_config.show_delay, + basep_widget_autoshow, basep); + } + + gboolean + basep_widget_autohide (gpointer data) + { + BasePState old_state; + BasePWidget *basep = data; + + g_return_val_if_fail (BASEP_IS_WIDGET(basep), TRUE); + + if (basep->drawers_open > 0) + return FALSE; + + if (basep->state != BASEP_SHOWN || + basep->mode != BASEP_AUTO_HIDE || + panel_widget_is_cursor (PANEL_WIDGET (basep->panel), 0)) + return FALSE; + + if (basep->autohide_inhibit) + return TRUE; + + if (basep->moving) + return TRUE; + + if (panel_applet_in_drag) + return TRUE; + + if (!gdk_pointer_is_grabbed ()) { + if (gdk_pointer_grab (gdk_get_default_root_window (), FALSE, + 0, NULL, NULL, GDK_CURRENT_TIME) + != GrabSuccess) { + return TRUE; + } else { + gdk_pointer_ungrab (GDK_CURRENT_TIME); + } + } + + basep->moving = TRUE; + old_state = basep->state; + basep->state = BASEP_AUTO_HIDDEN; + + g_signal_emit(G_OBJECT(basep), + basep_widget_signals[STATE_CHANGE_SIGNAL], + 0, old_state); + + /* if the app did any updating of the interface, flush that for us*/ + gdk_flush(); + + if (GTK_WIDGET_REALIZED(basep)) { + BasePPosClass *klass = basep_widget_get_pos_class (basep); + PanelOrient hide_orient; + int w, h, size; + + hide_orient = klass->get_hide_orient (basep); + basep_widget_get_size (basep, &w, &h); + klass->get_hide_size (basep, + hide_orient, + &w, &h); + size = (hide_orient == PANEL_ORIENT_UP || + hide_orient == PANEL_ORIENT_DOWN) + ? h : w; + + basep_widget_update_winhints (basep); + basep_widget_do_hiding (basep, + hide_orient, + size, + global_config.animation_speed); + } + + basep->moving = FALSE; + + basep_widget_update_winhints (basep); + + basep->leave_notify_timer_tag = 0; + return FALSE; + } + + void + basep_widget_queue_autohide (BasePWidget *basep) + { + if (basep->moving) + return; + + if (basep->enter_notify_timer_tag) { + g_source_remove (basep->enter_notify_timer_tag); + basep->enter_notify_timer_tag = 0; + } + + if (basep->leave_notify_timer_tag) { + g_source_remove (basep->leave_notify_timer_tag); + basep->leave_notify_timer_tag = 0; + } + + if (basep->mode != BASEP_AUTO_HIDE || + basep->state != BASEP_SHOWN) + return; + + if (global_config.hide_delay <= 0) + basep->leave_notify_timer_tag = + g_idle_add (basep_widget_autohide, basep); + else + basep->leave_notify_timer_tag = + g_timeout_add (global_config.hide_delay, + basep_widget_autohide, basep); + } + + PanelOrient + basep_widget_get_applet_orient (BasePWidget *basep) + { + BasePPosClass *klass = + basep_widget_get_pos_class (basep); + + g_return_val_if_fail (klass && + klass->get_applet_orient, -1); + + return klass->get_applet_orient(basep); + } + + void + basep_widget_get_size (BasePWidget *basep, + int *w, int *h) + { + GtkRequisition req; + BasePPosClass *klass = basep_widget_get_pos_class (basep); + + gtk_widget_size_request (basep->ebox, &req); + *w = req.width; + *h = req.height; + + g_return_if_fail (klass); + if (klass->get_size) + klass->get_size(basep, w, h); + } + + void + basep_widget_get_pos (BasePWidget *basep, + int *x, int *y) + { + int w, h; + BasePPosClass *klass = + basep_widget_get_pos_class (basep); + + g_return_if_fail (klass && klass->get_pos); + + basep_widget_get_size (basep, &w, &h); + klass->get_pos(basep, x, y, w, h); + } + + void + basep_widget_init_offsets (BasePWidget *basep) + { + g_return_if_fail (BASEP_IS_WIDGET (basep)); + + if (GTK_WIDGET (basep)->window != NULL) { + int x, y; + gdk_window_get_pointer (GTK_WIDGET (basep)->window, + &x, &y, NULL); + basep->offset_x = x; + basep->offset_y = y; + } else { + basep->offset_x = GTK_WIDGET (basep)->requisition.width / 2; + basep->offset_y = GTK_WIDGET (basep)->requisition.height / 2; + } + } + + void + basep_widget_set_pos (BasePWidget *basep, + int x, int y) + { + BasePPosClass *klass = basep_widget_get_pos_class (basep); + gboolean force = FALSE; + int w, h; + int new_monitor; + + g_return_if_fail (klass && klass->set_pos); + + /* first take care of switching monitors */ + new_monitor = multiscreen_locate_coords (basep->screen, x, y); + if (new_monitor >= 0 && new_monitor != basep->monitor) { + force = TRUE; + basep_widget_screen_change (basep, basep->screen, new_monitor); + } + + basep_widget_get_size (basep, &w, &h); + klass->set_pos (basep, x, y, w, h, force); + } + + void + basep_widget_pre_convert_hook (BasePWidget *basep) + { + BasePPosClass *klass = basep_widget_get_pos_class (basep); + g_return_if_fail (klass && klass->pre_convert_hook); + + klass->pre_convert_hook (basep); + } + + void + basep_widget_screen_change (BasePWidget *basep, + int screen, + int monitor) + { + int old_screen; + int old_monitor; + + g_return_if_fail (BASEP_IS_WIDGET (basep)); + g_return_if_fail (screen >= 0); + g_return_if_fail (monitor >= 0); + + if (basep->screen == screen && basep->monitor == monitor) + return; + + old_screen = basep->screen; basep->screen = screen; + old_monitor = basep->monitor; basep->monitor = monitor; + + g_signal_emit (basep, basep_widget_signals [SCREEN_CHANGE_SIGNAL], + 0, old_screen, old_monitor); + } + + /***** + * Collision avoidance stuff + *****/ + typedef struct { + int left; + int center; + int right; + } Border; + + typedef struct { + int screen; + int monitor; + Border borders[4]; + int left; + int right; + int top; + int bottom; + } ScreenBorders; + + typedef struct { + int screen; + int monitor; + } Recalc; + + static GList *border_list = NULL; + + static ScreenBorders * + get_borders (int screen, int monitor) + { + ScreenBorders *retval; + GList *l; + + for (l = border_list; l; l = l->next) { + ScreenBorders *sb = l->data; + + if (sb->screen == screen && + sb->monitor == monitor) + return sb; + } + + retval = g_new0 (ScreenBorders, 1); + retval->screen = screen; + retval->monitor = monitor; + border_list = g_list_prepend (border_list, retval); + + return retval; + } + + static void + basep_calculate_borders (int screen, int monitor) + { + ScreenBorders *sb; + GSList *l; + + sb = get_borders (screen, monitor); + + for (l = panel_list; l; l = l->next) { + PanelData *pd = l->data; + BasePWidget *basep; + GtkRequisition chreq; + BorderEdge edge; + int size = 0; + + g_assert (pd != NULL); + + if (!EDGE_IS_WIDGET (pd->panel) && + !ALIGNED_IS_WIDGET (pd->panel)) + continue; + + basep = BASEP_WIDGET (pd->panel); + + if (basep->mode == BASEP_AUTO_HIDE || + basep->screen != screen || + basep->monitor != monitor) + continue; + + gtk_widget_get_child_requisition (basep->ebox, &chreq); + + edge = BORDER_POS (basep->pos)->edge; + + switch (edge) { + case BORDER_RIGHT: + case BORDER_LEFT: + size = chreq.width; + break; + case BORDER_TOP: + case BORDER_BOTTOM: + size = chreq.height; + break; + default: + g_assert_not_reached (); + break; + } + + if (EDGE_IS_WIDGET (basep)) { + BasePState state = basep->state; + + switch (state) { + case BASEP_HIDDEN_RIGHT: + sb->borders [edge].right = MAX (sb->borders [edge].right, size); + break; + case BASEP_HIDDEN_LEFT: + sb->borders [edge].left = MAX (sb->borders [edge].left, size); + break; + default: + sb->borders [edge].right = MAX (sb->borders [edge].right, size); + sb->borders [edge].center = MAX (sb->borders [edge].center, size); + sb->borders [edge].left = MAX (sb->borders [edge].left, size); + break; + } + } else /* ALIGNED */ { + AlignedAlignment align = ALIGNED_POS (basep->pos)->align; + + switch (align) { + case ALIGNED_LEFT: + sb->borders [edge].left = MAX (sb->borders [edge].left, size); + break; + case ALIGNED_RIGHT: + sb->borders [edge].right = MAX (sb->borders [edge].right, size); + break; + case ALIGNED_CENTER: + sb->borders [edge].center = MAX (sb->borders [edge].center, size); + break; + default: + g_assert_not_reached (); + break; + } + } + } + } + + static int + border_max (ScreenBorders *sb, + BorderEdge edge) + { + return MAX (sb->borders [edge].center, + MAX (sb->borders [edge].left, + sb->borders [edge].right)); + } + + void + basep_border_recalc (int screen, int monitor) + { + ScreenBorders *sb; + ScreenBorders old; + GSList *l; + int i; + + sb = get_borders (screen, monitor); + + memcpy (&old, sb, sizeof (ScreenBorders)); + + for (i = 0; i < 4; i++) { + sb->borders [i].left = 0; + sb->borders [i].center = 0; + sb->borders [i].right = 0; + } + + basep_calculate_borders (screen, monitor); + + sb->left = border_max (sb, BORDER_LEFT); + sb->right = border_max (sb, BORDER_RIGHT); + sb->bottom = border_max (sb, BORDER_BOTTOM); + sb->top = border_max (sb, BORDER_TOP) + + foobar_widget_get_height (screen, monitor); + + if (!memcmp (&old, sb, sizeof (ScreenBorders))) + return; + + for (l = panel_list; l; l = l->next) { + PanelData *pdata = l->data; + GtkWidget *panel; + + g_assert (pdata != NULL); + + panel = pdata->panel; + + if (BORDER_IS_WIDGET (panel) && + BASEP_WIDGET (panel)->screen == screen && + BASEP_WIDGET (panel)->monitor == monitor) + gtk_widget_queue_resize (panel); + } + } + + static guint queue_recalc_id = 0; + static GList *pending_recalc_list = NULL; + + static gboolean + queue_recalc_handler (gpointer data) + { + GList *list, *l; + + queue_recalc_id = 0; + + list = pending_recalc_list; + pending_recalc_list = NULL; + + for (l = list; l; l = l->next) { + Recalc *recalc = l->data; + + basep_border_recalc (recalc->screen, recalc->monitor); + g_free (recalc); + } + + g_list_free (list); + + return FALSE; + } + + void + basep_border_queue_recalc (int screen, int monitor) + { + Recalc *new_recalc; + GList *l; + + for (l = pending_recalc_list; l; l = l->next) { + Recalc *recalc = l->data; + + if (recalc->screen == screen && + recalc->monitor == monitor) + return; + } + + new_recalc = g_new0 (Recalc, 1); + new_recalc->screen = screen; + new_recalc->monitor = monitor; + + pending_recalc_list = g_list_prepend ( + pending_recalc_list, new_recalc); + if (!queue_recalc_id) + queue_recalc_id = g_idle_add (queue_recalc_handler, NULL); + } + + void + basep_border_get (BasePWidget *basep, + BorderEdge edge, + int *left, + int *center, + int *right) + { + ScreenBorders *sb; + + g_assert (BASEP_IS_WIDGET (basep)); + g_assert (basep->screen >=0); + g_assert (basep->monitor >=0); + g_assert (edge == BORDER_TOP || + edge == BORDER_BOTTOM || + edge == BORDER_RIGHT || + edge == BORDER_LEFT); + + sb = get_borders (basep->screen, basep->monitor); + + if (left) + *left = sb->borders [edge].left; + + if (center) + *center = sb->borders [edge].center; + + if (right) + *right = sb->borders [edge].right; + + } + + static gboolean + basep_widget_popup_panel_menu (BasePWidget *basep) + { + gboolean retval; + + g_signal_emit_by_name (basep->panel, "popup_menu", &retval); + + return retval; + } diff -crN ./gnome-panel/gnome-panel/button-widget.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/button-widget.c *** ./gnome-panel/gnome-panel/button-widget.c Tue Aug 5 13:23:12 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/button-widget.c Fri Oct 17 10:03:41 2003 *************** *** 30,36 **** PROP_DND_HIGHLIGHT, PROP_ORIENTATION, PROP_ICON_NAME, ! PROP_STOCK_ID, }; #define BUTTON_WIDGET_DISPLACEMENT 2 --- 30,36 ---- PROP_DND_HIGHLIGHT, PROP_ORIENTATION, PROP_ICON_NAME, ! PROP_STOCK_ID }; #define BUTTON_WIDGET_DISPLACEMENT 2 diff -crN ./gnome-panel/gnome-panel/distribution.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/distribution.c *** ./gnome-panel/gnome-panel/distribution.c Wed Nov 27 10:33:37 2002 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/distribution.c Wed Jul 23 13:42:41 2003 *************** *** 38,43 **** --- 38,48 ---- PANEL_STOCK_CDE, "cdemenu:/", NULL, NULL }, + { DISTRIBUTION_AIX, "/usr/lpp/bos/aix_release.level", + N_("AIX"), N_("CDE Menu"), + PANEL_STOCK_CDE, "cdemenu:/", + NULL, NULL + }, { DISTRIBUTION_UNKNOWN, NULL, NULL, NULL, NULL } }; diff -crN ./gnome-panel/gnome-panel/distribution.h /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/distribution.h *** ./gnome-panel/gnome-panel/distribution.h Tue Aug 13 08:16:20 2002 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/distribution.h Wed Jul 23 13:41:33 2003 *************** *** 10,16 **** DISTRIBUTION_UNKNOWN = 0, DISTRIBUTION_DEBIAN, DISTRIBUTION_SUSE, ! DISTRIBUTION_SOLARIS } DistributionType; typedef struct { --- 10,17 ---- DISTRIBUTION_UNKNOWN = 0, DISTRIBUTION_DEBIAN, DISTRIBUTION_SUSE, ! DISTRIBUTION_SOLARIS, ! DISTRIBUTION_AIX } DistributionType; typedef struct { diff -crN ./gnome-panel/gnome-panel/egg-recent-item.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/egg-recent-item.c *** ./gnome-panel/gnome-panel/egg-recent-item.c Mon Jan 6 05:27:49 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/egg-recent-item.c Thu Sep 4 16:43:31 2003 *************** *** 63,72 **** g_free (item); } ! void egg_recent_item_ref (EggRecentItem *item) { item->refcount++; } void --- 63,74 ---- g_free (item); } ! gpointer egg_recent_item_ref (EggRecentItem *item) { item->refcount++; + + return item; } void diff -crN ./gnome-panel/gnome-panel/egg-recent-item.h /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/egg-recent-item.h *** ./gnome-panel/gnome-panel/egg-recent-item.h Thu Oct 10 19:23:52 2002 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/egg-recent-item.h Thu Sep 4 16:43:32 2003 *************** *** 34,40 **** /* constructors */ EggRecentItem * egg_recent_item_new (void); ! void egg_recent_item_ref (EggRecentItem *item); void egg_recent_item_unref (EggRecentItem *item); /* automatically fetches the mime type, etc */ --- 34,40 ---- /* constructors */ EggRecentItem * egg_recent_item_new (void); ! gpointer egg_recent_item_ref (EggRecentItem *item); void egg_recent_item_unref (EggRecentItem *item); /* automatically fetches the mime type, etc */ diff -crN ./gnome-panel/gnome-panel/gnome-desktop-item-edit.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/gnome-desktop-item-edit.c *** ./gnome-panel/gnome-panel/gnome-desktop-item-edit.c Wed Jul 2 10:39:04 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/gnome-desktop-item-edit.c Fri Oct 17 10:03:48 2003 *************** *** 1,4 **** --- 1,10 ---- #include "config.h" + + /* ?? : BV : added the inclusion of math.h (which is already included later) + so that M_PI and M_SQRT2 are not defined twice which causes an error + with xlc on AIX */ + #include + #include #include diff -crN ./gnome-panel/gnome-panel/gnome-panel-preferences.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/gnome-panel-preferences.c *** ./gnome-panel/gnome-panel/gnome-panel-preferences.c Mon Jun 30 14:07:12 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/gnome-panel-preferences.c Fri Oct 17 10:03:58 2003 *************** *** 27,33 **** */ #include ! #include #include #include --- 27,34 ---- */ #include ! ! #include #include #include diff -crN ./gnome-panel/gnome-panel/gnome-panel-screenshot.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/gnome-panel-screenshot.c *** ./gnome-panel/gnome-panel/gnome-panel-screenshot.c Wed Aug 13 12:29:24 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/gnome-panel-screenshot.c Fri Oct 17 10:04:08 2003 *************** *** 80,85 **** --- 80,86 ---- static char *temporary_file = NULL; static int status; + static int status; static GtkTargetEntry drag_types[] = { { "x-special/gnome-icon-list", 0, 0 }, { "text/uri-list", 0, 0 } }; diff -crN ./gnome-panel/gnome-panel/gnome-run.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/gnome-run.c *** ./gnome-panel/gnome-panel/gnome-run.c Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/gnome-run.c Tue Jul 8 11:53:20 2003 *************** *** 0 **** --- 1,1733 ---- + /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- */ + /* + * grun: Popup a command dialog. Original version by Elliot Lee, + * bloatware edition by Havoc Pennington. Both versions written in 10 + * minutes or less. :-) + * Copyright (C) 1998 Havoc Pennington + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA + */ + + #include + #include + #include + #include + #include + + #include + #include + #include + #include + #include + #include + #include + #include + + #include "gnome-run.h" + #include "disclosure-widget.h" + #include "menu-fentry.h" + #include "menu.h" + #include "multiscreen-stuff.h" + #include "panel-main.h" + #include "panel-util.h" + #include "panel-gconf.h" + #include "quick-desktop-reader.h" + #include "nothing.h" + #include "egg-screen-exec.h" + #include "egg-screen-url.h" + #include "panel-stock-icons.h" + + enum { + COLUMN_ICON, + COLUMN_ICON_FILE, + COLUMN_FULLNAME, + COLUMN_COMMENT, + COLUMN_NAME, + COLUMN_EXEC, + NUM_COLUMNS + }; + + typedef enum { + PANEL_RESPONSE_RUN + } PanelResponseType; + + #define ENABLE_LIST_DEFAULT TRUE + #define SHOW_LIST_DEFAULT FALSE + + extern GtkTooltips *panel_tooltips; + extern gboolean no_run_box; + + static GtkWidget *run_dialog = NULL; + static GSList *add_icon_paths = NULL; + static guint add_icon_idle_id = 0; + static guint add_items_idle_id = 0; + static guint find_icon_timeout_id = 0; + + static GList *executables = NULL; + static GCompletion *exe_completion = NULL; + + static void update_contents (GtkWidget *dialog); + static void unset_selected (GtkWidget *dialog); + static void unset_pixmap (GtkWidget *gpixmap); + static gboolean find_icon_timeout (gpointer data); + + static void + fill_executables_from (const char *dirname) + { + struct dirent *dent; + DIR *dir; + + dir = opendir (dirname); + + if (dir == NULL) + return; + + while ( (dent = readdir (dir)) != NULL) { + char *file = g_strconcat (dirname, "/", dent->d_name, NULL); + + if (access (file, X_OK) == 0) + executables = g_list_prepend (executables, + g_strdup (dent->d_name)); + } + + closedir (dir); + } + + static void + fill_executables (void) + { + int i; + const char *path; + char **pathv; + + panel_g_list_deep_free (executables); + executables = NULL; + + path = g_getenv ("PATH"); + + if (path == NULL || + path[0] == '\0') + return; + + pathv = g_strsplit (path, ":", 0); + + for (i = 0; pathv[i] != NULL; i++) + fill_executables_from (pathv[i]); + + g_strfreev (pathv); + } + + static void + ensure_completion (void) + { + if (exe_completion == NULL) { + exe_completion = g_completion_new (NULL); + fill_executables (); + + g_completion_add_items (exe_completion, executables); + } + } + + static void + kill_completion (void) + { + if (executables != NULL) { + panel_g_list_deep_free (executables); + executables = NULL; + } + + if (exe_completion != NULL) { + g_completion_free (exe_completion); + exe_completion = NULL; + } + } + + static void + get_environment (int *argc, + char ***argv, + int *envc, + char ***envv, + GdkScreen *screen) + { + GList *envar = NULL, *li; + gboolean display_found = FALSE; + int i, moveby; + + *envv = NULL; + *envc = 0; + + moveby = 0; + for (i = 0; i < *argc; i++) { + if (!strchr ((*argv) [i], '=')) + break; + + if (!strncmp ((*argv) [i], "DISPLAY", 7)) + display_found = TRUE; + + envar = g_list_append (envar, g_strdup ((*argv)[i])); + moveby ++; + } + + if (!display_found && gdk_screen_get_default () != screen) + envar = g_list_append ( + envar, egg_screen_exec_display_string (screen)); + + if (moveby == *argc) { + panel_g_list_deep_free (envar); + return; + } + + if (envar == NULL) + return; + + for (i = 0; i < *argc && moveby; i++) { + g_free ((*argv)[i]); + if (i + moveby < *argc) { + (*argv)[i] = (*argv)[i+moveby]; + (*argv)[i+moveby] = NULL; + } else { + (*argv)[i] = NULL; + } + } + *argc -= moveby; + + *envc = g_list_length (envar); + *envv = g_new0 (char *, *envc + 1); + for (i = 0, li = envar; li != NULL; li = li->next, i++) { + (*envv)[i] = li->data; + li->data = NULL; + } + (*envv)[i] = NULL; + g_list_free (envar); + } + + static void + launch_selected (GtkTreeModel *model, + GtkTreeIter *iter, + GtkWidget *dialog) + { + GnomeDesktopItem *ditem; + GnomeEntry *gnome_entry; + GtkWidget *entry; + GError *error = NULL; + GtkToggleButton *terminal; + char *name, *command; + + gtk_tree_model_get (model, iter, COLUMN_NAME, &name, -1); + + if (!name) + return; + + ditem = gnome_desktop_item_new_from_uri (name, + GNOME_DESKTOP_ITEM_LOAD_NO_TRANSLATIONS, + &error); + + g_free (name); + + if (!ditem) { + panel_error_dialog ( + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + "failed_to_load_desktop", + _("Failed to run this program\n\nDetails: %s"), + error->message); + g_clear_error (&error); + return; + } + + terminal = GTK_TOGGLE_BUTTON ( + g_object_get_data (G_OBJECT (dialog), "terminal")); + + /* Honor "run in terminal" button */ + gnome_desktop_item_set_boolean (ditem, + GNOME_DESKTOP_ITEM_TERMINAL, + terminal->active); + + if (!panel_ditem_launch ( + ditem, NULL, 0, + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + &error)) { + panel_error_dialog ( + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + "failed_to_load_desktop", + _("Failed to run this program\n\nDetails: %s"), + error->message); + g_clear_error (&error); + } + + /* save command history */ + gnome_entry = g_object_get_data (G_OBJECT (dialog), "gnome_entry"); + entry = g_object_get_data (G_OBJECT (dialog), "entry"); + command = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + gnome_entry_prepend_history (gnome_entry, TRUE, command); + g_free (command); + + gnome_desktop_item_unref (ditem); + } + + static void + run_dialog_response (GtkWidget *w, int response, gpointer data) + { + GtkWidget *entry; + GtkWidget *list; + GnomeEntry *gnome_entry; + char **argv = NULL; + char **temp_argv = NULL; + int argc, temp_argc; + char *s = NULL; + char *escaped = NULL; + char *disk = NULL; + char **envv = NULL; + int envc; + GError *error = NULL; + + if (response == GTK_RESPONSE_HELP) { + panel_show_help ( + gtk_window_get_screen (GTK_WINDOW (w)), + "wgoseditmainmenu.xml", "gospanel-23"); + /* just return as we don't want to close */ + return; + } else if (response != PANEL_RESPONSE_RUN) { + goto return_and_close; + } + + if (g_object_get_data (G_OBJECT (run_dialog), "use_list")) { + GtkTreeSelection *selection; + GtkTreeModel *model; + GtkTreeIter iter; + + list = g_object_get_data (G_OBJECT (run_dialog), "program_list"); + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); + + /* just return if nothing selected */ + if ( ! gtk_tree_selection_get_selected (selection, + &model, &iter)) + return; + + launch_selected (model, &iter, w); + } else { + + GtkToggleButton *terminal; + + entry = g_object_get_data (G_OBJECT (w), "entry"); + + s = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + + if (string_empty (s)) + goto return_and_close; + + escaped = g_markup_escape_text (s, -1); + disk = g_locale_from_utf8 (s, -1, NULL, NULL, NULL); + + /* save command in history */ + gnome_entry = g_object_get_data (G_OBJECT (w), "gnome_entry"); + gnome_entry_prepend_history (gnome_entry, TRUE, s); + + /* evil eggies, do not translate! */ + if (strcmp (s, "you shall bring us a shrubbery") == 0) { + panel_info_dialog ( + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + "ni_ni_ni_ni", + "NI! NI! NI! NI! NI! NI!"); + goto return_and_close; + } else if (strcmp (s, "supreme executive power") == 0) { + panel_info_dialog ( + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + "evil", + "Listen -- strange women lying in\n" + "ponds distributing swords is no\n" + "basis for a system of government.\n" + "Supreme executive power derives from\n" + "a mandate from the masses, not from\n" + "some farcical aquatic ceremony!"); + goto return_and_close; + } else if (strcmp (s, "free the fish") == 0) { + start_screen_check (); + goto return_and_close; + } else if (strcmp (s, "gegls from outer space") == 0) { + start_geginv (); + goto return_and_close; + } else if (strcmp (s, "End world hunger") == 0) { + egg_url_show_on_screen ( + "http://www.wfp.org", + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + NULL); + goto return_and_close; + } + + /* Somewhat of a hack I suppose */ + if (panel_is_url (s)) { + /* FIXME: URLs are in UTF8 ... right? */ + egg_url_show_on_screen ( + s, gtk_window_get_screen (GTK_WINDOW (run_dialog)), NULL); + goto return_and_close; + } + + /* Note, the command is taken to have to be in disk encoding + * even though it could contain strings, but more likely + * it is all filenames and thus should be in disk encoding */ + if ( ! g_shell_parse_argv (disk, &temp_argc, &temp_argv, &error)) { + g_clear_error (&error); + error = NULL; + if ( ! g_shell_parse_argv (s, &temp_argc, &temp_argv, &error)) { + panel_error_dialog ( + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + "run_error", + _("Failed to execute command: '%s'\n\nDetails: %s"), + escaped, error->message); + g_clear_error (&error); + goto return_and_close; + } + } + + get_environment ( + &temp_argc, &temp_argv, &envc, &envv, + gtk_window_get_screen (GTK_WINDOW (run_dialog))); + + terminal = GTK_TOGGLE_BUTTON ( + g_object_get_data (G_OBJECT (w), "terminal")); + + if (terminal->active) { + char **term_argv; + int term_argc; + gnome_config_get_vector ("/Gnome/Applications/Terminal", + &term_argc, &term_argv); + if (term_argv) { + int i; + argv = g_new(char *, term_argc + temp_argc + 1); + argc = term_argc + temp_argc; + for(i = 0; i < term_argc; i++) { + argv[i] = term_argv[i]; + term_argv[i] = NULL; + } + for(i = term_argc; i < term_argc+temp_argc; i++) { + argv[i] = temp_argv[i-term_argc]; + temp_argv[i-term_argc] = NULL; + } + argv[i] = NULL; + g_free (term_argv); + } else { + char *check; + int i; + check = g_find_program_in_path ("gnome-terminal"); + argv = g_new(char *, 2 + temp_argc + 1); + argc = 2 + temp_argc; + if(!check) { + argv[0] = g_strdup ("xterm"); + argv[1] = g_strdup ("-e"); + } else { + argv[0] = check; + argv[1] = g_strdup ("-x"); + } + for(i = 2; i < 2+temp_argc; i++) { + argv[i] = temp_argv[i-2]; + temp_argv[i-2] = NULL; + } + argv[i] = NULL; + } + } else { + argv = temp_argv; + temp_argv = NULL; + argc = temp_argc; + } + + if (gnome_execute_async_with_env (g_get_home_dir (), + argc, argv, + envc, envv) < 0) { + + /* if all else fails we try to open the file with an app */ + char *path; + char *command = NULL; + GError *error = NULL; + GnomeVFSFileInfo *info = NULL; + + if (!g_path_is_absolute (s)) { + path = g_strconcat (g_get_home_dir (), "/", s, NULL); + } else { + path = g_strdup (s); + } + + info = gnome_vfs_file_info_new (); + if (gnome_vfs_get_file_info (path,info, + GNOME_VFS_FILE_INFO_FOLLOW_LINKS) != GNOME_VFS_OK) { + panel_error_dialog( + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + "run_error", + _("Failed to execute command: '%s'\n\nDetails: %s"), + escaped, g_strerror (errno)); + g_free (path); + gnome_vfs_file_info_unref (info); + goto return_and_close; + } + + if (info->type == GNOME_VFS_FILE_TYPE_DIRECTORY) { + command = g_strconcat ("nautilus ", path, NULL); + } else { + char *mime_info; + GnomeVFSMimeApplication *app; + + mime_info = gnome_vfs_get_mime_type (path); + app = gnome_vfs_mime_get_default_application (mime_info); + + if (app != NULL) { + command = g_strconcat (app->command, " ", path, NULL); + } + + gnome_vfs_mime_application_free (app); + g_free (mime_info); + + if (command == NULL) { + panel_error_dialog ( + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + "run_error", + _("Failed to open file: '%s'\n\n" + "Details: no application available to open file"), + escaped); + + gnome_vfs_file_info_unref (info); + g_free (path); + goto return_and_close; + } + } + + if (!egg_screen_execute_command_line_async ( + gtk_window_get_screen (GTK_WINDOW (run_dialog)), command, &error)) { + panel_error_dialog ( + gtk_window_get_screen (GTK_WINDOW (run_dialog)), + "run_error", + _("Failed to open file: '%s'\n\nDetails: %s"), + escaped, error->message); + g_clear_error (&error); + } + + gnome_vfs_file_info_unref (info); + g_free (path); + g_free (command); + } + } + + return_and_close: + g_strfreev (argv); + g_strfreev (temp_argv); + g_strfreev (envv); + g_free (s); + g_free (escaped); + g_free (disk); + + gtk_widget_destroy (w); + + } + + static char * + quote_string (const char *s) + { + const char *p; + for (p = s; *p != '\0'; p++) { + if ((*p >= 'a' && *p <= 'z') || + (*p >= 'A' && *p <= 'Z') || + (*p >= '0' && *p <= '9') || + strchr ("-_./=:", *p) != NULL) + ; + else + return g_shell_quote (s); + } + return g_strdup (s); + } + + static void + append_file_utf8 (GtkWidget *entry, const char *file) + { + const char *text; + char *quoted = quote_string (file); + text = gtk_entry_get_text (GTK_ENTRY (entry)); + if (string_empty (text)) { + gtk_entry_set_text (GTK_ENTRY (entry), quoted); + } else { + char *new = g_strconcat (text, " ", quoted, NULL); + gtk_entry_set_text (GTK_ENTRY (entry), new); + g_free (new); + } + g_free (quoted); + } + + static void + append_file (GtkWidget *entry, const char *file) + { + char *utf8_file = g_filename_to_utf8 (file, -1, NULL, NULL, NULL); + if (utf8_file != NULL) { + append_file_utf8 (entry, utf8_file); + g_free (utf8_file); + } + } + + static void + browse_ok (GtkWidget *widget, GtkFileSelection *fsel) + { + const char *fname; + GtkWidget *entry; + + g_return_if_fail (GTK_IS_FILE_SELECTION (fsel)); + + entry = g_object_get_data (G_OBJECT (fsel), "entry"); + + fname = gtk_file_selection_get_filename (fsel); + if (fname != NULL) { + append_file (entry, fname); + } + + gtk_widget_destroy (GTK_WIDGET (fsel)); + } + + static void + browse (GtkWidget *w, GtkWidget *entry) + { + char *home; + GtkFileSelection *fsel; + + fsel = GTK_FILE_SELECTION (gtk_file_selection_new (_("Choose a file"))); + + home = g_strconcat (g_get_home_dir (), "/", NULL); + gtk_file_selection_set_filename (fsel, home); + g_free (home); + + gtk_window_set_transient_for (GTK_WINDOW (fsel), + GTK_WINDOW (run_dialog)); + g_object_set_data (G_OBJECT (fsel), "entry", entry); + + g_signal_connect (G_OBJECT (fsel->ok_button), "clicked", + G_CALLBACK (browse_ok), fsel); + g_signal_connect_swapped (G_OBJECT (fsel->cancel_button), "clicked", + G_CALLBACK (gtk_widget_destroy), + G_OBJECT (fsel)); + panel_signal_connect_object_while_alive + (G_OBJECT (entry), "destroy", + G_CALLBACK (gtk_widget_destroy), + G_OBJECT (fsel)); + + gtk_window_present (GTK_WINDOW (fsel)); + } + + static gboolean + entry_event (GtkEntry * entry, GdkEventKey * event, gpointer data) + { + if (event->type != GDK_KEY_PRESS) + return FALSE; + + /* completion */ + if ((event->keyval == GDK_Tab) && + (event->state & GDK_CONTROL_MASK)) { + gchar* prefix; + gchar* nprefix = NULL; + gint pos; + + ensure_completion (); + + pos = gtk_editable_get_position (GTK_EDITABLE (entry)); + prefix = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, pos); + + g_completion_complete (exe_completion, prefix, &nprefix); + + if (nprefix != NULL && + strlen (nprefix) > strlen (prefix)) { + gtk_editable_insert_text (GTK_EDITABLE (entry), + nprefix + pos, + strlen (nprefix) - + strlen (prefix), + &pos); + gtk_editable_set_position (GTK_EDITABLE (entry), pos); + } else { + gdk_beep (); + } + + g_free (nprefix); + g_free (prefix); + + return TRUE; + } + + return FALSE; + } + + static void + sync_entry_to_list (GtkWidget *dialog) + { + gboolean blocked; + gboolean enable_program_list; + GtkWidget *entry; + const char *key; + + blocked = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (dialog), + "sync_entry_to_list_blocked")); + if (blocked) + return; + + key = panel_gconf_general_key + (panel_gconf_get_profile (), "enable_program_list"), + enable_program_list = panel_gconf_get_bool (key, ENABLE_LIST_DEFAULT); + + if (enable_program_list) { + unset_selected (dialog); + + entry = g_object_get_data (G_OBJECT (dialog), "entry"); + + if (find_icon_timeout_id != 0) { + /* already a timeout registered so delay it for another half-second. */ + g_source_remove (find_icon_timeout_id); + find_icon_timeout_id = + g_idle_add_full (G_PRIORITY_LOW, find_icon_timeout, + entry, NULL); + } else { + /* no timeout registered so start a new one. */ + find_icon_timeout_id = + g_idle_add_full (G_PRIORITY_LOW, find_icon_timeout, + entry, NULL); + } + } + } + + static char * + remove_parameters (const char *exec) + { + GString *str; + char *retval, *p; + + str = g_string_new (exec); + + while ((p = strstr (str->str, "%"))) { + switch (p [1]) { + case '%': + g_string_erase (str, p - str->str, 1); + break; + case 'U': + case 'F': + case 'N': + case 'D': + case 'f': + case 'u': + case 'd': + case 'n': + case 'm': + case 'i': + case 'c': + case 'k': + case 'v': + g_string_erase (str, p - str->str, 2); + break; + default: + break; + } + } + + retval = str->str; + g_string_free (str, FALSE); + + return retval; + } + + static void + sync_list_to_entry (GtkWidget *dialog) + { + GtkWidget *list; + GtkWidget *entry; + GtkWidget *terminal_toggle; + gchar *name; + GtkTreeSelection *selection; + GtkTreeModel *model; + GtkTreeIter iter; + + g_object_set_data (G_OBJECT (dialog), + "sync_entry_to_list_blocked", + GINT_TO_POINTER (TRUE)); + + list = g_object_get_data (G_OBJECT (dialog), "program_list"); + entry = g_object_get_data (G_OBJECT (dialog), "entry"); + terminal_toggle = g_object_get_data (G_OBJECT (dialog), "terminal"); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); + + if (gtk_tree_selection_get_selected (selection, &model, &iter)) { + GValue value = {0, }; + + gtk_tree_model_get_value (model, &iter, + COLUMN_NAME, + &value); + name = g_strdup (g_value_get_string (&value)); + g_value_unset (&value); + + if (name != NULL) { + GnomeDesktopItem *ditem; + + ditem = gnome_desktop_item_new_from_uri (name, + GNOME_DESKTOP_ITEM_LOAD_NO_TRANSLATIONS, + NULL /* error */); + if (ditem != NULL) { + gboolean terminal; + const char *exec; + + exec = gnome_desktop_item_get_string ( + ditem, GNOME_DESKTOP_ITEM_EXEC); + if (exec) { + char *stripped; + + stripped = remove_parameters (exec); + + gtk_entry_set_text (GTK_ENTRY (entry), stripped); + + g_free (stripped); + } else { + exec = gnome_desktop_item_get_string ( + ditem, GNOME_DESKTOP_ITEM_URL); + gtk_entry_set_text (GTK_ENTRY (entry), sure_string (exec)); + } + + terminal = gnome_desktop_item_get_boolean ( + ditem, GNOME_DESKTOP_ITEM_TERMINAL); + + gtk_toggle_button_set_active ( + GTK_TOGGLE_BUTTON (terminal_toggle), terminal); + + gnome_desktop_item_unref (ditem); + } + + g_free (name); + } + } + + g_object_set_data (G_OBJECT (dialog), + "sync_entry_to_list_blocked", + GINT_TO_POINTER (FALSE)); + + g_object_set_data (G_OBJECT (dialog), "use_list", + GINT_TO_POINTER (TRUE)); + } + + static void + toggle_contents (GtkWidget *disclosure, + GtkWidget *dialog) + { + const char *key; + + key = panel_gconf_general_key + (panel_gconf_get_profile (), "show_program_list"), + + panel_gconf_set_bool (key, GTK_TOGGLE_BUTTON (disclosure)->active); + + /* FIXME: we need to listen on this key! */ + update_contents (dialog); + } + + static GtkWidget* + create_disclosure_widget (void) + { + GtkWidget *disclosure; + gboolean show_program_list; + const char *key; + + disclosure = cddb_disclosure_new (_("Known Applications"), + _("Known Applications")); + + key = panel_gconf_general_key + (panel_gconf_get_profile (), "show_program_list"), + show_program_list = panel_gconf_get_bool (key, SHOW_LIST_DEFAULT); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (disclosure), + show_program_list); + + g_object_set_data (G_OBJECT (run_dialog), "disclosure", disclosure); + + g_signal_connect (G_OBJECT (disclosure), "toggled", + G_CALLBACK (toggle_contents), + run_dialog); + + return disclosure; + } + + static void + entry_changed (GtkWidget *entry, + gpointer data) + { + GtkWidget *button; + char *text; + + /* desensitize run button if no text entered */ + text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + button = g_object_get_data (G_OBJECT (run_dialog), "run_button"); + if (strlen (text) == 0) { + gtk_widget_set_sensitive (GTK_WIDGET (button), FALSE); + } else { + gtk_widget_set_sensitive (GTK_WIDGET (button), TRUE); + } + g_free (text); + + if (run_dialog != NULL) + sync_entry_to_list (run_dialog); + } + + static void + activate_run (GtkWidget *entry, gpointer data) + { + if (run_dialog != NULL) + gtk_dialog_response (GTK_DIALOG (run_dialog), + PANEL_RESPONSE_RUN); + } + + static void + drag_data_received (GtkWidget *widget, + GdkDragContext *context, + gint x, + gint y, + GtkSelectionData *selection_data, + guint info, + guint32 time, + gpointer data) + { + GtkWidget *entry = data; + char **uris; + int i; + + uris = g_strsplit (selection_data->data, "\r\n", -1); + + if (uris == NULL) { + gtk_drag_finish (context, FALSE, FALSE, time); + return; + } + + for (i = 0; uris[i] != NULL; i++) { + char *file = gnome_vfs_get_local_path_from_uri (uris[i]); + + /* FIXME: I assume the file is in utf8 encoding if coming + * from a URI? */ + if (file != NULL) { + append_file_utf8 (entry, file); + g_free (file); + } else { + append_file_utf8 (entry, uris[i]); + } + } + + g_strfreev (uris); + + gtk_drag_finish (context, TRUE, FALSE, time); + } + + #define ELEMENTS(x) (sizeof (x) / sizeof (x[0])) + + static GtkWidget* + create_simple_contents (GdkScreen *screen) + { + GtkWidget *vbox; + GtkWidget *entry; + GtkWidget *gentry; + GtkWidget *pixmap; + GtkWidget *hbox; + GtkWidget *vbox2; + GtkWidget *hbox2; + GtkWidget *w; + const char *key; + gboolean enable_program_list; + int width_request; + static GtkTargetEntry drop_types[] = { { "text/uri-list", 0, 0 } }; + + vbox = gtk_vbox_new (FALSE, 0); + + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox), hbox, + TRUE, TRUE, GNOME_PAD_SMALL); + + w = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); + pixmap = gtk_image_new (); + g_object_set_data (G_OBJECT (run_dialog), "pixmap", pixmap); + gtk_container_add (GTK_CONTAINER (w), pixmap); + gtk_box_pack_start (GTK_BOX (hbox), w, + FALSE, FALSE, 10); + unset_pixmap (pixmap); + + vbox2 = gtk_vbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (hbox), vbox2, + TRUE, TRUE, GNOME_PAD_SMALL); + + gentry = gnome_entry_new ("gnome-run"); + gtk_box_pack_start (GTK_BOX (vbox2), gentry, + TRUE, TRUE, GNOME_PAD_SMALL); + + /* 1/4 the width of the first monitor should be a good value */ + width_request = multiscreen_width (gdk_screen_get_number (screen), 0) / 4; + g_object_set (G_OBJECT (gentry), "width_request", width_request, NULL); + + entry = gnome_entry_gtk_entry (GNOME_ENTRY (gentry)); + gtk_tooltips_set_tip (panel_tooltips, entry, _("Command to run"), NULL); + gtk_combo_set_use_arrows_always (GTK_COMBO (gentry), TRUE); + g_object_set_data (G_OBJECT (run_dialog), "entry", entry); + g_object_set_data (G_OBJECT (run_dialog), "gnome_entry", gentry); + + g_signal_connect (G_OBJECT (entry), "event", + G_CALLBACK (entry_event), + NULL); + g_signal_connect (G_OBJECT (entry), "destroy", + G_CALLBACK (kill_completion), + NULL); + + g_signal_connect (G_OBJECT (entry), "activate", + G_CALLBACK (activate_run), + NULL); + + g_signal_connect (G_OBJECT (entry), "changed", + G_CALLBACK (entry_changed), + NULL); + + gtk_drag_dest_unset (entry); + gtk_drag_dest_set (gentry, + GTK_DEST_DEFAULT_ALL, + drop_types, ELEMENTS (drop_types), GDK_ACTION_COPY); + + g_signal_connect (gentry, "drag_data_received", + G_CALLBACK (drag_data_received), + entry); + + hbox2 = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (vbox2), hbox2, + TRUE, TRUE, GNOME_PAD_SMALL); + + hbox = gtk_hbox_new (FALSE, 0); + + w = gtk_check_button_new_with_mnemonic(_("Run in _terminal")); + g_object_set_data (G_OBJECT (run_dialog), "terminal", w); + gtk_box_pack_start (GTK_BOX (hbox2), w, + TRUE, TRUE, 0); + + w = gtk_button_new_with_mnemonic (_("_Append File...")); + g_signal_connect(G_OBJECT(w), "clicked", + G_CALLBACK (browse), entry); + gtk_box_pack_start (GTK_BOX (hbox2), w, + FALSE, FALSE, 0); + + key = panel_gconf_general_key + (panel_gconf_get_profile (), "enable_program_list"), + enable_program_list = panel_gconf_get_bool (key, ENABLE_LIST_DEFAULT); + + /* only create disclosure widget if really needed */ + if (enable_program_list) { + w = create_disclosure_widget (); + gtk_box_pack_start (GTK_BOX (vbox), w, + FALSE, FALSE, GNOME_PAD_SMALL); + } + + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (run_dialog)->vbox), + vbox, + FALSE, FALSE, 0); + + g_object_set_data_full (G_OBJECT (run_dialog), + "advanced-entry", + g_object_ref (entry), + (GDestroyNotify) g_object_unref); + + gtk_widget_show_all (vbox); + + return vbox; + } + + static void + add_columns (GtkTreeView *treeview) + { + GtkCellRenderer *renderer; + GtkTreeViewColumn *column; + + renderer = gtk_cell_renderer_pixbuf_new (); + column = gtk_tree_view_column_new (); + + gtk_tree_view_column_pack_start (column, renderer, FALSE); + gtk_tree_view_column_set_attributes (column, renderer, + "pixbuf", COLUMN_ICON, + NULL); + + renderer = gtk_cell_renderer_text_new (); + gtk_tree_view_column_pack_start (column, renderer, TRUE); + + gtk_tree_view_column_set_attributes (column, renderer, + "text", COLUMN_FULLNAME, + NULL); + gtk_tree_view_append_column (treeview, column); + } + + static gboolean + fuzzy_command_match (const char *cmd1, const char *cmd2, gboolean *fuzzy) + { + char **tokens; + char *word1, *word2; + + if (strcmp (cmd1, cmd2) == 0) { + *fuzzy = FALSE; + return TRUE; + } + + /* find basename of exec from desktop item. + strip of all arguments after the initial command */ + tokens = g_strsplit (cmd1, " ", -1); + if (tokens == NULL || tokens[0] == NULL) { + g_strfreev (tokens); + return FALSE; + } + word1 = g_path_get_basename (tokens[0]); + g_strfreev (tokens); + + /* same for the user command */ + tokens = g_strsplit (cmd2, " ", -1); + word2 = g_path_get_basename (tokens[0]); + if (tokens == NULL || tokens[0] == NULL) { + g_free (word1); + g_strfreev (tokens); + return FALSE; + } + g_strfreev (tokens); + + if (strcmp (word1, word2) == 0) { + g_free (word1); + g_free (word2); + *fuzzy = TRUE; + return TRUE; + } + + g_free (word1); + g_free (word2); + return FALSE; + } + + static gboolean + find_icon_timeout (gpointer data) + { + GtkWidget *entry = data; + GdkPixbuf *pixbuf; + GtkListStore *list; + GtkTreeIter iter; + GtkTreeModel *model; + GtkTreePath *path; + GtkWidget *pixmap; + GValue value = {0}; + char *exec, *icon; + char *found_icon = NULL; + + pixmap = g_object_get_data (G_OBJECT (run_dialog), "pixmap"); + list = g_object_get_data (G_OBJECT (run_dialog), "program_list"); + model = gtk_tree_view_get_model (GTK_TREE_VIEW (list)); + path = gtk_tree_path_new_root (); + + if (path == NULL || + ! gtk_tree_model_get_iter (model, &iter, path)) { + if (path != NULL) + gtk_tree_path_free (path); + unset_pixmap (pixmap); + + find_icon_timeout_id = 0; + return FALSE; + } + + do { + gtk_tree_model_get_value (model, &iter, + COLUMN_EXEC, + &value); + + exec = g_strdup (g_value_get_string (&value)); + g_value_unset (&value); + + gtk_tree_model_get_value (model, &iter, + COLUMN_ICON_FILE, + &value); + + icon = g_strdup (g_value_get_string (&value)); + g_value_unset (&value); + + if (exec != NULL && icon != NULL) { + const char *text; + gboolean fuzzy = FALSE; + + text = gtk_entry_get_text (GTK_ENTRY (entry)); + + if (fuzzy_command_match (sure_string (text), + exec, &fuzzy)) { + g_free (found_icon); + found_icon = g_strdup (icon); + if ( ! fuzzy) { + /* if not fuzzy then we have a precise + * match and we can quit, else keep + * searching for a better match */ + g_free (exec); + g_free (icon); + break; + } + } + } + g_free (exec); + g_free (icon); + + } while (gtk_tree_model_iter_next (model, &iter)); + + gtk_tree_path_free (path); + + pixbuf = NULL; + if (found_icon != NULL) { + icon = gnome_desktop_item_find_icon (panel_icon_theme, + found_icon, + 48 /* desired size */, + 0 /* flags */); + if (icon != NULL) { + pixbuf = gdk_pixbuf_new_from_file (icon, NULL); + g_free (icon); + if (pixbuf != NULL) { + gtk_image_set_from_pixbuf (GTK_IMAGE (pixmap), + pixbuf); + g_object_unref (pixbuf); + } + } + g_free (found_icon); + } + + if (pixbuf == NULL) + unset_pixmap (pixmap); + + find_icon_timeout_id = 0; + return FALSE; + } + + static gboolean + add_icon_idle (GtkListStore *list) + { + GtkTreeIter iter; + GtkTreePath *path; + gboolean long_operation = FALSE; + GdkPixbuf *pixbuf; + char *file; + int icon_height; + + do { + if (add_icon_paths == NULL) { + add_icon_idle_id = 0; + return FALSE; + } + + path = add_icon_paths->data; + add_icon_paths->data = NULL; + add_icon_paths = g_slist_delete_link (add_icon_paths, + add_icon_paths); + + if ( ! gtk_tree_model_get_iter (GTK_TREE_MODEL (list), + &iter, + path)) { + gtk_tree_path_free (path); + continue; + } + gtk_tree_path_free (path); + + gtk_tree_model_get (GTK_TREE_MODEL (list), &iter, + COLUMN_ICON_FILE, &file, -1); + + if (!gtk_icon_size_lookup (panel_menu_icon_get_size (), NULL, &icon_height)) + icon_height = PANEL_DEFAULT_MENU_ICON_SIZE; + + pixbuf = panel_make_menu_icon (file, NULL, icon_height, &long_operation); + if (pixbuf) { + gtk_list_store_set (list, &iter, COLUMN_ICON, pixbuf, -1); + g_object_unref (pixbuf); + } + g_free (file); + /* don't go back into the main loop if this wasn't very hard to do */ + } while (!long_operation); + + if (add_icon_paths == NULL) { + add_icon_idle_id = 0; + return FALSE; + } + + return TRUE; + } + + /* Called when simple contents are switched to or first shown */ + static void + fill_list (GtkWidget *list) + { + GSList *tmp; + GSList *files; + GSList *prev; + char *prev_name; + GtkListStore *store; + FileRec *all_dir; + + /* create list store */ + store = gtk_list_store_new (NUM_COLUMNS, + GDK_TYPE_PIXBUF, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_STRING); + + all_dir = fr_get_dir ("all-applications:/"); + if (all_dir != NULL) { + files = g_slist_copy (((DirRec *)all_dir)->recs); + } else { + files = NULL; + } + + /* Collate */ + files = g_slist_sort (files, (GCompareFunc) fr_compare); + + /* Strip duplicates */ + tmp = files; + prev = NULL; + prev_name = NULL; + while (tmp) { + FileRec *fr; + + fr = tmp->data; + if (prev_name && strcmp (fr->fullname, prev_name) == 0) { + prev->next = tmp->next; + tmp->data = NULL; + g_slist_free_1 (tmp); + tmp = prev->next; + } else { + prev = tmp; + prev_name = fr->fullname; + tmp = tmp->next; + } + } + + tmp = files; + while (tmp != NULL) { + GtkTreeIter iter; + FileRec *fr; + GtkTreePath *path; + + fr = tmp->data; + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + COLUMN_ICON, NULL, + COLUMN_ICON_FILE, (fr->icon) ? fr->icon : "", + COLUMN_FULLNAME, (fr->fullname) ? fr->fullname : "", + COLUMN_COMMENT, (fr->comment) ? fr->comment : "", + COLUMN_NAME, (fr->name) ? fr->name : "", + COLUMN_EXEC, (fr->exec) ? fr->exec : "", + -1); + + path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &iter); + + if (path != NULL) + add_icon_paths = g_slist_prepend (add_icon_paths, path); + + tmp = tmp->next; + } + + g_slist_free (files); + + gtk_tree_view_set_model (GTK_TREE_VIEW (list), + GTK_TREE_MODEL (store)); + + add_columns (GTK_TREE_VIEW (list)); + + add_icon_paths = g_slist_reverse (add_icon_paths); + + if (add_icon_idle_id == 0) + add_icon_idle_id = + g_idle_add_full (G_PRIORITY_LOW, + (GSourceFunc)add_icon_idle, + store, NULL); + } + + #define DEFAULT_ICON "document-icons/i-executable.png" + #define FALLBACK_DEFAULT_ICON "gnome-logo-icon-transparent.png" + + static void + unset_pixmap (GtkWidget *gpixmap) + { + gchar *file; + + file = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_PIXMAP, + DEFAULT_ICON, TRUE, NULL); + + if (file == NULL) + file = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_APP_PIXMAP, + DEFAULT_ICON, TRUE, NULL); + if (file == NULL) + file = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_PIXMAP, + FALLBACK_DEFAULT_ICON, TRUE, NULL); + if (file == NULL) + file = gnome_program_locate_file (NULL, GNOME_FILE_DOMAIN_APP_PIXMAP, + FALLBACK_DEFAULT_ICON, TRUE, NULL); + + gtk_image_set_from_file (GTK_IMAGE (gpixmap), file); + + g_free (file); + } + + static void + unset_selected (GtkWidget *dialog) + { + GtkWidget *gpixmap; + GtkWidget *desc_label; + GtkWidget *entry; + GtkWidget *list; + char *text; + + gpixmap = g_object_get_data (G_OBJECT (dialog), "pixmap"); + desc_label = g_object_get_data (G_OBJECT (dialog), "desc_label"); + entry = g_object_get_data (G_OBJECT (dialog), "entry"); + list = g_object_get_data (G_OBJECT (dialog), "program_list"); + + if (entry != NULL) { + text = gtk_editable_get_chars (GTK_EDITABLE (entry), + 0, -1); + } else { + text = NULL; + } + + if ( ! string_empty (text)) { + char *msg; + msg = g_strdup_printf (_("Will run command: '%s'"), + text); + if (desc_label != NULL) + gtk_label_set_text (GTK_LABEL (desc_label), msg); + + g_free (msg); + } else { + + if (desc_label != NULL) + gtk_label_set_text (GTK_LABEL (desc_label), _("No application selected")); + } + + g_free (text); + + if (gpixmap != NULL) + unset_pixmap (gpixmap); + + g_object_set_data (G_OBJECT (dialog), "use_list", + GPOINTER_TO_INT (FALSE)); + gtk_tree_selection_unselect_all + (gtk_tree_view_get_selection (GTK_TREE_VIEW (list))); + } + + static void + selection_activated (GtkTreeView *tree_view, + GtkTreePath *path, + GtkTreeViewColumn *column, + GtkWidget *dialog) + { + GtkTreeModel *model; + GtkTreeIter iter; + + model = gtk_tree_view_get_model (tree_view); + if (gtk_tree_model_get_iter (model, &iter, path)) + launch_selected (model, &iter, dialog); + + gtk_widget_destroy (dialog); + } + + static void + selection_changed (GtkTreeSelection *selection, + GtkWidget *dialog) + { + GtkWidget *gpixmap; + GtkWidget *desc_label; + gchar *name; + GtkTreeModel *model; + GtkTreeIter iter; + GValue value = {0, }; + + if ( ! gtk_tree_selection_get_selected (selection, &model, &iter)) + return; + + gtk_tree_model_get_value (model, &iter, + COLUMN_NAME, + &value); + name = g_strdup (g_value_get_string (&value)); + g_value_unset (&value); + + gpixmap = g_object_get_data (G_OBJECT (dialog), "pixmap"); + desc_label = g_object_get_data (G_OBJECT (dialog), "desc_label"); + + if (name != NULL && gpixmap != NULL) { + QuickDesktopItem *qitem; + + qitem = quick_desktop_item_load_uri (name /*file */, + "Application" /* expected type */, + TRUE /* run tryexec */); + if (qitem != NULL) { + GdkPixbuf *pixbuf; + char *icon; + + if (desc_label != NULL) + gtk_label_set_text (GTK_LABEL (desc_label), + sure_string (qitem->comment)); + + icon = gnome_desktop_item_find_icon (panel_icon_theme, + qitem->icon, + 48 /* desired size */, + 0 /* flags */); + if (icon != NULL) { + pixbuf = gdk_pixbuf_new_from_file (icon, NULL); + g_free (icon); + } else { + pixbuf = NULL; + } + + if (pixbuf != NULL) { + gtk_image_set_from_pixbuf (GTK_IMAGE (gpixmap), pixbuf); + g_object_unref (pixbuf); + } else { + unset_pixmap (gpixmap); + } + + quick_desktop_item_destroy (qitem); + } + + g_free (name); + } + + sync_list_to_entry (dialog); + } + + static gboolean + add_items_idle (gpointer data) + { + GtkWidget *list = data; + fill_list (list); + add_items_idle_id = 0; + return FALSE; + } + + static GtkWidget* + create_program_list_contents (void) + { + GtkWidget *vbox; + GtkWidget *w; + GtkWidget *label; + GtkWidget *list; + GtkTreeSelection *selection; + + vbox = gtk_vbox_new (FALSE, 0); + + list = gtk_tree_view_new (); + + g_object_set_data (G_OBJECT (run_dialog), "program_list", list); + + gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (list), FALSE); + + panel_set_atk_name_desc (list, + _("List of known applications"), + _("Choose an application to run from the list")); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list)); + gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); + + g_signal_connect (selection, "changed", + G_CALLBACK (selection_changed), run_dialog); + + g_signal_connect (list, "row-activated", + G_CALLBACK (selection_activated), run_dialog); + + w = gtk_scrolled_window_new (NULL, NULL); + gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), + GTK_SHADOW_IN); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + + gtk_container_add (GTK_CONTAINER (w), list); + gtk_box_pack_start (GTK_BOX (vbox), w, + TRUE, TRUE, 0); + + label = gtk_label_new (""); + gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5); + gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 5); + g_object_set_data (G_OBJECT (run_dialog), "desc_label", label); + + g_object_set_data_full (G_OBJECT (run_dialog), + "program_list_box", + g_object_ref (vbox), + (GtkDestroyNotify) g_object_unref); + + unset_selected (run_dialog); + + return vbox; + } + + + static void + update_contents (GtkWidget *dialog) + { + GtkWidget *program_list_box = NULL; + gboolean show_program_list; + const char *key; + + key = panel_gconf_general_key + (panel_gconf_get_profile (), "show_program_list"), + show_program_list = panel_gconf_get_bool (key, SHOW_LIST_DEFAULT); + + if (show_program_list) { + program_list_box = g_object_get_data (G_OBJECT (dialog), "program_list_box"); + + if (program_list_box && program_list_box->parent == NULL) { + GtkWidget *list; + + gtk_window_resize (GTK_WINDOW (dialog), 100, 300); + gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); + + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), + program_list_box, + TRUE, TRUE, GNOME_PAD_SMALL); + + + gtk_widget_show_all (GTK_WIDGET (GTK_DIALOG (dialog)->vbox)); + + list = g_object_get_data (G_OBJECT (dialog), "program_list"); + gtk_widget_grab_focus (list); + } + } else { + GtkWidget *entry; + + program_list_box = g_object_get_data (G_OBJECT (dialog), "program_list_box"); + + if (program_list_box && program_list_box->parent != NULL) { + gtk_container_remove (GTK_CONTAINER (program_list_box->parent), program_list_box); + gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); + } + + entry = g_object_get_data (G_OBJECT (dialog), "entry"); + gtk_widget_grab_focus (entry); + } + } + + static void + run_dialog_destroyed (GtkWidget *widget) + { + run_dialog = NULL; + g_slist_foreach (add_icon_paths, (GFunc)gtk_tree_path_free, NULL); + g_slist_free (add_icon_paths); + add_icon_paths = NULL; + + if (add_icon_idle_id) + g_source_remove (add_icon_idle_id); + add_icon_idle_id = 0; + + if (add_items_idle_id) + g_source_remove (add_items_idle_id); + add_items_idle_id = 0; + + if (find_icon_timeout_id) + g_source_remove (find_icon_timeout_id); + find_icon_timeout_id = 0; + } + + void + show_run_dialog (GdkScreen *screen) + { + gboolean enable_program_list; + GtkWidget *w; + const char *key; + char *run_icon; + + if (no_run_box) + return; + + if (run_dialog) { + gtk_window_set_screen (GTK_WINDOW (run_dialog), screen); + gtk_window_present (GTK_WINDOW (run_dialog)); + /* always focus the entry initially */ + w = g_object_get_data (G_OBJECT (run_dialog), "entry"); + gtk_widget_grab_focus (w); + return; + } + + run_dialog = gtk_dialog_new_with_buttons ( + _("Run Program"), + NULL, 0 /* flags */, + GTK_STOCK_HELP, GTK_RESPONSE_HELP, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + NULL); + + gtk_window_set_resizable (GTK_WINDOW (run_dialog), FALSE); + gtk_window_set_screen (GTK_WINDOW (run_dialog), screen); + + w = gtk_dialog_add_button (GTK_DIALOG (run_dialog), + PANEL_STOCK_EXECUTE, PANEL_RESPONSE_RUN); + gtk_widget_set_sensitive (w, FALSE); + g_object_set_data (G_OBJECT (run_dialog), "run_button", w); + + run_icon = gnome_program_locate_file ( + NULL, GNOME_FILE_DOMAIN_PIXMAP, "gnome-run.png", TRUE, NULL); + if (run_icon) { + gnome_window_icon_set_from_file (GTK_WINDOW (run_dialog), run_icon); + g_free (run_icon); + } + + g_signal_connect (G_OBJECT (run_dialog), "destroy", + G_CALLBACK (run_dialog_destroyed), + NULL); + + gtk_window_set_wmclass (GTK_WINDOW (run_dialog), "run_dialog", "Panel"); + + gtk_dialog_set_default_response (GTK_DIALOG (run_dialog), PANEL_RESPONSE_RUN); + + g_signal_connect (G_OBJECT (run_dialog), "response", + G_CALLBACK (run_dialog_response), NULL); + + + create_simple_contents (screen); + + key = panel_gconf_general_key + (panel_gconf_get_profile (), "enable_program_list"), + enable_program_list = panel_gconf_get_bool (key, ENABLE_LIST_DEFAULT); + + if (enable_program_list) { + create_program_list_contents (); + update_contents (run_dialog); + + /* start loading the list of applications */ + w = g_object_get_data (G_OBJECT (run_dialog), "program_list"); + add_items_idle_id = + g_idle_add_full (G_PRIORITY_LOW, add_items_idle, + w, NULL); + + gtk_widget_grab_focus (w); + } else { + w = g_object_get_data (G_OBJECT (run_dialog), "entry"); + gtk_widget_grab_focus (w); + } + + gtk_widget_show_all (run_dialog); + } + + void + show_run_dialog_with_text (GdkScreen *screen, + const char *text) + { + GtkWidget *entry; + char *exec; + + g_return_if_fail (text != NULL); + + show_run_dialog (screen); + + if (run_dialog == NULL) { + return; + } + + entry = g_object_get_data (G_OBJECT (run_dialog), "entry"); + + exec = remove_parameters (text); + + gtk_entry_set_text (GTK_ENTRY (entry), exec); + + g_free (exec); + } diff -crN ./gnome-panel/gnome-panel/panel-applet-frame.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-applet-frame.c *** ./gnome-panel/gnome-panel/panel-applet-frame.c Tue Sep 2 12:59:07 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-applet-frame.c Fri Oct 17 10:04:27 2003 *************** *** 78,84 **** APPLET_FLAGS_NONE = 0, APPLET_EXPAND_MAJOR = 1 << 0, APPLET_EXPAND_MINOR = 1 << 1, ! APPLET_HAS_HANDLE = 1 << 2, } PanelAppletFlags; static void --- 78,84 ---- APPLET_FLAGS_NONE = 0, APPLET_EXPAND_MAJOR = 1 << 0, APPLET_EXPAND_MINOR = 1 << 1, ! APPLET_HAS_HANDLE = 1 << 2 } PanelAppletFlags; static void diff -crN ./gnome-panel/gnome-panel/panel-compatibility.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-compatibility.c *** ./gnome-panel/gnome-panel/panel-compatibility.c Mon Aug 25 18:13:52 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-compatibility.c Thu Nov 6 18:02:45 2003 *************** *** 36,42 **** PANEL_ORIENT_UP = GNOME_Vertigo_PANEL_ORIENT_UP, PANEL_ORIENT_DOWN = GNOME_Vertigo_PANEL_ORIENT_DOWN, PANEL_ORIENT_LEFT = GNOME_Vertigo_PANEL_ORIENT_LEFT, ! PANEL_ORIENT_RIGHT = GNOME_Vertigo_PANEL_ORIENT_RIGHT, } PanelOrient; static GConfEnumStringPair panel_orient_map [] = { --- 36,42 ---- PANEL_ORIENT_UP = GNOME_Vertigo_PANEL_ORIENT_UP, PANEL_ORIENT_DOWN = GNOME_Vertigo_PANEL_ORIENT_DOWN, PANEL_ORIENT_LEFT = GNOME_Vertigo_PANEL_ORIENT_LEFT, ! PANEL_ORIENT_RIGHT = GNOME_Vertigo_PANEL_ORIENT_RIGHT } PanelOrient; static GConfEnumStringPair panel_orient_map [] = { diff -crN ./gnome-panel/gnome-panel/panel-config.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-config.c *** ./gnome-panel/gnome-panel/panel-config.c Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-config.c Tue Jul 8 11:55:11 2003 *************** *** 0 **** --- 1,1799 ---- + /* GNOME panel: Individual panel configurations + * + * (C) 1998 the Free Software Foundation + * Copyright 2000 Helix Code, Inc. + * + * Authors: Jacob Berkman + * George Lebl + */ + + #include + + #include + + #include + + #include + + #include + #include + #include + #include + + #include + #include + + #include "panel-config.h" + + #include "aligned-widget.h" + #include "basep-widget.h" + #include "border-widget.h" + #include "drawer-widget.h" + #include "edge-widget.h" + #include "floating-widget.h" + #include "sliding-widget.h" + #include "panel.h" + #include "multiscreen-stuff.h" + + #include "nothing.cP" + + static void config_apply (PerPanelConfig *ppc); + + static GList *ppconfigs = NULL; + + /* register changes */ + void + panel_config_register_changes (PerPanelConfig *ppc) + { + if (ppc->register_changes) { + config_apply (ppc); + if (ppc->update_function != NULL) + ppc->update_function (ppc->update_data); + } + } + + static PerPanelConfig * + get_config_struct(GtkWidget *panel) + { + GList *list; + for (list = ppconfigs; list != NULL; list = list->next) { + PerPanelConfig *ppc = list->data; + if (ppc->panel == panel) + return ppc; + } + return NULL; + } + + void + kill_config_dialog (GtkWidget *panel) + { + PerPanelConfig *ppc; + + g_return_if_fail (panel != NULL); + g_return_if_fail (GTK_IS_WIDGET (panel)); + + ppc = get_config_struct (panel); + if (ppc != NULL && + ppc->config_window != NULL) + gtk_widget_destroy (ppc->config_window); + } + + static void + update_position_toggles (PerPanelConfig *ppc) + { + GtkWidget *toggle = ppc->toggle[ppc->edge][ppc->align]; + + /* this could happen during type changes */ + if (toggle == NULL) + return; + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), TRUE); + } + + void + update_config_edge (BasePWidget *panel) + { + PerPanelConfig *ppc; + + g_return_if_fail (panel != NULL); + g_return_if_fail (GTK_IS_WIDGET (panel)); + + ppc = get_config_struct (GTK_WIDGET (panel)); + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + g_return_if_fail (BORDER_IS_WIDGET (panel)); + + if (ppc->edge == BORDER_POS (panel->pos)->edge) + return; + + ppc->edge = BORDER_POS (panel->pos)->edge; + update_position_toggles (ppc); + } + + void + update_config_floating_pos (BasePWidget *panel) + { + PerPanelConfig *ppc; + + g_return_if_fail (panel != NULL); + g_return_if_fail (GTK_IS_WIDGET (panel)); + + ppc = get_config_struct (GTK_WIDGET (panel)); + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + gtk_spin_button_set_value (GTK_SPIN_BUTTON (ppc->x_spin), + FLOATING_POS (panel->pos)->x); + + gtk_spin_button_set_value (GTK_SPIN_BUTTON (ppc->y_spin), + FLOATING_POS (panel->pos)->y); + } + + void + update_config_floating_pos_limits (BasePWidget *panel) + { + GtkWidget *widget; + PerPanelConfig *ppc; + int xlimit, ylimit; + int val; + GtkAdjustment *adj; + + g_return_if_fail (panel != NULL); + g_return_if_fail (GTK_IS_WIDGET (panel)); + + widget = GTK_WIDGET (panel); + ppc = get_config_struct (widget); + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + xlimit = multiscreen_width (panel->screen, panel->monitor) + - widget->allocation.width; + ylimit = multiscreen_height (panel->screen, panel->monitor) + - widget->allocation.height; + + adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON (ppc->x_spin)); + if((int)adj->upper == xlimit) { + adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON (ppc->y_spin)); + if((int)adj->upper == ylimit) + return; + } + + + val = FLOATING_POS (panel->pos)->x; + if(val > xlimit) + val = xlimit; + adj = GTK_ADJUSTMENT(gtk_adjustment_new (val, 0, xlimit, 1, 10, 10)); + gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (ppc->x_spin), adj); + gtk_adjustment_value_changed(adj); + + val = FLOATING_POS (panel->pos)->y; + if(val > ylimit) + val = ylimit; + adj = GTK_ADJUSTMENT(gtk_adjustment_new (val, 0, ylimit, 1, 10, 10)); + gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (ppc->y_spin), adj); + gtk_adjustment_value_changed(adj); + } + + void + update_config_floating_orient (BasePWidget *panel) + { + PerPanelConfig *ppc = get_config_struct (GTK_WIDGET (panel)); + GtkWidget *toggle; + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + toggle = (PANEL_WIDGET (panel->panel)->orient == GTK_ORIENTATION_HORIZONTAL) + ? ppc->h_orient : ppc->v_orient; + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), + TRUE); + } + + void + update_config_screen (BasePWidget *w) + { + PerPanelConfig *ppc = get_config_struct (GTK_WIDGET (w)); + + if (!ppc || ppc->ppc_origin_change) + return; + + gtk_spin_button_set_value ( + GTK_SPIN_BUTTON (ppc->screen_spin), w->screen); + gtk_spin_button_set_value ( + GTK_SPIN_BUTTON (ppc->monitor_spin), w->monitor); + + gtk_spin_button_set_range ( + GTK_SPIN_BUTTON (ppc->monitor_spin), + 0, multiscreen_monitors (w->screen)); + + if (FLOATING_IS_WIDGET (w)) + update_config_floating_pos_limits (w); + else if (SLIDING_IS_WIDGET (w)) + update_config_offset_limit (w); + } + + void + update_config_size (GtkWidget *panel) + { + PerPanelConfig *ppc = get_config_struct(panel); + int i; + PanelWidget *p; + GtkWidget *menuitem; + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + p = PANEL_WIDGET(BASEP_WIDGET(panel)->panel); + switch(p->sz) { + case PANEL_SIZE_XX_SMALL: + i = 0; + break; + case PANEL_SIZE_X_SMALL: + i = 1; + break; + case PANEL_SIZE_SMALL: + i = 2; + break; + default: + case PANEL_SIZE_MEDIUM: + i = 3; + break; + case PANEL_SIZE_LARGE: + i = 4; + break; + case PANEL_SIZE_X_LARGE: + i = 5; + break; + case PANEL_SIZE_XX_LARGE: + i = 6; + break; + } + + gtk_option_menu_set_history (GTK_OPTION_MENU (ppc->size_menu), i); + menuitem = g_list_nth_data(GTK_MENU_SHELL(GTK_OPTION_MENU(ppc->size_menu)->menu)->children, i); + gtk_menu_item_activate(GTK_MENU_ITEM(menuitem)); + } + + void + update_config_back (PanelWidget *pw) + { + PerPanelConfig *ppc; + + g_return_if_fail (pw); + g_return_if_fail (PANEL_IS_WIDGET(pw)); + g_return_if_fail (pw->panel_parent); + + ppc = get_config_struct (pw->panel_parent); + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + switch (pw->background.type) { + default: + case PANEL_BACK_NONE: + break; + case PANEL_BACK_COLOR: + gnome_color_picker_set_i16(GNOME_COLOR_PICKER(ppc->backsel), + pw->background.color.gdk.red, + pw->background.color.gdk.green, + pw->background.color.gdk.blue, + pw->background.color.alpha); + break; + case PANEL_BACK_IMAGE: { + GtkWidget *t; + const gchar *text; + + t = gnome_file_entry_gtk_entry (GNOME_FILE_ENTRY (ppc->pix_entry)); + + text = gtk_entry_get_text (GTK_ENTRY (t)); + + if (strcmp (sure_string (pw->background.image), text)) + gtk_entry_set_text (GTK_ENTRY (t), + sure_string (pw->background.image)); + + } + break; + } + + gtk_option_menu_set_history (GTK_OPTION_MENU (ppc->back_om), + pw->background.type); + } + + void + update_config_anchor (BasePWidget *w) + { + PerPanelConfig *ppc = get_config_struct (GTK_WIDGET (w)); + g_return_if_fail (SLIDING_IS_WIDGET (w)); + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + ppc->align = SLIDING_POS (w->pos)->anchor; + update_position_toggles (ppc); + } + + void + update_config_offset (BasePWidget *w) + { + PerPanelConfig *ppc = get_config_struct (GTK_WIDGET (w)); + + g_return_if_fail (SLIDING_IS_WIDGET (w)); + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + gtk_spin_button_set_value (GTK_SPIN_BUTTON (ppc->offset_spin), + SLIDING_POS (w->pos)->offset); + } + + void + update_config_offset_limit (BasePWidget *panel) + { + GtkWidget *widget = GTK_WIDGET(panel); + PerPanelConfig *ppc = get_config_struct (widget); + int range, val; + GtkAdjustment *adj; + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + if(ppc->edge == BORDER_LEFT || ppc->edge == BORDER_RIGHT) + range = multiscreen_height (panel->screen, panel->monitor) + - widget->allocation.height; + else + range = multiscreen_width (panel->screen, panel->monitor) + - widget->allocation.width; + + adj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON (ppc->offset_spin)); + if((int)adj->upper == range) + return; + + val = SLIDING_POS (panel->pos)->offset; + if(val > range) val = range; + adj = GTK_ADJUSTMENT(gtk_adjustment_new (val, 0, range, 1, 10, 10)); + gtk_spin_button_set_adjustment (GTK_SPIN_BUTTON (ppc->offset_spin), adj); + gtk_adjustment_value_changed(adj); + } + + + void + update_config_align (BasePWidget *w) + { + PerPanelConfig *ppc = get_config_struct (GTK_WIDGET (w)); + g_return_if_fail (ALIGNED_IS_WIDGET (w)); + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + if (ppc->align == ALIGNED_POS (w->pos)->align) + return; + + ppc->align = ALIGNED_POS (w->pos)->align; + update_position_toggles (ppc); + } + + + static void + config_destroy(GtkWidget *widget, gpointer data) + { + PerPanelConfig *ppc = data; + + ppconfigs = g_list_remove (ppconfigs, ppc); + + g_free (ppc->back_pixmap); + ppc->back_pixmap = NULL; + g_free (ppc); + } + + static void + config_apply (PerPanelConfig *ppc) + { + /* don't update selves, all changes coming from ME */ + ppc->ppc_origin_change = TRUE; + + if(EDGE_IS_WIDGET(ppc->panel)) + border_widget_change_params(BORDER_WIDGET(ppc->panel), + ppc->screen, + ppc->monitor, + ppc->edge, + ppc->sz, + ppc->mode, + BASEP_WIDGET(ppc->panel)->state, + ppc->hidebuttons, + ppc->hidebutton_pixmaps, + ppc->back_type, + ppc->back_pixmap, + ppc->fit_pixmap_bg, + ppc->stretch_pixmap_bg, + ppc->rotate_pixmap_bg, + &ppc->back_color); + else if(SLIDING_IS_WIDGET(ppc->panel)) + sliding_widget_change_params(SLIDING_WIDGET(ppc->panel), + ppc->screen, + ppc->monitor, + ppc->align, + ppc->offset, + ppc->edge, + ppc->sz, + ppc->mode, + BASEP_WIDGET(ppc->panel)->state, + ppc->hidebuttons, + ppc->hidebutton_pixmaps, + ppc->back_type, + ppc->back_pixmap, + ppc->fit_pixmap_bg, + ppc->stretch_pixmap_bg, + ppc->rotate_pixmap_bg, + &ppc->back_color); + else if (ALIGNED_IS_WIDGET (ppc->panel)) + aligned_widget_change_params (ALIGNED_WIDGET (ppc->panel), + ppc->screen, + ppc->monitor, + ppc->align, + ppc->edge, + ppc->sz, + ppc->mode, + BASEP_WIDGET(ppc->panel)->state, + ppc->hidebuttons, + ppc->hidebutton_pixmaps, + ppc->back_type, + ppc->back_pixmap, + ppc->fit_pixmap_bg, + ppc->stretch_pixmap_bg, + ppc->rotate_pixmap_bg, + &ppc->back_color); + else if (FLOATING_IS_WIDGET (ppc->panel)) + floating_widget_change_params (FLOATING_WIDGET (ppc->panel), + ppc->screen, + ppc->monitor, + ppc->x, + ppc->y, + ppc->orient, + ppc->mode, + BASEP_WIDGET (ppc->panel)->state, + ppc->sz, + ppc->hidebuttons, + ppc->hidebutton_pixmaps, + ppc->back_type, + ppc->back_pixmap, + ppc->fit_pixmap_bg, + ppc->stretch_pixmap_bg, + ppc->rotate_pixmap_bg, + &ppc->back_color); + else if(DRAWER_IS_WIDGET(ppc->panel)) { + DrawerPos *dp = DRAWER_POS (BASEP_WIDGET (ppc->panel)->pos); + drawer_widget_change_params(DRAWER_WIDGET (ppc->panel), + ppc->screen, + ppc->monitor, + dp->orient, + ppc->mode, + BASEP_WIDGET (ppc->panel)->state, + ppc->sz, + ppc->hidebuttons, + ppc->hidebutton_pixmaps, + ppc->back_type, + ppc->back_pixmap, + ppc->fit_pixmap_bg, + ppc->stretch_pixmap_bg, + ppc->rotate_pixmap_bg, + &ppc->back_color); + } + + /* start registering changes again */ + ppc->ppc_origin_change = FALSE; + + gtk_widget_queue_draw (ppc->panel); + + panel_save_to_gconf ( + g_object_get_data (G_OBJECT (ppc->panel), "PanelData")); + } + + static void + set_toggle (GtkWidget *widget, gpointer data) + { + PerPanelConfig *ppc = g_object_get_data (G_OBJECT (widget), "PerPanelConfig"); + int *the_toggle = data; + + *the_toggle = GTK_TOGGLE_BUTTON(widget)->active; + + panel_config_register_changes (ppc); + } + + static void + set_sensitive_toggle (GtkWidget *widget, GtkWidget *widget2) + { + gtk_widget_set_sensitive(widget2,GTK_TOGGLE_BUTTON(widget)->active); + } + + static void + basep_set_auto_hide (GtkWidget *widget, gpointer data) + { + PerPanelConfig *ppc = g_object_get_data (G_OBJECT (widget), "PerPanelConfig"); + + ppc->mode = (GTK_TOGGLE_BUTTON (widget)->active) + ? BASEP_AUTO_HIDE + : BASEP_EXPLICIT_HIDE; + + + panel_config_register_changes (ppc); + } + + static GtkWidget * + make_hidebuttons_widget (PerPanelConfig *ppc) + { + GtkWidget *box; + GtkWidget *alignment; + GtkWidget *button; + GtkWidget *w; + + box = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width (GTK_CONTAINER (box), GNOME_PAD_SMALL); + + /* Auto-hide */ + button = gtk_check_button_new_with_mnemonic (_("_Autohide")); + ppc->autohide_button = button; + g_object_set_data (G_OBJECT (button), "PerPanelConfig", ppc); + if (ppc->mode == BASEP_AUTO_HIDE) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + g_signal_connect (G_OBJECT (button), "toggled", + G_CALLBACK (basep_set_auto_hide), + NULL); + gtk_box_pack_start (GTK_BOX (box), button, TRUE, TRUE, 0); + + /* Hidebuttons enable */ + w = button = gtk_check_button_new_with_mnemonic (_("Show hide _buttons")); + ppc->hidebuttons_button = button; + g_object_set_data (G_OBJECT (button), "PerPanelConfig", ppc); + if (ppc->hidebuttons) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + g_signal_connect (G_OBJECT (button), "toggled", + G_CALLBACK (set_toggle), + &ppc->hidebuttons); + gtk_box_pack_start (GTK_BOX (box), button, TRUE, TRUE, 0); + + alignment = gtk_alignment_new (0.25, 0.5, 0, 0); + /* Arrow enable */ + button = gtk_check_button_new_with_mnemonic (_("Arro_ws on hide buttons")); + ppc->hidebutton_pixmaps_button = button; + g_signal_connect (G_OBJECT (w), "toggled", + G_CALLBACK (set_sensitive_toggle), + button); + if (!ppc->hidebuttons) + gtk_widget_set_sensitive(button,FALSE); + g_object_set_data (G_OBJECT (button), "PerPanelConfig", ppc); + if (ppc->hidebutton_pixmaps) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + g_signal_connect (G_OBJECT (button), "toggled", + G_CALLBACK (set_toggle), + &ppc->hidebutton_pixmaps); + gtk_container_add (GTK_CONTAINER (alignment), button); + gtk_box_pack_start (GTK_BOX (box), alignment, FALSE, FALSE, 0); + + return box; + } + + static void + screen_set (GtkWidget *widget, gpointer data) + { + PerPanelConfig *ppc = g_object_get_data (G_OBJECT (widget), "PerPanelConfig"); + + ppc->screen = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget)); + panel_config_register_changes (ppc); + + if (ppc->monitor_spin) + gtk_spin_button_set_range (GTK_SPIN_BUTTON (ppc->monitor_spin), + 0, multiscreen_monitors (ppc->screen)); + } + + static void + monitor_set (GtkWidget *widget, gpointer data) + { + PerPanelConfig *ppc = g_object_get_data (G_OBJECT (widget), "PerPanelConfig"); + + ppc->monitor = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget)); + panel_config_register_changes (ppc); + } + + /* FIXME: this is a pile of poopies + */ + static GtkWidget * + make_misc_widget (PerPanelConfig *ppc) + { + GtkWidget *frame; + GtkWidget *box, *hbox; + GtkWidget *button, *label; + char *text; + + if (multiscreen_screens () <= 1 && + multiscreen_monitors (0) <= 1) + return NULL; + + text = g_strdup_printf ("%s", _("Miscellaneous:")); + frame = gtk_frame_new (text); + g_free (text); + + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); + gtk_label_set_use_markup ( + GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE); + + gtk_container_set_border_width (GTK_CONTAINER (frame), GNOME_PAD_SMALL); + + box = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width (GTK_CONTAINER (box), GNOME_PAD_SMALL); + gtk_container_add (GTK_CONTAINER (frame), box); + + if (multiscreen_screens () > 1) { + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (box), hbox, FALSE, FALSE, 0); + + label = gtk_label_new (_("Current screen:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + + ppc->screen_spin = button = + gtk_spin_button_new_with_range (0, multiscreen_screens () - 1, 1); + gtk_widget_set_size_request (GTK_WIDGET (button), 65, -1); + g_object_set_data (G_OBJECT (button), "PerPanelConfig", ppc); + gtk_spin_button_set_value (GTK_SPIN_BUTTON (button), ppc->screen); + g_signal_connect (button, "value-changed", G_CALLBACK (screen_set), NULL); + gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); + } + + if (multiscreen_monitors (0) > 1) { + hbox = gtk_hbox_new (FALSE, 0); + gtk_box_pack_start (GTK_BOX (box), hbox, FALSE, FALSE, 0); + + label = gtk_label_new (_("Current monitor:")); + gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); + + ppc->monitor_spin = button = + gtk_spin_button_new_with_range ( + 0, multiscreen_monitors (ppc->screen) - 1, 1); + gtk_widget_set_size_request (GTK_WIDGET (button), 65, -1); + g_object_set_data (G_OBJECT (button), "PerPanelConfig", ppc); + gtk_spin_button_set_value (GTK_SPIN_BUTTON (button), ppc->monitor); + g_signal_connect (button, "value-changed", G_CALLBACK (monitor_set), NULL); + gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); + } + + return frame; + } + + static void + border_set_edge (GtkWidget *widget, gpointer data) + { + int edge = GPOINTER_TO_INT (data); + PerPanelConfig *ppc = g_object_get_data (G_OBJECT (widget), "PerPanelConfig"); + + if (ppc->edge == edge) + return; + + ppc->edge = edge; + + panel_config_register_changes (ppc); + } + + static void + border_set_align (GtkWidget *widget, gpointer data) + { + int align = GPOINTER_TO_INT (data); + PerPanelConfig *ppc = g_object_get_data (G_OBJECT (widget), "PerPanelConfig"); + + if (ppc->align == align) + return; + + ppc->align = align; + + panel_config_register_changes (ppc); + } + + static void + make_position_widget_accessible (GtkWidget *w, + int current, + int max, + PanelOrient orient) + { + static const char *horiz_prefix[] = { "Left ", "Middle ", "Right " }; + static const char *vert_prefix[] = { "Top ", "Middle ", "Bottom " }; + char *atk_name; + char *str1 = ""; + char *str2 = ""; + + switch (orient) { + case PANEL_ORIENT_LEFT: + str2 = "Left Vertical"; + break; + case PANEL_ORIENT_UP: + str2 = "Top Horizontal"; + break; + case PANEL_ORIENT_RIGHT: + str2 = "Right Vertical"; + break; + case PANEL_ORIENT_DOWN: + str2 = "Bottom Horizontal"; + break; + } + + if (max > 1) { + /* In this case, we have to skip the entry "Middle" */ + if (max == 2 && current == 1) + current++; + + switch (orient) { + case PANEL_ORIENT_LEFT: + case PANEL_ORIENT_RIGHT: + str1 = (char *) vert_prefix [current]; + break; + case PANEL_ORIENT_UP: + case PANEL_ORIENT_DOWN: + str1 = (char *) horiz_prefix [current]; + break; + } + } + + atk_name = g_strconcat (str1, str2, NULL); + + panel_set_atk_name_desc (w, + _(atk_name), + _("Indicates the panel position and orientation on screen")); + + g_free (atk_name); + } + + static GtkWidget * + make_position_widget (PerPanelConfig *ppc, int aligns) + { + GtkWidget *pos_box; + GtkWidget *table; + GtkWidget *w = NULL; + GtkWidget *label; + int align; + + pos_box = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width (GTK_CONTAINER (pos_box), + GNOME_PAD_SMALL); + + label = gtk_label_new_with_mnemonic (_("_Position:")); + gtk_box_pack_start (GTK_BOX (pos_box), label, FALSE, FALSE, 0); + + w = gtk_alignment_new (0.5, 0.5, 0, 0); + gtk_box_pack_start (GTK_BOX (pos_box), w, FALSE, FALSE, 0); + + table = gtk_table_new (2 + aligns, 2 + aligns, FALSE); + gtk_widget_set_direction (table, GTK_TEXT_DIR_LTR); + gtk_container_add (GTK_CONTAINER (w), table); + + panel_set_atk_relation (table, GTK_LABEL (label)); + + w = NULL; + + /* LEFT */ + for (align = 0; align < aligns; ++align) { + w = w + ? gtk_radio_button_new_from_widget ( + GTK_RADIO_BUTTON (w)) + : gtk_radio_button_new (NULL); + ppc->toggle[BORDER_LEFT][align] = w; + gtk_widget_set_size_request (w, 18, 18); + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (w), FALSE); + g_object_set_data (G_OBJECT (w), "PerPanelConfig", ppc); + gtk_table_attach (GTK_TABLE (table), w, 0, 1, + 1 + align, 2 + align, + GTK_FILL, + GTK_EXPAND | GTK_FILL, 0, 0); + + g_signal_connect (w, "toggled", + G_CALLBACK (border_set_edge), + GINT_TO_POINTER (BORDER_LEFT)); + g_signal_connect (w, "toggled", + G_CALLBACK (border_set_align), + GINT_TO_POINTER (align)); + + make_position_widget_accessible ( + w, align, aligns, PANEL_ORIENT_LEFT); + } + + /* TOP */ + for (align = 0; align < aligns; ++align) { + w = gtk_radio_button_new_from_widget ( + GTK_RADIO_BUTTON (w)); + ppc->toggle[BORDER_TOP][align] = w; + gtk_widget_set_size_request (w, 18, 18); + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (w), FALSE); + g_object_set_data (G_OBJECT (w), "PerPanelConfig", ppc); + gtk_table_attach (GTK_TABLE (table), w, + 1 + align, 2 + align, 0, 1, + GTK_EXPAND | GTK_FILL, + 0, 0, 0); + + g_signal_connect (w, "toggled", + G_CALLBACK (border_set_edge), + GINT_TO_POINTER (BORDER_TOP)); + g_signal_connect (w, "toggled", + G_CALLBACK (border_set_align), + GINT_TO_POINTER (align)); + + make_position_widget_accessible ( + w, align, aligns, PANEL_ORIENT_UP); + } + + + /* RIGHT */ + for (align = 0; align < aligns; ++align) { + w = gtk_radio_button_new_from_widget ( + GTK_RADIO_BUTTON (w)); + ppc->toggle[BORDER_RIGHT][align] = w; + gtk_widget_set_size_request (w, 18, 18); + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (w), FALSE); + g_object_set_data (G_OBJECT (w), "PerPanelConfig", ppc); + gtk_table_attach (GTK_TABLE (table), w, + 1 + aligns, 2 + aligns, + 1 + align, 2 + align, + GTK_FILL, + GTK_FILL | GTK_EXPAND, 0, 0); + + g_signal_connect (w, "toggled", + G_CALLBACK (border_set_edge), + GINT_TO_POINTER (BORDER_RIGHT)); + g_signal_connect (w, "toggled", + G_CALLBACK (border_set_align), + GINT_TO_POINTER (align)); + + make_position_widget_accessible ( + w, align, aligns, PANEL_ORIENT_RIGHT); + } + + + /* BOTTOM */ + for (align = 0; align < aligns; ++align) { + w = gtk_radio_button_new_from_widget ( + GTK_RADIO_BUTTON (w)); + ppc->toggle[BORDER_BOTTOM][align] = w; + gtk_widget_set_size_request (w, 18, 18); + gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (w), FALSE); + g_object_set_data (G_OBJECT (w), "PerPanelConfig", ppc); + gtk_table_attach (GTK_TABLE (table), w, + 1 + align, 2 + align, + 1 + aligns, 2 + aligns, + GTK_EXPAND | GTK_FILL, + 0, 0, 0); + + g_signal_connect (w, "toggled", + G_CALLBACK (border_set_edge), + GINT_TO_POINTER (BORDER_BOTTOM)); + g_signal_connect (w, "toggled", + G_CALLBACK (border_set_align), + GINT_TO_POINTER (align)); + + make_position_widget_accessible ( + w, align, aligns, PANEL_ORIENT_DOWN); + } + + update_position_toggles (ppc); + gtk_label_set_mnemonic_widget (GTK_LABEL (label), ppc->toggle[ppc->edge][ppc->align]); + + w = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (w), GTK_SHADOW_IN); + gtk_table_attach (GTK_TABLE (table), w, + 1, 1 + aligns, + 1, 1 + aligns, + GTK_FILL, GTK_FILL, 0, 0); + gtk_widget_set_size_request (w, 103, 77); + return pos_box; + } + + static GtkWidget * + edge_notebook_page (PerPanelConfig *ppc) + { + GtkWidget *vbox; + GtkWidget *w; + + vbox = gtk_vbox_new (FALSE, GNOME_PAD_BIG); + gtk_container_set_border_width (GTK_CONTAINER (vbox), GNOME_PAD_SMALL); + + w = make_position_widget (ppc, 1); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_size_widget (ppc); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_hidebuttons_widget (ppc); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_misc_widget (ppc); + if (w != NULL) + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + return vbox; + } + + static GtkWidget * + aligned_notebook_page (PerPanelConfig *ppc) + { + GtkWidget *vbox; + GtkWidget *w; + + vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width (GTK_CONTAINER (vbox), GNOME_PAD_SMALL); + + w = make_position_widget (ppc, 3); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_size_widget (ppc); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_hidebuttons_widget (ppc); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_misc_widget (ppc); + if (w != NULL) + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + return vbox; + } + + static void + floating_set_orient (GtkWidget *widget, gpointer data) + { + GtkOrientation orient = GPOINTER_TO_INT (data); + PerPanelConfig *ppc = g_object_get_data (G_OBJECT (widget), "PerPanelConfig"); + + if (!(GTK_TOGGLE_BUTTON (widget)->active)) + return; + + ppc->orient = orient; + + panel_config_register_changes (ppc); + } + + static void + floating_set_xy (GtkWidget *widget, gpointer data) + { + gint16 *xy = data; + PerPanelConfig *ppc = g_object_get_data (G_OBJECT (widget), "PerPanelConfig"); + + *xy = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget)); + panel_config_register_changes (ppc); + } + + static GtkWidget * + floating_notebook_page (PerPanelConfig *ppc) + { + GtkWidget *frame; + GtkWidget *vbox; + GtkWidget *button, *label; + GtkWidget *orientbox; + GtkWidget *table; + GtkWidget *alignment; + GtkObject *range; + GtkWidget *w; + int xlimit, ylimit; + char *text; + + xlimit = multiscreen_width (ppc->screen, ppc->monitor) + - ppc->panel->allocation.width; + ylimit = multiscreen_height (ppc->screen, ppc->monitor) + - ppc->panel->allocation.height; + + vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + + + text = g_strdup_printf ("%s", _("Orientation:")); + frame = gtk_frame_new (text); + g_free (text); + + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); + gtk_label_set_use_markup ( + GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE); + + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 20); + + orientbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width (GTK_CONTAINER (orientbox), GNOME_PAD_SMALL); + gtk_container_add (GTK_CONTAINER (frame), orientbox); + + ppc->h_orient = button = gtk_radio_button_new_with_mnemonic ( + NULL, _("Hori_zontal")); + if(ppc->orient == GTK_ORIENTATION_HORIZONTAL) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + g_object_set_data (G_OBJECT (button), "PerPanelConfig", ppc); + g_signal_connect (G_OBJECT (button), "toggled", + G_CALLBACK (floating_set_orient), + GINT_TO_POINTER (GTK_ORIENTATION_HORIZONTAL)); + gtk_box_pack_start (GTK_BOX (orientbox), button, FALSE, FALSE, 0); + + ppc->v_orient = button = + gtk_radio_button_new_with_mnemonic_from_widget ( + GTK_RADIO_BUTTON (ppc->h_orient), + _("_Vertical")); + if(ppc->orient == GTK_ORIENTATION_VERTICAL) + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); + g_object_set_data (G_OBJECT (button), "PerPanelConfig", ppc); + g_signal_connect (G_OBJECT (button), "toggled", + G_CALLBACK (floating_set_orient), + GINT_TO_POINTER (GTK_ORIENTATION_VERTICAL)); + gtk_box_pack_start (GTK_BOX (orientbox), button, FALSE, FALSE, 0); + + + text = g_strdup_printf ("%s", _("Position:")); + frame = gtk_frame_new (text); + g_free (text); + + gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); + gtk_label_set_use_markup ( + GTK_LABEL (gtk_frame_get_label_widget (GTK_FRAME (frame))), TRUE); + + gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 20); + + table = gtk_table_new (2, 2, FALSE); + gtk_table_set_row_spacings (GTK_TABLE (table), GNOME_PAD_SMALL); + gtk_table_set_col_spacings (GTK_TABLE (table), GNOME_PAD_SMALL); + + alignment = gtk_alignment_new (0, 0.5, 0, 0); + label = gtk_label_new_with_mnemonic (_("H_orizontal:")); + gtk_container_add (GTK_CONTAINER (alignment), label); + gtk_table_attach (GTK_TABLE (table), alignment, 0, 1, 0, 1, + GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); + + range = gtk_adjustment_new (ppc->x, 0, xlimit, 1, 10, 10); + ppc->x_spin = button = + gtk_spin_button_new (GTK_ADJUSTMENT (range), 1, 0); + gtk_label_set_mnemonic_widget (GTK_LABEL (label), ppc->x_spin); + gtk_widget_set_size_request (GTK_WIDGET (button), 65, -1); + g_object_set_data (G_OBJECT (button), "PerPanelConfig", ppc); + gtk_spin_button_set_value (GTK_SPIN_BUTTON (button), ppc->x); + g_signal_connect (button, "value-changed", + G_CALLBACK (floating_set_xy), &ppc->x); + gtk_table_attach (GTK_TABLE (table), button, 1, 2, 0, 1, + GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); + + panel_set_atk_relation (ppc->x_spin, GTK_LABEL (label)); + + alignment = gtk_alignment_new (0, 0.5, 0, 0); + label = gtk_label_new_with_mnemonic (_("Ver_tical:")); + gtk_container_add (GTK_CONTAINER (alignment), label); + gtk_table_attach (GTK_TABLE (table), alignment, 0, 1, 1, 2, + GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); + + range = gtk_adjustment_new (ppc->y, 0, ylimit, 1, 10, 10); + ppc->y_spin = button = + gtk_spin_button_new (GTK_ADJUSTMENT (range), 1, 0); + gtk_widget_set_size_request (GTK_WIDGET (button), 65, -1); + gtk_label_set_mnemonic_widget (GTK_LABEL (label), ppc->y_spin); + g_object_set_data (G_OBJECT (button), "PerPanelConfig", ppc); + gtk_spin_button_set_value (GTK_SPIN_BUTTON (button), ppc->y); + g_signal_connect (button, "value-changed", + G_CALLBACK (floating_set_xy), &ppc->y); + panel_set_atk_relation (ppc->y_spin, GTK_LABEL (label)); + gtk_table_attach (GTK_TABLE (table), button, 1, 2, 1, 2, + GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); + + gtk_container_add (GTK_CONTAINER (frame), table); + + w = make_size_widget (ppc); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_hidebuttons_widget (ppc); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_misc_widget (ppc); + if (w != NULL) + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + return vbox; + } + + + static void + sliding_set_offset (GtkWidget *widget, gpointer data) + { + PerPanelConfig *ppc = data; + + ppc->offset = + gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (ppc->offset_spin)); + + panel_config_register_changes (ppc); + } + + + static GtkWidget * + sliding_notebook_page (PerPanelConfig *ppc) + { + GtkWidget *vbox, *hbox; + GtkWidget *w; + GtkWidget *l; + GtkWidget *button; + GtkAdjustment *adj; + int range; + + vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + + w = make_position_widget (ppc, 2); + gtk_box_pack_start (GTK_BOX (vbox), w, TRUE, TRUE, 0); + + hbox = gtk_hbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width (GTK_CONTAINER (hbox), GNOME_PAD_SMALL); + gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); + + l = gtk_label_new_with_mnemonic (_("_Distance from edge:")); + gtk_box_pack_start (GTK_BOX (hbox), l, FALSE, FALSE, 0); + + if(ppc->edge == BORDER_LEFT || ppc->edge == BORDER_RIGHT) + range = multiscreen_height (ppc->screen, ppc->monitor) + - ppc->panel->allocation.height; + else + range = multiscreen_width (ppc->screen, ppc->monitor) + - ppc->panel->allocation.width; + adj = GTK_ADJUSTMENT(gtk_adjustment_new (ppc->offset, 0, range, 1, 10, 10)); + ppc->offset_spin = button = + gtk_spin_button_new (adj, 1, 0); + gtk_label_set_mnemonic_widget (GTK_LABEL (l), button); + gtk_widget_set_size_request (button, 100, -1); + gtk_spin_button_set_value (GTK_SPIN_BUTTON (button), ppc->offset); + g_signal_connect (G_OBJECT (button), "changed", + G_CALLBACK (sliding_set_offset), ppc); + gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); + + panel_set_atk_relation (ppc->offset_spin, GTK_LABEL (l)); + + w = make_size_widget (ppc); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_hidebuttons_widget (ppc); + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + w = make_misc_widget (ppc); + if (w != NULL) + gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0); + + return vbox; + } + + static void + size_set_size (GtkWidget *widget, gpointer data) + { + int sz = GPOINTER_TO_INT(data); + PerPanelConfig *ppc = g_object_get_data (G_OBJECT (widget), "PerPanelConfig"); + + if (ppc->sz == sz) + return; + + ppc->sz = sz; + + panel_config_register_changes (ppc); + } + + GtkWidget * + make_size_widget (PerPanelConfig *ppc) + { + GtkWidget *box; + GtkWidget *menu; + GtkWidget *menuitem; + GtkWidget *label; + int i; + + box = gtk_hbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width (GTK_CONTAINER (box), GNOME_PAD_SMALL); + label = gtk_label_new_with_mnemonic (_("_Size:")); + gtk_box_pack_start (GTK_BOX (box), + label, + FALSE, FALSE, 0); + + + menu = gtk_menu_new (); + + menuitem = gtk_menu_item_new_with_label (_("XX Small")); + gtk_widget_show(menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); + g_object_set_data (G_OBJECT (menuitem), "PerPanelConfig", ppc); + g_signal_connect (G_OBJECT (menuitem), "activate", + G_CALLBACK (size_set_size), + GINT_TO_POINTER (PANEL_SIZE_XX_SMALL)); + + menuitem = gtk_menu_item_new_with_label (_("X Small")); + gtk_widget_show(menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); + g_object_set_data (G_OBJECT (menuitem), "PerPanelConfig", ppc); + g_signal_connect (G_OBJECT (menuitem), "activate", + G_CALLBACK (size_set_size), + GINT_TO_POINTER (PANEL_SIZE_X_SMALL)); + + menuitem = gtk_menu_item_new_with_label (_("Small")); + gtk_widget_show(menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); + g_object_set_data (G_OBJECT (menuitem), "PerPanelConfig", ppc); + g_signal_connect (G_OBJECT (menuitem), "activate", + G_CALLBACK (size_set_size), + GINT_TO_POINTER (PANEL_SIZE_SMALL)); + + menuitem = gtk_menu_item_new_with_label (_("Medium")); + gtk_widget_show(menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); + g_object_set_data (G_OBJECT (menuitem), "PerPanelConfig", ppc); + g_signal_connect (G_OBJECT (menuitem), "activate", + G_CALLBACK (size_set_size), + GINT_TO_POINTER (PANEL_SIZE_MEDIUM)); + + menuitem = gtk_menu_item_new_with_label (_("Large")); + gtk_widget_show(menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); + g_object_set_data (G_OBJECT (menuitem), "PerPanelConfig", ppc); + g_signal_connect (G_OBJECT (menuitem), "activate", + G_CALLBACK (size_set_size), + GINT_TO_POINTER (PANEL_SIZE_LARGE)); + + menuitem = gtk_menu_item_new_with_label (_("X Large")); + gtk_widget_show(menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); + g_object_set_data (G_OBJECT (menuitem), "PerPanelConfig", ppc); + g_signal_connect (G_OBJECT (menuitem), "activate", + G_CALLBACK (size_set_size), + GINT_TO_POINTER (PANEL_SIZE_X_LARGE)); + + menuitem = gtk_menu_item_new_with_label (_("XX Large")); + gtk_widget_show(menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); + g_object_set_data (G_OBJECT (menuitem), "PerPanelConfig", ppc); + g_signal_connect (G_OBJECT (menuitem), "activate", + G_CALLBACK (size_set_size), + GINT_TO_POINTER (PANEL_SIZE_XX_LARGE)); + + ppc->size_menu = gtk_option_menu_new (); + gtk_label_set_mnemonic_widget (GTK_LABEL (label), ppc->size_menu); + gtk_option_menu_set_menu (GTK_OPTION_MENU (ppc->size_menu), menu); + + gtk_box_pack_start (GTK_BOX (box), ppc->size_menu, + FALSE, FALSE, 0); + + panel_set_atk_relation (ppc->size_menu, GTK_LABEL (label)); + + switch(ppc->sz) { + case PANEL_SIZE_XX_SMALL: + i = 0; + break; + case PANEL_SIZE_X_SMALL: + i = 1; + break; + case PANEL_SIZE_SMALL: + i = 2; + break; + default: + case PANEL_SIZE_MEDIUM: + i = 3; + break; + case PANEL_SIZE_LARGE: + i = 4; + break; + case PANEL_SIZE_X_LARGE: + i = 5; + break; + case PANEL_SIZE_XX_LARGE: + i = 6; + break; + } + + gtk_option_menu_set_history (GTK_OPTION_MENU (ppc->size_menu), i); + menuitem = g_list_nth_data(GTK_MENU_SHELL(GTK_OPTION_MENU(ppc->size_menu)->menu)->children, i); + gtk_menu_item_activate(GTK_MENU_ITEM(menuitem)); + + return box; + } + + static void + value_changed (GtkWidget *w, gpointer data) + { + PerPanelConfig *ppc = data; + + g_free(ppc->back_pixmap); + ppc->back_pixmap = gnome_pixmap_entry_get_filename ( + GNOME_PIXMAP_ENTRY (ppc->pix_entry)); + + panel_config_register_changes (ppc); + } + + static void + set_fit_pixmap_bg (GtkToggleButton *toggle, gpointer data) + { + PerPanelConfig *ppc = data; + ppc->fit_pixmap_bg = toggle->active; + + panel_config_register_changes (ppc); + } + + static void + set_stretch_pixmap_bg (GtkToggleButton *toggle, gpointer data) + { + PerPanelConfig *ppc = data; + ppc->stretch_pixmap_bg = toggle->active; + + panel_config_register_changes (ppc); + } + + static void + set_rotate_pixmap_bg (GtkToggleButton *toggle, gpointer data) + { + PerPanelConfig *ppc = data; + ppc->rotate_pixmap_bg = toggle->active; + + panel_config_register_changes (ppc); + } + + static void + color_set_cb (GtkWidget *widget, + int red, + int green, + int blue, + int alpha, + PerPanelConfig *ppc) + { + ppc->back_color.gdk.red = red; + ppc->back_color.gdk.green = green; + ppc->back_color.gdk.blue = blue; + ppc->back_color.alpha = alpha; + + panel_config_register_changes (ppc); + } + + static void + background_type_changed (GtkOptionMenu *option_menu, + PerPanelConfig *ppc) + { + PanelBackgroundType back_type; + + g_return_if_fail (GTK_IS_OPTION_MENU (option_menu)); + + back_type = gtk_option_menu_get_history (option_menu); + + if (ppc->back_type == back_type) + return; + + if (back_type == 3) { /* Transparent */ + back_type = PANEL_BACK_COLOR; + ppc->back_color.alpha = 0x0000; + + gnome_color_picker_set_i16 (GNOME_COLOR_PICKER (ppc->backsel), + ppc->back_color.gdk.red, + ppc->back_color.gdk.green, + ppc->back_color.gdk.blue, + ppc->back_color.alpha); + } + + ppc->back_type = back_type; + + switch (ppc->back_type) { + case PANEL_BACK_NONE: + gtk_widget_set_sensitive (ppc->pix_frame, FALSE); + gtk_widget_set_sensitive (ppc->backsel, FALSE); + gtk_widget_set_sensitive (ppc->col_label, FALSE); + break; + case PANEL_BACK_COLOR: + gtk_widget_set_sensitive (ppc->pix_frame, FALSE); + gtk_widget_set_sensitive (ppc->backsel, TRUE); + gtk_widget_set_sensitive (ppc->col_label, TRUE); + break; + case PANEL_BACK_IMAGE: + gtk_widget_set_sensitive (ppc->pix_frame, TRUE); + gtk_widget_set_sensitive (ppc->backsel, FALSE); + gtk_widget_set_sensitive (ppc->col_label, FALSE); + break; + case 3: /* Transparent */ + gtk_widget_set_sensitive (ppc->pix_frame, FALSE); + gtk_widget_set_sensitive (ppc->backsel, TRUE); + gtk_widget_set_sensitive (ppc->col_label, TRUE); + break; + default: + g_assert_not_reached (); + break; + } + + panel_config_register_changes (ppc); + } + + static GtkWidget * + background_page (PerPanelConfig *ppc) + { + GtkWidget *box, *t, *table; + GtkWidget *vbox, *noscale, *fit, *stretch; + GtkWidget *w, *m; + GtkWidget *label; + char *text; + + vbox = gtk_vbox_new (FALSE, GNOME_PAD_SMALL); + gtk_container_set_border_width(GTK_CONTAINER (vbox), GNOME_PAD_SMALL); + + box = gtk_hbox_new (FALSE, GNOME_PAD_SMALL); + table = gtk_table_new (2, 2, FALSE); + gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); + + label = gtk_label_new_with_mnemonic (_("_Type:")); + gtk_table_attach (GTK_TABLE (table), GTK_WIDGET (label), + 0, 1, 0, 1, + GTK_SHRINK, GTK_EXPAND | GTK_FILL, + 2, 2); + + /*background type option menu*/ + m = gtk_menu_new (); + gtk_menu_shell_append (GTK_MENU_SHELL (m), + gtk_menu_item_new_with_label (_("Default"))); + gtk_menu_shell_append (GTK_MENU_SHELL (m), + gtk_menu_item_new_with_label (_("Color"))); + gtk_menu_shell_append (GTK_MENU_SHELL (m), + gtk_menu_item_new_with_label (_("Image"))); + gtk_menu_shell_append (GTK_MENU_SHELL (m), + gtk_menu_item_new_with_label (_("Transparent"))); + + ppc->back_om = gtk_option_menu_new (); + gtk_option_menu_set_menu (GTK_OPTION_MENU (ppc->back_om), m); + gtk_label_set_mnemonic_widget (GTK_LABEL (label), ppc->back_om); + gtk_table_attach (GTK_TABLE (table), GTK_WIDGET (ppc->back_om), + 1, 2, 0, 1, + GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, + 2, 2); + + panel_set_atk_relation (ppc->back_om, GTK_LABEL (label)); + + g_signal_connect (ppc->back_om, "changed", + G_CALLBACK (background_type_changed), ppc); + + ppc->col_label = gtk_label_new_with_mnemonic (_("_Color:")); + gtk_widget_set_sensitive (ppc->col_label, ppc->back_type == PANEL_BACK_COLOR); + gtk_table_attach (GTK_TABLE (table), GTK_WIDGET (ppc->col_label), + 0, 1, 1, 2, + GTK_SHRINK, GTK_EXPAND | GTK_FILL, + 2, 2); + + ppc->backsel = gnome_color_picker_new(); + + gnome_color_picker_set_use_alpha ( + GNOME_COLOR_PICKER (ppc->backsel), TRUE); + + gtk_widget_set_sensitive (ppc->backsel, ppc->back_type == PANEL_BACK_COLOR); + gtk_label_set_mnemonic_widget (GTK_LABEL (ppc->col_label), ppc->backsel); + g_signal_connect (G_OBJECT(ppc->backsel),"color_set", + G_CALLBACK(color_set_cb), ppc); + gnome_color_picker_set_i16(GNOME_COLOR_PICKER(ppc->backsel), + ppc->back_color.gdk.red, + ppc->back_color.gdk.green, + ppc->back_color.gdk.blue, + ppc->back_color.alpha); + + panel_set_atk_relation (ppc->backsel, GTK_LABEL (ppc->col_label)); + + gtk_table_attach (GTK_TABLE (table), ppc->backsel, + 1, 2, 1, 2, + GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, + 2, 2); + + /*image frame*/ + text = g_strdup_printf ("%s", _("Image:")); + ppc->pix_frame = gtk_frame_new (text); + g_free (text); + + gtk_frame_set_shadow_type (GTK_FRAME (ppc->pix_frame), GTK_SHADOW_NONE); + gtk_label_set_use_markup ( + GTK_LABEL (gtk_frame_get_label_widget ( + GTK_FRAME (ppc->pix_frame))), + TRUE); + + gtk_widget_set_sensitive (ppc->pix_frame, ppc->back_type == PANEL_BACK_IMAGE); + gtk_container_set_border_width (GTK_CONTAINER (ppc->pix_frame), GNOME_PAD_SMALL); + gtk_box_pack_start (GTK_BOX (vbox), ppc->pix_frame, FALSE, FALSE, 0); + + box = gtk_vbox_new (0, 0); + gtk_container_set_border_width(GTK_CONTAINER (box), GNOME_PAD_SMALL); + gtk_container_add (GTK_CONTAINER (ppc->pix_frame), box); + + ppc->pix_entry = gnome_pixmap_entry_new ("pixmap", _("Browse"), TRUE); + gtk_box_pack_start (GTK_BOX (box), ppc->pix_entry, FALSE, FALSE, 0); + if (gdk_screen_height () < 600) + gnome_pixmap_entry_set_preview_size (GNOME_PIXMAP_ENTRY (ppc->pix_entry), + 0,50); + t = gnome_file_entry_gtk_entry (GNOME_FILE_ENTRY (ppc->pix_entry)); + panel_signal_connect_while_alive (G_OBJECT (t), "changed", + G_CALLBACK (value_changed), ppc, + G_OBJECT (ppc->pix_entry)); + + gtk_entry_set_text (GTK_ENTRY (t), + sure_string (ppc->back_pixmap)); + + noscale = gtk_radio_button_new_with_mnemonic ( + NULL, _("T_ile")); + + gtk_box_pack_start (GTK_BOX (box), noscale, FALSE, FALSE,0); + + fit = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (noscale), + _("_Scale")); + gtk_box_pack_start (GTK_BOX (box), fit, FALSE, FALSE,0); + + stretch = gtk_radio_button_new_with_mnemonic_from_widget (GTK_RADIO_BUTTON (noscale), + _("St_retch")); + gtk_box_pack_start (GTK_BOX (box), stretch, FALSE, FALSE,0); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (noscale), + ppc->stretch_pixmap_bg); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (stretch), + ppc->stretch_pixmap_bg); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (fit), + ppc->fit_pixmap_bg); + g_signal_connect (G_OBJECT (fit), "toggled", + G_CALLBACK (set_fit_pixmap_bg), ppc); + g_signal_connect (G_OBJECT (stretch), "toggled", + G_CALLBACK (set_stretch_pixmap_bg), ppc); + + w = gtk_check_button_new_with_mnemonic (_("Rotate image when panel is _vertical")); + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), + ppc->rotate_pixmap_bg); + g_signal_connect (G_OBJECT (w), "toggled", + G_CALLBACK (set_rotate_pixmap_bg), ppc); + gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE,0); + + gtk_option_menu_set_history ( + GTK_OPTION_MENU (ppc->back_om), ppc->back_type); + + return vbox; + } + + static void + setup_pertype_defs (BasePWidget *basep, PerPanelConfig *ppc) + { + if (BORDER_IS_WIDGET (basep)) + ppc->edge = BORDER_POS (basep->pos)->edge; + + if (ALIGNED_IS_WIDGET(basep)) { + ppc->align = ALIGNED_POS (basep->pos)->align; + } else if (FLOATING_IS_WIDGET (basep)) { + FloatingPos *pos = FLOATING_POS (basep->pos); + ppc->x = pos->x; + ppc->y = pos->y; + ppc->orient = PANEL_WIDGET(basep->panel)->orient; + } else if (SLIDING_IS_WIDGET(basep)) { + SlidingPos *pos = SLIDING_POS (basep->pos); + ppc->offset = pos->offset; + ppc->align = pos->anchor; + } else { + ppc->align = 0; + } + } + + void + update_config_type (BasePWidget *w) + { + PerPanelConfig *ppc = get_config_struct (GTK_WIDGET (w)); + int i,j; + GtkWidget *page; + + if (ppc == NULL || + ppc->ppc_origin_change) + return; + + g_return_if_fail(ppc->type_tab); + + ppc->register_changes = FALSE; + gtk_widget_destroy(GTK_BIN(ppc->type_tab)->child); + + for(i = 0; i < POSITION_EDGES; i++) + for(j = 0; j < POSITION_ALIGNS; j++) + ppc->toggle[i][j] = NULL; + + setup_pertype_defs (BASEP_WIDGET(w), ppc); + + if(EDGE_IS_WIDGET(w)) { + /* edge notebook page */ + page = edge_notebook_page(ppc); + gtk_label_set_text (GTK_LABEL (ppc->type_tab_label), + _("Edge panel")); + gtk_container_add(GTK_CONTAINER(ppc->type_tab), page); + } else if(ALIGNED_IS_WIDGET(w)) { + /* aligned notebook page */ + page = aligned_notebook_page(ppc); + gtk_container_add(GTK_CONTAINER(ppc->type_tab), page); + gtk_label_set_text (GTK_LABEL (ppc->type_tab_label), + _("Corner panel")); + } else if(SLIDING_IS_WIDGET(w)) { + /* sliding notebook page */ + page = sliding_notebook_page(ppc); + gtk_container_add(GTK_CONTAINER(ppc->type_tab), page); + gtk_label_set_text (GTK_LABEL (ppc->type_tab_label), + _("Sliding panel")); + } else if(FLOATING_IS_WIDGET(w)) { + /* floating notebook page */ + page = floating_notebook_page(ppc); + gtk_container_add(GTK_CONTAINER(ppc->type_tab), page); + gtk_label_set_text (GTK_LABEL (ppc->type_tab_label), + _("Floating panel")); + } + gtk_widget_show_all (ppc->type_tab); + ppc->register_changes = TRUE; + } + + static void + window_response (GtkWidget *w, int response, gpointer data) + { + GtkWidget *notebook = data; + const char *help_path = g_object_get_data (G_OBJECT (w), "help_path"); + const char *help_linkid = g_object_get_data (G_OBJECT (w), "help_linkid"); + + if (response == GTK_RESPONSE_HELP) { + int tab; + + tab = gtk_notebook_get_current_page (GTK_NOTEBOOK (notebook)); + + if (tab == 1) + panel_show_help ( + gtk_window_get_screen (GTK_WINDOW (w)), + "wgospanel.xml", "gospanel-28"); + else + panel_show_help ( + gtk_window_get_screen (GTK_WINDOW (w)), + help_path, help_linkid); + } else { + gtk_widget_destroy (w); + } + } + + void + panel_config (GtkWidget *panel) + { + GtkWidget *page; + PerPanelConfig *ppc; + GtkWidget *prop_nbook; + BasePWidget *basep = BASEP_WIDGET (panel); + PanelWidget *pw = PANEL_WIDGET (basep->panel); + char *help_path = ""; + char *help_linkid = NULL; + ppc = get_config_struct(panel); + + /* return if the window is already up. */ + if (ppc != NULL) { + g_assert (ppc->config_window != NULL); + + gtk_window_present (GTK_WINDOW (ppc->config_window)); + return; + } + + ppc = g_new0 (PerPanelConfig, 1); + ppconfigs = g_list_prepend(ppconfigs, ppc); + ppc->register_changes = FALSE; /*don't notify property box of changes + until everything is all set up*/ + ppc->ppc_origin_change = FALSE; /* default state */ + + ppc->sz = pw->sz; + ppc->screen = basep->screen; + ppc->monitor = basep->monitor; + ppc->hidebuttons = basep->hidebuttons_enabled; + ppc->hidebutton_pixmaps = basep->hidebutton_pixmaps_enabled; + ppc->fit_pixmap_bg = pw->background.fit_image; + ppc->stretch_pixmap_bg = pw->background.stretch_image; + ppc->rotate_pixmap_bg = pw->background.rotate_image; + ppc->back_pixmap = g_strdup(pw->background.image); + ppc->back_color = pw->background.color; + ppc->back_type = pw->background.type; + ppc->mode = basep->mode; + ppc->update_function = NULL; + ppc->update_data = NULL; + + setup_pertype_defs (basep, ppc); + + ppc->panel = panel; + + /* main window */ + ppc->config_window = gtk_dialog_new_with_buttons ( + _("Panel Properties"), + NULL, 0, + GTK_STOCK_HELP, GTK_RESPONSE_HELP, + GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, + NULL); + gtk_dialog_set_default_response (GTK_DIALOG (ppc->config_window), + GTK_RESPONSE_CLOSE); + gtk_window_set_resizable (GTK_WINDOW (ppc->config_window), FALSE); + gtk_widget_add_events (ppc->config_window, GDK_KEY_PRESS_MASK); + g_signal_connect (G_OBJECT (ppc->config_window), "event", + G_CALLBACK (panel_dialog_window_event), NULL); + gtk_window_set_wmclass (GTK_WINDOW (ppc->config_window), + "panel_properties", "Panel"); + gtk_window_set_screen (GTK_WINDOW (ppc->config_window), + gtk_window_get_screen (GTK_WINDOW (panel))); + gtk_widget_set_events (ppc->config_window, + gtk_widget_get_events (ppc->config_window) | + GDK_BUTTON_PRESS_MASK); + + g_signal_connect (G_OBJECT (ppc->config_window), "destroy", + G_CALLBACK (config_destroy), ppc); + + prop_nbook = gtk_notebook_new (); + + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (ppc->config_window)->vbox), + prop_nbook, TRUE, TRUE, 0); + + if(EDGE_IS_WIDGET(panel)) { + /* edge notebook page */ + help_path = "wgospanel.xml"; + help_linkid = "gospanel-28"; + page = edge_notebook_page(ppc); + ppc->type_tab = gtk_event_box_new(); + gtk_container_add(GTK_CONTAINER(ppc->type_tab), page); + ppc->type_tab_label = gtk_label_new (_("Edge Panel")); + gtk_notebook_append_page(GTK_NOTEBOOK(prop_nbook), + ppc->type_tab, + ppc->type_tab_label); + } else if(ALIGNED_IS_WIDGET(panel)) { + /* aligned notebook page */ + help_path = "wgospanel.xml"; + help_linkid = "gospanel-28"; + page = aligned_notebook_page(ppc); + ppc->type_tab = gtk_event_box_new(); + gtk_container_add(GTK_CONTAINER(ppc->type_tab), page); + ppc->type_tab_label = gtk_label_new (_("Corner Panel")); + gtk_notebook_append_page(GTK_NOTEBOOK(prop_nbook), + ppc->type_tab, + ppc->type_tab_label); + } else if(SLIDING_IS_WIDGET(panel)) { + /* sliding notebook page */ + help_path = "wgospanel.xml"; + help_linkid = "gospanel-28"; + page = sliding_notebook_page(ppc); + ppc->type_tab = gtk_event_box_new(); + gtk_container_add(GTK_CONTAINER(ppc->type_tab), page); + ppc->type_tab_label = gtk_label_new (_("Sliding Panel")); + gtk_notebook_append_page(GTK_NOTEBOOK (prop_nbook), + ppc->type_tab, + ppc->type_tab_label); + } else if(FLOATING_IS_WIDGET(panel)) { + /* floating notebook page */ + help_path = "wgospanel.xml"; + help_linkid = "gospanel-28"; + page = floating_notebook_page(ppc); + ppc->type_tab = gtk_event_box_new(); + gtk_container_add(GTK_CONTAINER(ppc->type_tab), page); + ppc->type_tab_label = gtk_label_new (_("Floating Panel")); + gtk_notebook_append_page(GTK_NOTEBOOK (prop_nbook), + ppc->type_tab, + ppc->type_tab_label); + } else if(DRAWER_IS_WIDGET(panel)) { + BasePWidget *basep = BASEP_WIDGET(panel); + GtkWidget *applet = PANEL_WIDGET(basep->panel)->master_widget; + AppletInfo *info = + g_object_get_data (G_OBJECT (applet), "applet_info"); + add_drawer_properties_page(ppc, GTK_NOTEBOOK (prop_nbook), info->data); + help_path = "wgospanel.xml"; + help_linkid = "gospanel-550"; + /* we can't change to/from drawers anyhow */ + ppc->type_tab = NULL; + } + + /* Backing configuration */ + page = background_page (ppc); + gtk_notebook_append_page (GTK_NOTEBOOK(prop_nbook), + page, gtk_label_new (_("Background"))); + + g_object_set_data (G_OBJECT (ppc->config_window), "help_path", + help_path); + g_object_set_data (G_OBJECT (ppc->config_window), "help_linkid", + help_linkid); + g_signal_connect (G_OBJECT (ppc->config_window), "response", + G_CALLBACK (window_response), + prop_nbook); + + g_signal_connect (G_OBJECT (ppc->config_window), "event", + G_CALLBACK (config_event), + prop_nbook); + + ppc->register_changes = TRUE; + + /* show main window */ + gtk_widget_show_all (ppc->config_window); + } diff -crN ./gnome-panel/gnome-panel/panel-default-setup.entries /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-default-setup.entries *** ./gnome-panel/gnome-panel/panel-default-setup.entries Tue Jul 1 15:25:01 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-default-setup.entries Wed Dec 17 10:47:51 2003 *************** *** 98,104 **** size /schemas/apps/panel/toplevels/size ! 32 --- 98,104 ---- size /schemas/apps/panel/toplevels/size ! 24 *************** *** 131,137 **** size /schemas/apps/panel/toplevels/size ! 32 --- 131,137 ---- size /schemas/apps/panel/toplevels/size ! 24 diff -crN ./gnome-panel/gnome-panel/panel-enums.h /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-enums.h *** ./gnome-panel/gnome-panel/panel-enums.h Wed Jun 11 08:21:10 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-enums.h Thu Nov 6 18:06:13 2003 *************** *** 33,39 **** PANEL_ORIENTATION_TOP = 1 << 0, PANEL_ORIENTATION_RIGHT = 1 << 1, PANEL_ORIENTATION_BOTTOM = 1 << 2, ! PANEL_ORIENTATION_LEFT = 1 << 3, } PanelOrientation; #define PANEL_HORIZONTAL_MASK (PANEL_ORIENTATION_TOP | PANEL_ORIENTATION_BOTTOM) --- 33,39 ---- PANEL_ORIENTATION_TOP = 1 << 0, PANEL_ORIENTATION_RIGHT = 1 << 1, PANEL_ORIENTATION_BOTTOM = 1 << 2, ! PANEL_ORIENTATION_LEFT = 1 << 3 } PanelOrientation; #define PANEL_HORIZONTAL_MASK (PANEL_ORIENTATION_TOP | PANEL_ORIENTATION_BOTTOM) *************** *** 53,65 **** PANEL_STATE_HIDDEN_UP = 2, PANEL_STATE_HIDDEN_DOWN = 3, PANEL_STATE_HIDDEN_LEFT = 4, ! PANEL_STATE_HIDDEN_RIGHT = 5, } PanelState; typedef enum { PANEL_ANIMATION_SLOW = 0, PANEL_ANIMATION_MEDIUM = 1, ! PANEL_ANIMATION_FAST = 2, } PanelAnimationSpeed; typedef enum { --- 53,65 ---- PANEL_STATE_HIDDEN_UP = 2, PANEL_STATE_HIDDEN_DOWN = 3, PANEL_STATE_HIDDEN_LEFT = 4, ! PANEL_STATE_HIDDEN_RIGHT = 5 } PanelState; typedef enum { PANEL_ANIMATION_SLOW = 0, PANEL_ANIMATION_MEDIUM = 1, ! PANEL_ANIMATION_FAST = 2 } PanelAnimationSpeed; typedef enum { diff -crN ./gnome-panel/gnome-panel/panel-menu-bar.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-menu-bar.c *** ./gnome-panel/gnome-panel/panel-menu-bar.c Wed Aug 13 12:29:26 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-menu-bar.c Thu Nov 6 18:06:26 2003 *************** *** 42,48 **** #define MENU_FLAGS (MAIN_MENU_SYSTEM | MAIN_MENU_DISTRIBUTION_SUB) enum { ! PROP_0, }; struct _PanelMenuBarPrivate { --- 42,48 ---- #define MENU_FLAGS (MAIN_MENU_SYSTEM | MAIN_MENU_DISTRIBUTION_SUB) enum { ! PROP_0 }; struct _PanelMenuBarPrivate { diff -crN ./gnome-panel/gnome-panel/panel-per-panel-config.schemas.in /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-per-panel-config.schemas.in *** ./gnome-panel/gnome-panel/panel-per-panel-config.schemas.in Thu Jan 1 01:00:00 1970 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-per-panel-config.schemas.in Fri Aug 29 17:33:19 2003 *************** *** 0 **** --- 1,1350 ---- + + + + + + + + + + + + + + + + + /schemas/apps/panel/default_profiles/small/general/show_program_list + panel + bool + false + + Show the program listing in the Run box + Show the program listing by default when opening the Run box + + + + + /schemas/apps/panel/default_profiles/small/general/enable_program_list + panel + bool + true + + Enable the program listing in the run box + Enable the program listing in the run box + + + + + /schemas/apps/panel/default_profiles/small/general/panel_id_list + panel + list + string + [00000001] + + + + + + + + /schemas/apps/panel/default_profiles/small/general/applet_id_list + panel + list + string + [] + + + + + + + + /schemas/apps/panel/default_profiles/small/general/object_id_list + panel + list + string + [] + + + + + + + + + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_type + panel + string + edge-panel + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_size + panel + string + panel-size-x-small + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_hide_mode + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_hide_state + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/screen + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/monitor + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/screen_edge + panel + string + panel-edge-bottom + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/hide_buttons_enabled + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/hide_button_pixmaps_enabled + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_background_type + panel + string + no-background + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_background_pixmap + panel + string + + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_background_pixmap_fit + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_background_pixmap_stretch + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_background_pixmap_rotate + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/small/panels/00000001/panel_background_color + panel + string + #000000 + + + + + + + + + + + + + + + + + + + + + + + /schemas/apps/panel/default_profiles/medium/general/advanced_run_dialog + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/medium/general/panel_id_list + panel + list + string + [00000001,00000002] + + + + + + + + /schemas/apps/panel/default_profiles/medium/general/applet_id_list + panel + list + string + [00000001,00000002,00000003,00000004,show_desktop_button] + + + + + + + + /schemas/apps/panel/default_profiles/medium/general/object_id_list + panel + list + string + [00000001,00000002] + + + + + + + + + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_type + panel + string + edge-panel + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_size + panel + string + panel-size-x-small + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_hide_mode + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_hide_state + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/screen + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/monitor + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/screen_edge + panel + string + panel-edge-bottom + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/hide_buttons_enabled + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/hide_button_pixmaps_enabled + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_background_type + panel + string + no-background + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_background_pixmap + panel + string + + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_background_pixmap_fit + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_background_pixmap_stretch + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_background_pixmap_rotate + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_background_color + panel + string + #ffffff + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000001/panel_background_color_alpha + panel + int + 65535 + + + + + + + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000001/object_type + panel + string + launcher-object + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000001/launcher_location + panel + string + applications:///nautilus.desktop + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000001/panel_id + panel + string + 00000002 + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000001/position + panel + int + 20 + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000001/panel_right_stick + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000002/object_type + panel + string + launcher-object + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000002/launcher_location + panel + string + applications:///System/gnome-terminal.desktop + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000002/panel_id + panel + string + 00000002 + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000002/position + panel + int + 25 + + + + + + + + /schemas/apps/panel/default_profiles/medium/objects/00000002/panel_stick + panel + bool + false + + + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/show_desktop_button/object_type + panel + string + bonobo-applet + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/show_desktop_button/panel_id + panel + string + 00000001 + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/show_desktop_button/position + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/show_desktop_button/bonobo_iid + panel + string + OAFIID:GNOME_ShowDesktopApplet + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/show_desktop_button/panel_right_stick + panel + bool + false + + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000001/object_type + panel + string + bonobo-applet + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000001/panel_id + panel + string + 00000001 + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000001/position + panel + int + 1 + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000001/bonobo_iid + panel + string + OAFIID:GNOME_TasklistApplet + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000001/panel_right_stick + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000002/object_type + panel + string + bonobo-applet + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000002/panel_id + panel + string + 00000001 + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000002/position + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000002/bonobo_iid + panel + string + OAFIID:GNOME_PagerApplet + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000002/panel_right_stick + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000004/object_type + panel + string + bonobo-applet + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000004/panel_id + panel + string + 00000002 + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000004/position + panel + int + -1 + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000004/bonobo_iid + panel + string + OAFIID:GNOME_ClockApplet + + + + + + + + /schemas/apps/panel/default_profiles/medium/applets/00000004/panel_right_stick + panel + bool + true + + + + + + + + + + + + + + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/panel_type + panel + string + menu-panel + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/panel_size + panel + string + panel-size-x-small + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/screen + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/monitor + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/panel_background_type + panel + string + no-background + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/panel_background_pixmap + panel + string + + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/panel_background_pixmap_fit + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/panel_background_pixmap_stretch + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/panel_background_pixmap_rotate + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/panel_background_color + panel + string + #000000 + + + + + + + + /schemas/apps/panel/default_profiles/medium/panels/00000002/clock_format + panel + string + %I:%M %p + + + + + + + + + + + + + + + + + + + /schemas/apps/panel/default_profiles/large/general/advanced_run_dialog + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/large/general/panel_id_list + panel + list + string + [00000001,00000002] + + + + + + + + /schemas/apps/panel/default_profiles/large/general/applet_id_list + panel + list + string + [] + + + + + + + + /schemas/apps/panel/default_profiles/large/general/object_id_list + panel + list + string + [] + + + + + + + + + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_type + panel + string + edge-panel + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_size + panel + string + panel-size-medium + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_hide_mode + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_hide_state + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/screen + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/monitor + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/screen_edge + panel + string + panel-edge-bottom + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/hide_buttons_enabled + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/hide_button_pixmaps_enabled + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_background_type + panel + string + no-background + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_background_pixmap + panel + string + + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_background_pixmap_fit + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_background_pixmap_stretch + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_background_pixmap_rotate + panel + bool + true + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000001/panel_background_color + panel + string + #000000 + + + + + + + + + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/panel_type + panel + string + menu-panel + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/panel_size + panel + string + panel-size-small + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/screen + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/monitor + panel + int + 0 + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/panel_background_type + panel + string + no-background + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/panel_background_pixmap + panel + string + + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/panel_background_pixmap_fit + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/panel_background_pixmap_stretch + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/panel_background_pixmap_rotate + panel + bool + false + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/panel_background_color + panel + string + #000000 + + + + + + + + /schemas/apps/panel/default_profiles/large/panels/00000002/clock_format + panel + string + %I:%M:%S %p + + + + + + + + + + + + + + + + diff -crN ./gnome-panel/gnome-panel/panel-profile.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-profile.c *** ./gnome-panel/gnome-panel/panel-profile.c Fri Sep 5 15:18:22 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-profile.c Thu Nov 6 18:06:39 2003 *************** *** 323,329 **** GUINT_TO_POINTER (timeout)); } ! static const guint panel_profile_get_commit_timeout (GObject *object) { if (!commit_timeout_quark) --- 323,329 ---- GUINT_TO_POINTER (timeout)); } ! static guint panel_profile_get_commit_timeout (GObject *object) { if (!commit_timeout_quark) diff -crN ./gnome-panel/gnome-panel/panel-toplevel.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-toplevel.c *** ./gnome-panel/gnome-panel/panel-toplevel.c Fri Sep 5 15:47:58 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-toplevel.c Thu Nov 6 18:06:52 2003 *************** *** 205,211 **** PROP_ANIMATE, PROP_ANIMATION_SPEED, PROP_BUTTONS_ENABLED, ! PROP_ARROWS_ENABLED, }; static GObjectClass *parent_class; --- 205,211 ---- PROP_ANIMATE, PROP_ANIMATION_SPEED, PROP_BUTTONS_ENABLED, ! PROP_ARROWS_ENABLED }; static GObjectClass *parent_class; diff -crN ./gnome-panel/gnome-panel/panel-util.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-util.c *** ./gnome-panel/gnome-panel/panel-util.c Fri Sep 5 15:18:22 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-util.c Tue Mar 16 18:08:22 2004 *************** *** 1010,1015 **** --- 1010,1016 ---- "moe", NULL}; char *retval = NULL; + char *freeme = NULL; gboolean exists = TRUE; while (exists) { *************** *** 1025,1036 **** (guint) rnd, suffix); ! g_free (retval); ! retval = panel_make_full_path (dir, filename); ! exists = g_file_test (retval, G_FILE_TEST_EXISTS); g_free (filename); } return retval; #undef NUM_OF_WORDS --- 1026,1039 ---- (guint) rnd, suffix); ! g_free (freeme); ! freeme = panel_make_full_path (dir, filename); ! exists = g_file_test (freeme, G_FILE_TEST_EXISTS); g_free (filename); } + retval = g_strconcat ("file://", freeme, NULL); + g_free (freeme); return retval; #undef NUM_OF_WORDS diff -crN ./gnome-panel/gnome-panel/panel-xutils.h /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-xutils.h *** ./gnome-panel/gnome-panel/panel-xutils.h Tue Jul 8 18:30:05 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel-xutils.h Thu Nov 6 18:07:04 2003 *************** *** 38,44 **** typedef enum { PANEL_XUTILS_TYPE_NORMAL, ! PANEL_XUTILS_TYPE_DOCK, } PanelXUtilsWindowType; void panel_xutils_set_window_type (GdkWindow *gdk_window, --- 38,44 ---- typedef enum { PANEL_XUTILS_TYPE_NORMAL, ! PANEL_XUTILS_TYPE_DOCK } PanelXUtilsWindowType; void panel_xutils_set_window_type (GdkWindow *gdk_window, diff -crN ./gnome-panel/gnome-panel/panel.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel.c *** ./gnome-panel/gnome-panel/panel.c Tue Sep 2 12:59:07 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/panel.c Fri Oct 17 10:04:55 2003 *************** *** 58,64 **** TARGET_APPLET_INTERNAL, TARGET_ICON_INTERNAL, TARGET_BGIMAGE, ! TARGET_BACKGROUND_RESET, }; /*we call this recursively*/ --- 58,64 ---- TARGET_APPLET_INTERNAL, TARGET_ICON_INTERNAL, TARGET_BGIMAGE, ! TARGET_BACKGROUND_RESET }; /*we call this recursively*/ diff -crN ./gnome-panel/gnome-panel/quick-desktop-reader.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/quick-desktop-reader.c *** ./gnome-panel/gnome-panel/quick-desktop-reader.c Wed Aug 13 12:29:28 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/gnome-panel/quick-desktop-reader.c Fri Oct 17 10:05:04 2003 *************** *** 180,186 **** ENCODING_LEGACY_MIXED }; ! static const int guess_encoding (const char *uri, const char *name, const char *comment, --- 180,186 ---- ENCODING_LEGACY_MIXED }; ! static int guess_encoding (const char *uri, const char *name, const char *comment, diff -crN ./gnome-panel/libpanel-applet/Makefile.am /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/libpanel-applet/Makefile.am *** ./gnome-panel/libpanel-applet/Makefile.am Wed May 14 16:05:40 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/libpanel-applet/Makefile.am Wed Jan 21 10:00:57 2004 *************** *** 51,56 **** --- 51,58 ---- $(LIBPANEL_APPLET_LIBS) \ libpanel-applet-2.la + panel_test_applets_LDFLAGS = -export-dynamic + test_bonobo_applet_LDADD = \ $(LIBPANEL_APPLET_LIBS) \ libpanel-applet-2.la diff -crN ./gnome-panel/libpanel-applet/panel-applet.c /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/libpanel-applet/panel-applet.c *** ./gnome-panel/libpanel-applet/panel-applet.c Tue Jul 8 16:59:10 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/libpanel-applet/panel-applet.c Fri Oct 17 10:05:15 2003 *************** *** 102,108 **** PROPERTY_SIZE_IDX, PROPERTY_BACKGROUND_IDX, PROPERTY_FLAGS_IDX, ! PROPERTY_SIZE_HINTS_IDX, }; static void --- 102,108 ---- PROPERTY_SIZE_IDX, PROPERTY_BACKGROUND_IDX, PROPERTY_FLAGS_IDX, ! PROPERTY_SIZE_HINTS_IDX }; static void diff -crN ./gnome-panel/omf.make /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/omf.make *** ./gnome-panel/omf.make Tue Sep 9 15:57:24 2003 --- /gestconf/project/GNOME_ACL/GNOME/build/sh_build_GNOME/src/./gnome-panel/omf.make Fri Oct 17 10:05:33 2003 *************** *** 1,3 **** --- 1,4 ---- + # # No modifications of this Makefile should be necessary. # *************** *** 43,49 **** install-data-hook-omf: $(mkinstalldirs) $(DESTDIR)$(omf_dest_dir) for file in $(omffile); do \ ! $(INSTALL_DATA) $$file.out $(DESTDIR)$(omf_dest_dir)/$$file; \ done -scrollkeeper-update -p $(scrollkeeper_localstate_dir) -o $(DESTDIR)$(omf_dest_dir) --- 44,50 ---- install-data-hook-omf: $(mkinstalldirs) $(DESTDIR)$(omf_dest_dir) for file in $(omffile); do \ ! $(INSTALL_DATA) $(srcdir)/$$file $(DESTDIR)$(omf_dest_dir)/$$file; \ done -scrollkeeper-update -p $(scrollkeeper_localstate_dir) -o $(DESTDIR)$(omf_dest_dir)