xemacs 21.4.17 install problem
18 years, 12 months
David Bishop
David Bishop
I'm building Xemacs on a SUN, I ran "config" as follows:
./configure --site-prefixes=/packages/xemacs_21.4.17/xlib
--prefix=/packages/xemacs_21.4.17 --with-gtk --with-jpeg --with-png --with-xpm
--x-libraries=/packages/X11R6.4/lib --x-includes=/packages/X11R6.4/include
I downloaded all of the packages I am configuring with from the web page, and as
you can see I'm trying to compile 21.4.17. There were a few files and links in
the wrong spots, which I fixed (X11 link, libjpg.a, etc). The error that I hit
that I couldn't get around was:
cc -c -v -xO4 -Demacs -I. -DHAVE_CONFIG_H
-I/packages/xemacs_21.4.17/xlib/include -I/packages/X11R6.4/include menubar-gtk.c
"menubar-gtk.c", line 142: warning: implicitly declaring function to return int:
FRAME_GTK_TEXT_WIDGET()
"menubar-gtk.c", line 142: warning: improper pointer/integer combination: arg #1
"menubar-gtk.c", line 563: warning: argument #1 is incompatible with prototype:
prototype: pointer to char : "menubar-gtk.c", line 281
argument : pointer to uchar
"menubar-gtk.c", line 567: warning: argument #1 is incompatible with prototype:
prototype: pointer to const char : "menubar-gtk.c", line 470
argument : pointer to uchar
"menubar-gtk.c", line 738: warning: implicitly declaring function to return int:
gtk_widget_to_frame()
"menubar-gtk.c", line 744: warning: implicitly declaring function to return int:
signal_special_gtk_user_event()
"menubar-gtk.c", line 861: warning: argument #1 is incompatible with prototype:
prototype: pointer to char : "menubar-gtk.c", line 281
argument : pointer to uchar
"menubar-gtk.c", line 1079: warning: implicitly declaring function to return
int: FRAME_GTK_MENUBAR_WIDGET()
"menubar-gtk.c", line 1079: warning: improper pointer/integer combination: op "="
"menubar-gtk.c", line 1129: warning: argument #2 is incompatible with prototype:
prototype: pointer to const char : "menubar-gtk.c", line 1046
argument : pointer to uchar
"menubar-gtk.c", line 1178: warning: implicitly declaring function to return
int: FRAME_GTK_SHELL_WIDGET()
"menubar-gtk.c", line 1215: warning: implicitly declaring function to return
int: FRAME_GTK_CONTAINER_WIDGET()
"menubar-gtk.c", line 1225: left operand must be modifiable lvalue: op "="
"menubar-gtk.c", line 1228: cannot recover from previous errors
cc: acomp failed for menubar-gtk.c
*** Error code 2
make: Fatal error: Command failed for target `menubar-gtk.o'
Current working directory /packages/xemacs_21.4.17/xemacs-21.4.17/src
*** Error code 1
make: Fatal error: Command failed for target `src'
I fail at the file, using gcc, or Sparcworks 5 C compiler.
Do I have a bad version of something?
--
David W. Bishop dbishop(a)vhdl.org All standard disclaimers apply.
/* Implements an elisp-programmable menubar -- Gtk interface.
Copyright (C) 1993, 1994 Free Software Foundation, Inc.
Copyright (C) 1995 Tinker Systems and INS Engineering Corp.
This file is part of XEmacs.
XEmacs 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, or (at your option) any
later version.
XEmacs 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 XEmacs; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Synched up with: Not in FSF. */
/* created 16-dec-91 by jwz */
#include <config.h>
#include "lisp.h"
#include "console-gtk.h"
#include "gui-gtk.h"
#include "buffer.h"
#include "commands.h" /* zmacs_regions */
#include "ui-gtk.h"
#include "gui.h"
#include "events.h"
#include "frame.h"
#include "opaque.h"
#include "window.h"
#ifdef HAVE_GNOME
#include <libgnomeui/libgnomeui.h>
#endif
#define MENUBAR_TYPE 0
#define SUBMENU_TYPE 1
#define POPUP_TYPE 2
static GtkWidget *menu_descriptor_to_widget_1 (Lisp_Object descr, GtkAccelGroup* accel_group);
#define FRAME_MENUBAR_DATA(frame) ((frame)->menubar_data)
#define XFRAME_MENUBAR_DATA_LASTBUFF(frame) (XCAR ((frame)->menubar_data))
#define XFRAME_MENUBAR_DATA_UPTODATE(frame) (XCDR ((frame)->menubar_data))
/* This is a bogus subclass of GtkMenuBar so that the menu never tries
** to be bigger than the text widget. This prevents weird resizing
** when jumping around between buffers with radically different menu
** sizes.
*/
#define GTK_XEMACS_MENUBAR(obj) GTK_CHECK_CAST (obj, gtk_xemacs_menubar_get_type (), GtkXEmacsMenubar)
#define GTK_XEMACS_MENUBAR_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_xemacs_menubar_get_type (), GtkXEmacsMenubarClass)
#define GTK_IS_XEMACS_MENUBAR(obj) GTK_CHECK_TYPE (obj, gtk_xemacs_menubar_get_type ())
#define GTK_XEMACS_MENUBAR_FRAME(obj) GTK_XEMACS_MENUBAR (obj)->f
typedef struct _GtkXEmacsMenubar GtkXEmacsMenubar;
typedef struct _GtkXEmacsMenubarClass GtkXEmacsMenubarClass;
struct _GtkXEmacsMenubar
{
GtkMenuBar menu;
struct frame *frame;
};
struct _GtkXEmacsMenubarClass
{
GtkMenuBarClass parent_class;
};
guint gtk_xemacs_menubar_get_type (void);
GtkWidget *gtk_xemacs_menubar_new (struct frame *f);
static void gtk_xemacs_menubar_class_init (GtkXEmacsMenubarClass *klass);
static void gtk_xemacs_menubar_init (GtkXEmacsMenubar *xemacs);
static void gtk_xemacs_menubar_size_request (GtkWidget *widget, GtkRequisition *requisition);
guint
gtk_xemacs_menubar_get_type (void)
{
static guint xemacs_menubar_type;
if (!xemacs_menubar_type)
{
static const GtkTypeInfo xemacs_menubar_info =
{
"GtkXEmacsMenubar",
sizeof (GtkXEmacsMenubar),
sizeof (GtkXEmacsMenubarClass),
(GtkClassInitFunc) gtk_xemacs_menubar_class_init,
(GtkObjectInitFunc) gtk_xemacs_menubar_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
xemacs_menubar_type = gtk_type_unique (gtk_menu_bar_get_type (), &xemacs_menubar_info);
}
return xemacs_menubar_type;
}
static GtkWidgetClass *menubar_parent_class;
static void gtk_xemacs_menubar_class_init (GtkXEmacsMenubarClass *klass)
{
GtkWidgetClass *widget_class;
widget_class = (GtkWidgetClass*) klass;
menubar_parent_class = (GtkWidgetClass *) gtk_type_class (gtk_menu_bar_get_type ());
widget_class->size_request = gtk_xemacs_menubar_size_request;
}
static void gtk_xemacs_menubar_init (GtkXEmacsMenubar *xemacs)
{
}
static void gtk_xemacs_menubar_size_request (GtkWidget *widget, GtkRequisition *requisition)
{
GtkXEmacsMenubar *x = GTK_XEMACS_MENUBAR (widget);
GtkRequisition frame_size;
menubar_parent_class->size_request (widget, requisition);
/* #### BILL!
** We should really only do this if the menu has not been detached!
**
** WMP 9/9/2000
*/
gtk_widget_size_request (FRAME_GTK_TEXT_WIDGET (x->frame), &frame_size);
requisition->width = frame_size.width;
}
GtkWidget *
gtk_xemacs_menubar_new (struct frame *f)
{
GtkXEmacsMenubar *menubar = gtk_type_new (gtk_xemacs_menubar_get_type ());
menubar->frame = f;
return (GTK_WIDGET (menubar));
}
/*
* Label with XEmacs accelerator character support.
*
* The default interfaces to GtkAccelLabel does not understand XEmacs
* keystroke printing conventions, nor is it convenient in the places where is
* it needed. This subclass provides an alternative interface more suited to
* XEmacs needs but does not add new functionality.
*/
#define GTK_TYPE_XEMACS_ACCEL_LABEL (gtk_xemacs_accel_label_get_type ())
#define GTK_XEMACS_ACCEL_LABEL(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_ACCEL_LABEL, GtkXEmacsAccelLabel))
#define GTK_XEMACS_ACCEL_LABEL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCEL_LABEL, GtkXEmacsAccelLabelClass))
#define GTK_IS_XEMACS_ACCEL_LABEL(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_XEMACS_ACCEL_LABEL))
#define GTK_IS_XEMACS_ACCEL_LABEL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_XEMACS_ACCEL_LABEL))
typedef struct _GtkXEmacsAccelLabel GtkXEmacsAccelLabel;
typedef struct _GtkXEmacsAccelLabelClass GtkXEmacsAccelLabelClass;
/* Instance structure. No additional fields required. */
struct _GtkXEmacsAccelLabel
{
GtkAccelLabel label;
};
/* Class structure. No additional fields required. */
struct _GtkXEmacsAccelLabelClass
{
GtkAccelLabelClass parent_class;
};
static GtkType gtk_xemacs_accel_label_get_type(void);
static GtkWidget* gtk_xemacs_accel_label_new(const gchar *string);
static void gtk_xemacs_set_accel_keys(GtkXEmacsAccelLabel* l,
Lisp_Object keys);
static void gtk_xemacs_accel_label_class_init(GtkXEmacsAccelLabelClass *klass);
static void gtk_xemacs_accel_label_init(GtkXEmacsAccelLabel *xemacs);
static GtkType
gtk_xemacs_accel_label_get_type(void)
{
static GtkType xemacs_accel_label_type = 0;
if (!xemacs_accel_label_type)
{
static const GtkTypeInfo xemacs_accel_label_info =
{
"GtkXEmacsAccelLabel",
sizeof (GtkXEmacsAccelLabel),
sizeof (GtkXEmacsAccelLabelClass),
(GtkClassInitFunc) gtk_xemacs_accel_label_class_init,
(GtkObjectInitFunc) gtk_xemacs_accel_label_init,
/* reserved_1 */ NULL,
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
xemacs_accel_label_type = gtk_type_unique (gtk_accel_label_get_type(), &xemacs_accel_label_info);
}
return xemacs_accel_label_type;
}
static void
gtk_xemacs_accel_label_class_init(GtkXEmacsAccelLabelClass *klass)
{
/* Nothing to do. */
}
static void
gtk_xemacs_accel_label_init(GtkXEmacsAccelLabel *xemacs)
{
/* Nothing to do. */
}
static GtkWidget*
gtk_xemacs_accel_label_new (const gchar *string)
{
GtkXEmacsAccelLabel *xemacs_accel_label;
xemacs_accel_label = gtk_type_new (GTK_TYPE_XEMACS_ACCEL_LABEL);
if (string && *string)
gtk_label_set_text (GTK_LABEL (xemacs_accel_label), string);
return GTK_WIDGET (xemacs_accel_label);
}
/* Make the string <keys> the accelerator string for the label. */
static void
gtk_xemacs_set_accel_keys(GtkXEmacsAccelLabel* l, Lisp_Object keys)
{
g_return_if_fail (l != NULL);
g_return_if_fail (GTK_IS_XEMACS_ACCEL_LABEL (l));
/* Disable the standard way of finding the accelerator string for the
label. */
gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL(l), NULL);
/* Set the string straight from the object. */
if (STRINGP (keys) && XSTRING_LENGTH (keys))
{
C_STRING_TO_EXTERNAL_MALLOC(XSTRING_DATA (keys),
l->label.accel_string,
Qctext);
}
else
{
/* l->label.accel_string = NULL;*/
}
}
/* We now return you to your regularly scheduled menus... */
int dockable_menubar;
/* #define TEAR_OFF_MENUS */
#ifdef TEAR_OFF_MENUS
int tear_off_menus;
#endif
/* Converting from XEmacs to GTK representation */
static Lisp_Object
menu_name_to_accelerator (char *name)
{
while (*name) {
if (*name=='%') {
++name;
if (!(*name))
return Qnil;
if (*name=='_' && *(name+1))
{
int accelerator = (int) (unsigned char) (*(name+1));
return make_char (tolower (accelerator));
}
}
++name;
}
return Qnil;
}
#define XEMACS_MENU_DESCR_TAG "xemacs::menu::description"
#define XEMACS_MENU_FILTER_TAG "xemacs::menu::filter"
#define XEMACS_MENU_GUIID_TAG "xemacs::menu::gui_id"
#define XEMACS_MENU_FIRSTTIME_TAG "xemacs::menu::first_time"
static void __activate_menu(GtkMenuItem *, gpointer);
#ifdef TEAR_OFF_MENUS
static void
__torn_off_sir(GtkMenuItem *item, gpointer user_data)
{
GtkWidget *menu_item = GTK_WIDGET (user_data);
if (GTK_TEAROFF_MENU_ITEM (item)->torn_off)
{
/* Menu was just torn off */
GUI_ID id = new_gui_id ();
Lisp_Object menu_desc = Qnil;
GtkWidget *old_submenu = GTK_MENU_ITEM (menu_item)->submenu;
VOID_TO_LISP (menu_desc, gtk_object_get_data (GTK_OBJECT (menu_item), XEMACS_MENU_DESCR_TAG));
/* GCPRO all of our very own */
gcpro_popup_callbacks (id, menu_desc);
/* Hide the now detached menu from the attentions of
__activate_menu destroying the old submenu */
#if 0
gtk_widget_ref (old_submenu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), gtk_menu_new ());
gtk_widget_show_all (old_submenu);
#endif
}
}
#endif
/* This is called when a menu is about to be shown... this is what
does the delayed creation of the menu items. We populate the
submenu and away we go. */
static void
__maybe_destroy (GtkWidget *child, GtkWidget *precious)
{
if (GTK_IS_MENU_ITEM (child) && !GTK_IS_TEAROFF_MENU_ITEM (child))
{
if (GTK_WIDGET_VISIBLE (child))
{
/* If we delete the menu item that was 'active' when the
menu was cancelled, GTK gets upset because it tries to
remove the focus rectangle from a (now) dead widget.
This widget will eventually get killed because it will
not be visible the next time the window is shown.
*/
gtk_widget_set_sensitive (child, FALSE);
gtk_widget_hide_all (child);
}
else
{
gtk_widget_destroy (child);
}
}
}
/* If user_data != 0x00 then we are using a hook to build the menu. */
static void
__activate_menu(GtkMenuItem *item, gpointer user_data)
{
Lisp_Object desc;
gpointer force_clear = gtk_object_get_data (GTK_OBJECT (item), XEMACS_MENU_FIRSTTIME_TAG);
gtk_object_set_data (GTK_OBJECT (item), XEMACS_MENU_FIRSTTIME_TAG, 0x00);
/* Delete the old contents of the menu if we are the top level menubar */
if (GTK_IS_MENU_BAR (GTK_WIDGET (item)->parent) || force_clear)
{
GtkWidget *selected = gtk_menu_get_active (GTK_MENU (item->submenu));
gtk_container_foreach (GTK_CONTAINER (item->submenu),(GtkCallback) __maybe_destroy,
selected);
}
else if (gtk_container_children (GTK_CONTAINER (item->submenu)))
{
return;
}
VOID_TO_LISP (desc, gtk_object_get_data (GTK_OBJECT (item), XEMACS_MENU_DESCR_TAG));
#ifdef TEAR_OFF_MENUS
/* Lets stick in a detacher just for giggles */
if (tear_off_menus && !gtk_container_children (GTK_CONTAINER (item->submenu)))
{
GtkWidget *w = gtk_tearoff_menu_item_new ();
gtk_widget_show (w);
gtk_menu_append (GTK_MENU (item->submenu), w);
gtk_signal_connect (GTK_OBJECT (w), "activate", GTK_SIGNAL_FUNC (__torn_off_sir), item);
}
#endif
if (user_data)
{
GUI_ID id = (GUI_ID) gtk_object_get_data (GTK_OBJECT (item), XEMACS_MENU_GUIID_TAG);
Lisp_Object hook_fn;
struct gcpro gcpro1, gcpro2;
VOID_TO_LISP (hook_fn, gtk_object_get_data (GTK_OBJECT (item), XEMACS_MENU_FILTER_TAG));
GCPRO2 (desc, hook_fn);
desc = call1 (hook_fn, desc);
UNGCPRO;
ungcpro_popup_callbacks (id);
gcpro_popup_callbacks (id, desc);
}
/* Build the child widgets */
for (; !NILP (desc); desc = Fcdr (desc))
{
GtkWidget *next = NULL;
Lisp_Object child = Fcar (desc);
if (NILP (child)) /* the partition */
{
/* Signal an error here? The NILP handling is handled a
layer higher where appropriate */
}
else
{
next = menu_descriptor_to_widget_1 (child,
gtk_menu_ensure_uline_accel_group (GTK_MENU (item->submenu)));
}
if (!next)
{
continue;
}
gtk_widget_show_all (next);
gtk_menu_append (GTK_MENU (item->submenu), next);
}
}
/* This is called whenever an item with a GUI_ID associated with it is
destroyed. This allows us to remove the references in gui-gtk.c
that made sure callbacks and such were GCPRO-ed
*/
static void
__remove_gcpro_by_id (gpointer user_data)
{
ungcpro_popup_callbacks ((GUI_ID) user_data);
}
static void
__kill_stupid_gtk_timer (GtkObject *obj, gpointer user_data)
{
GtkMenuItem *mi = GTK_MENU_ITEM (obj);
if (mi->timer)
{
gtk_timeout_remove (mi->timer);
mi->timer = 0;
}
}
/* Convert the XEmacs menu accelerator representation to Gtk mnemonic form. If
no accelerator has been provided, put one at the start of the string (this
mirrors the behaviour under X). This algorithm is also found in
dialog-gtk.el:gtk-popup-convert-underscores.
*/
static char *
convert_underscores(const char *name)
{
char *rval;
int i,j;
int found_accel = FALSE;
int underscores = 0;
for (i = 0; name[i]; ++i)
if (name[i] == '%' && name[i+1] == '_')
{
found_accel = TRUE;
}
else if (name[i] == '_')
{
underscores++;
}
/* Allocate space for the original string, plus zero byte plus extra space
for all quoted underscores plus possible additional leading accelerator. */
rval = xmalloc_and_zero (strlen(name) + 1 + underscores
+ (found_accel ? 0 : 1));
if (!found_accel)
rval[0] = '_';
for (i = 0, j = (found_accel ? 0 : 1); name[i]; i++)
{
if (name[i]=='%')
{
i++;
if (!(name[i]))
continue;
if ((name[i] != '_') && (name[i] != '%'))
i--;
found_accel = TRUE;
}
else if (name[i] == '_')
{
rval[j++] = '_';
}
rval[j++] = name[i];
}
return rval;
}
/* Remove the XEmacs menu accellerator representation from a string. */
static char *
remove_underscores(const char *name)
{
char *rval = xmalloc_and_zero (strlen(name) + 1);
int i,j;
for (i = 0, j = 0; name[i]; i++)
{
if (name[i]=='%') {
i++;
if (!(name[i]))
continue;
if ((name[i] != '_') && (name[i] != '%'))
i--;
else
continue;
}
rval[j++] = name[i];
}
return rval;
}
/* This converts an entire menu into a GtkMenuItem (with an attached
submenu). A menu is a list of (STRING [:keyword value]+ [DESCR]+)
DESCR is either a list (meaning a submenu), a vector, or nil (if
you include a :filter keyword) */
static GtkWidget *
menu_convert (Lisp_Object desc, GtkWidget *reuse,
GtkAccelGroup* menubar_accel_group)
{
GtkWidget *menu_item = NULL;
GtkWidget *submenu = NULL;
Lisp_Object key, val;
Lisp_Object include_p = Qnil, hook_fn = Qnil, config_tag = Qnil;
Lisp_Object active_p = Qt;
Lisp_Object accel;
int included_spec = 0;
int active_spec = 0;
if (STRINGP (XCAR (desc)))
{
accel = menu_name_to_accelerator (XSTRING_DATA (XCAR (desc)));
if (!reuse)
{
char *temp_menu_name = convert_underscores (XSTRING_DATA (XCAR (desc)));
GtkWidget* accel_label = gtk_xemacs_accel_label_new(NULL);
guint accel_key;
gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);
accel_key = gtk_label_parse_uline (GTK_LABEL (accel_label), temp_menu_name);
menu_item = gtk_menu_item_new ();
gtk_container_add (GTK_CONTAINER (menu_item), accel_label);
gtk_widget_show (accel_label);
if (menubar_accel_group)
gtk_widget_add_accelerator (menu_item,
"activate_item",
menubar_accel_group,
accel_key, GDK_MOD1_MASK,
GTK_ACCEL_LOCKED);
free (temp_menu_name);
}
else
{
menu_item = reuse;
}
submenu = gtk_menu_new ();
gtk_widget_show (menu_item);
gtk_widget_show (submenu);
if (!reuse)
gtk_signal_connect (GTK_OBJECT (menu_item), "destroy",
GTK_SIGNAL_FUNC (__kill_stupid_gtk_timer), NULL);
/* Without this sometimes a submenu gets left on the screen -
** urk
*/
if (GTK_MENU_ITEM (menu_item)->submenu)
{
gtk_widget_destroy (GTK_MENU_ITEM (menu_item)->submenu);
}
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
/* We put this bogus menu item in so that GTK does the right
** thing when the menu is near the screen border.
**
** Aug 29, 2000
*/
{
GtkWidget *bogus_item = gtk_menu_item_new_with_label ("A suitably long label here...");
gtk_object_set_data (GTK_OBJECT (menu_item), XEMACS_MENU_FIRSTTIME_TAG, (gpointer)0x01);
gtk_widget_show_all (bogus_item);
gtk_menu_append (GTK_MENU (submenu), bogus_item);
}
desc = Fcdr (desc);
while (key = Fcar (desc), KEYWORDP (key))
{
Lisp_Object cascade = desc;
desc = Fcdr (desc);
if (NILP (desc))
signal_simple_error ("keyword in menu lacks a value",
cascade);
val = Fcar (desc);
desc = Fcdr (desc);
if (EQ (key, Q_included))
include_p = val, included_spec = 1;
else if (EQ (key, Q_config))
config_tag = val;
else if (EQ (key, Q_filter))
hook_fn = val;
else if (EQ (key, Q_active))
active_p = val, active_spec = 1;
else if (EQ (key, Q_accelerator))
{
#if 0
if ( SYMBOLP (val)
|| CHARP (val))
wv->accel = LISP_TO_VOID (val);
else
signal_simple_error ("bad keyboard accelerator", val);
#endif
}
else if (EQ (key, Q_label))
{
/* implement in 21.2 */
}
else
signal_simple_error ("unknown menu cascade keyword", cascade);
}
gtk_object_set_data (GTK_OBJECT (menu_item), XEMACS_MENU_DESCR_TAG, LISP_TO_VOID (desc));
gtk_object_set_data (GTK_OBJECT (menu_item), XEMACS_MENU_FILTER_TAG, LISP_TO_VOID (hook_fn));
if ((!NILP (config_tag)
&& NILP (Fmemq (config_tag, Vmenubar_configuration)))
|| (included_spec && NILP (Feval (include_p))))
{
return (NULL);
}
if (active_spec)
active_p = Feval (active_p);
gtk_widget_set_sensitive (GTK_WIDGET (menu_item), ! NILP (active_p));
}
else
{
signal_simple_error ("menu name (first element) must be a string",
desc);
}
/* If we are reusing a widget, we need to make sure we clean
** everything up.
*/
if (reuse)
{
gpointer id = gtk_object_get_data (GTK_OBJECT (reuse), XEMACS_MENU_GUIID_TAG);
if (id)
{
/* If the menu item had a GUI_ID that means it was a filter menu */
__remove_gcpro_by_id (id);
gtk_signal_disconnect_by_func (GTK_OBJECT (reuse),
GTK_SIGNAL_FUNC (__activate_menu),
(gpointer) 0x01 );
}
else
{
gtk_signal_disconnect_by_func (GTK_OBJECT (reuse),
GTK_SIGNAL_FUNC (__activate_menu),
NULL);
}
GTK_MENU_ITEM (reuse)->right_justify = 0;
}
if (NILP (hook_fn))
{
/* Generic menu builder */
gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
GTK_SIGNAL_FUNC (__activate_menu),
NULL);
}
else
{
GUI_ID id = new_gui_id ();
gtk_object_set_data (GTK_OBJECT (menu_item), XEMACS_MENU_GUIID_TAG,
(gpointer) id);
/* Make sure we gcpro the menu descriptions */
gcpro_popup_callbacks (id, desc);
gtk_object_weakref (GTK_OBJECT (menu_item), __remove_gcpro_by_id,
(gpointer) id);
gtk_signal_connect (GTK_OBJECT (menu_item), "activate",
GTK_SIGNAL_FUNC (__activate_menu),
(gpointer) 0x01);
}
return (menu_item);
}
/* Called whenever a button, radio, or toggle is selected in the menu */
static void
__generic_button_callback (GtkMenuItem *item, gpointer user_data)
{
Lisp_Object callback, function, data, channel;
XSETFRAME (channel, gtk_widget_to_frame (GTK_WIDGET (item)));
VOID_TO_LISP (callback, user_data);
get_gui_callback (callback, &function, &data);
signal_special_gtk_user_event (channel, function, data);
}
/* Convert a single menu item descriptor to a suitable GtkMenuItem */
/* This function cannot GC.
It is only called from menu_item_descriptor_to_widget_value, which
prohibits GC. */
static GtkWidget *
menu_descriptor_to_widget_1 (Lisp_Object descr, GtkAccelGroup* accel_group)
{
if (STRINGP (descr))
{
/* It is a separator. Unfortunately GTK does not allow us to
specify what our separators look like, so we can't do all the
fancy stuff that the X code does.
*/
return (gtk_menu_item_new ());
}
else if (LISTP (descr))
{
/* It is a submenu */
return (menu_convert (descr, NULL, accel_group));
}
else if (VECTORP (descr))
{
/* An actual menu item description! This gets yucky. */
Lisp_Object name = Qnil;
Lisp_Object callback = Qnil;
Lisp_Object suffix = Qnil;
Lisp_Object active_p = Qt;
Lisp_Object include_p = Qt;
Lisp_Object selected_p = Qnil;
Lisp_Object keys = Qnil;
Lisp_Object style = Qnil;
Lisp_Object config_tag = Qnil;
Lisp_Object accel = Qnil;
GtkWidget *main_label = NULL;
int length = XVECTOR_LENGTH (descr);
Lisp_Object *contents = XVECTOR_DATA (descr);
int plist_p;
int selected_spec = 0, included_spec = 0;
GtkWidget *widget = NULL;
guint accel_key;
if (length < 2)
signal_simple_error ("button descriptors must be at least 2 long", descr);
/* length 2: [ "name" callback ]
length 3: [ "name" callback active-p ]
length 4: [ "name" callback active-p suffix ]
or [ "name" callback keyword value ]
length 5+: [ "name" callback [ keyword value ]+ ]
*/
plist_p = (length >= 5 || (length > 2 && KEYWORDP (contents [2])));
if (!plist_p && length > 2)
/* the old way */
{
name = contents [0];
callback = contents [1];
active_p = contents [2];
if (length == 4)
suffix = contents [3];
}
else
{
/* the new way */
int i;
if (length & 1)
signal_simple_error (
"button descriptor has an odd number of keywords and values",
descr);
name = contents [0];
callback = contents [1];
for (i = 2; i < length;)
{
Lisp_Object key = contents [i++];
Lisp_Object val = contents [i++];
if (!KEYWORDP (key))
signal_simple_error_2 ("not a keyword", key, descr);
if (EQ (key, Q_active)) active_p = val;
else if (EQ (key, Q_suffix)) suffix = val;
else if (EQ (key, Q_keys)) keys = val;
else if (EQ (key, Q_key_sequence)) ; /* ignored for FSF compat */
else if (EQ (key, Q_label)) ; /* implement for 21.0 */
else if (EQ (key, Q_style)) style = val;
else if (EQ (key, Q_selected)) selected_p = val, selected_spec = 1;
else if (EQ (key, Q_included)) include_p = val, included_spec = 1;
else if (EQ (key, Q_config)) config_tag = val;
else if (EQ (key, Q_accelerator))
{
if ( SYMBOLP (val) || CHARP (val))
accel = val;
else
signal_simple_error ("bad keyboard accelerator", val);
}
else if (EQ (key, Q_filter))
signal_simple_error(":filter keyword not permitted on leaf nodes", descr);
else
signal_simple_error_2 ("unknown menu item keyword", key, descr);
}
}
#ifdef HAVE_MENUBARS
if ((!NILP (config_tag) && NILP (Fmemq (config_tag, Vmenubar_configuration)))
|| (included_spec && NILP (Feval (include_p))))
{
/* the include specification says to ignore this item. */
return 0;
}
#endif /* HAVE_MENUBARS */
CHECK_STRING (name);
if (NILP (accel))
accel = menu_name_to_accelerator (XSTRING_DATA (name));
if (!NILP (suffix))
suffix = Feval (suffix);
if (!separator_string_p (XSTRING_DATA (name)))
{
char *label_buffer = NULL;
char *temp_label = NULL;
if (STRINGP (suffix) && XSTRING_LENGTH (suffix))
{
label_buffer = alloca (XSTRING_LENGTH (name) + 15 + XSTRING_LENGTH (suffix));
sprintf (label_buffer, "%s %s ", XSTRING_DATA (name), XSTRING_DATA (suffix));
}
else
{
label_buffer = alloca (XSTRING_LENGTH (name) + 15);
sprintf (label_buffer, "%s ", XSTRING_DATA (name));
}
temp_label = convert_underscores (label_buffer);
main_label = gtk_xemacs_accel_label_new (NULL);
accel_key = gtk_label_parse_uline (GTK_LABEL (main_label), temp_label);
free (temp_label);
}
/* Evaluate the selected and active items now */
if (selected_spec)
{
if (NILP (selected_p) || EQ (selected_p, Qt))
{
/* Do nothing */
}
else
{
selected_p = Feval (selected_p);
}
}
if (NILP (active_p) || EQ (active_p, Qt))
{
/* Do Nothing */
}
else
{
active_p = Feval (active_p);
}
if (0 ||
#ifdef HAVE_MENUBARS
menubar_show_keybindings
#endif
)
{
/* Need to get keybindings */
if (!NILP (keys))
{
/* User-specified string to generate key bindings with */
CHECK_STRING (keys);
keys = Fsubstitute_command_keys (keys);
}
else if (SYMBOLP (callback))
{
char buf[1024];
/* #### Warning, dependency here on current_buffer and point */
where_is_to_char (callback, buf);
keys = build_string (buf);
}
}
/* Now we get down to the dirty business of creating the widgets */
if (NILP (style) || EQ (style, Qtext) || EQ (style, Qbutton))
{
/* A normal menu item */
widget = gtk_menu_item_new ();
}
else if (EQ (style, Qtoggle) || EQ (style, Qradio))
{
/* They are radio or toggle buttons.
XEmacs' menu descriptions are fairly lame in that they do
not have the idea of a 'group' of radio buttons. They
are exactly like toggle buttons except that they get
drawn differently.
GTK rips us a new one again. If you have a radio button
in a group by itself, it always draws it as highlighted.
So we dummy up and create a second radio button that does
not get added to the menu, but gets invisibly set/unset
when the other gets unset/set. *sigh*
*/
if (EQ (style, Qradio))
{
GtkWidget *dummy_sibling = NULL;
GSList *group = NULL;
dummy_sibling = gtk_radio_menu_item_new (group);
group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (dummy_sibling));
widget = gtk_radio_menu_item_new (group);
/* We need to notice when the 'real' one gets destroyed
so we can clean up the dummy as well. */
gtk_object_weakref (GTK_OBJECT (widget),
(GtkDestroyNotify) gtk_widget_destroy,
dummy_sibling);
}
else
{
widget = gtk_check_menu_item_new ();
}
/* What horrible defaults you have GTK dear! The default
for a toggle menu item is to not show the toggle unless it
is turned on or actively highlighted. How absolutely
hideous. */
gtk_check_menu_item_set_show_toggle (GTK_CHECK_MENU_ITEM (widget), TRUE);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (widget),
NILP (selected_p) ? FALSE : TRUE);
}
else
{
signal_simple_error_2 ("unknown style", style, descr);
}
gtk_widget_set_sensitive (widget, ! NILP (active_p));
gtk_signal_connect (GTK_OBJECT (widget), "activate-item",
GTK_SIGNAL_FUNC (__generic_button_callback),
LISP_TO_VOID (callback));
gtk_signal_connect (GTK_OBJECT (widget), "activate",
GTK_SIGNAL_FUNC (__generic_button_callback),
LISP_TO_VOID (callback));
/* Now that all the information about the menu item is know, set the
remaining properties.
*/
if (main_label)
{
gtk_container_add (GTK_CONTAINER (widget), main_label);
gtk_misc_set_alignment (GTK_MISC (main_label), 0.0, 0.5);
gtk_xemacs_set_accel_keys(GTK_XEMACS_ACCEL_LABEL(main_label), keys);
if (accel_group)
gtk_widget_add_accelerator (widget,
"activate_item",
accel_group,
accel_key, 0,
GTK_ACCEL_LOCKED);
}
return (widget);
}
else
{
return (NULL);
/* ABORT (); ???? */
}
}
static GtkWidget *
menu_descriptor_to_widget (Lisp_Object descr, GtkAccelGroup* accel_group)
{
int count = specpdl_depth ();
GtkWidget *rval = NULL;
record_unwind_protect (restore_gc_inhibit, make_int (gc_currently_forbidden));
gc_currently_forbidden = 1;
/* Cannot GC from here on out... */
rval = menu_descriptor_to_widget_1 (descr, accel_group);
unbind_to (count, Qnil);
return (rval);
}
static gboolean
menu_can_reuse_widget (GtkWidget *child, const char *label)
{
/* Everything up at the top level was done using
** gtk_xemacs_accel_label_new(), but we still double check to make
** sure we don't seriously foobar ourselves.
*/
gpointer possible_child =
g_list_nth_data (gtk_container_children (GTK_CONTAINER (child)), 0);
gboolean ret_val = FALSE;
if (possible_child && GTK_IS_LABEL (possible_child))
{
char *temp_label = remove_underscores (label);
if (!strcmp (GTK_LABEL (possible_child)->label, temp_label))
ret_val = TRUE;
free (temp_label);
}
return ret_val;
}
/* Converts a menubar description into a GtkMenuBar... a menubar is a
list of menus or buttons
*/
static void
menu_create_menubar (struct frame *f, Lisp_Object descr)
{
gboolean right_justify = FALSE;
Lisp_Object tail = Qnil;
Lisp_Object value = descr;
Lisp_Object item_descr = Qnil;
GtkWidget *menubar = FRAME_GTK_MENUBAR_WIDGET (f);
GUI_ID id = (GUI_ID) gtk_object_get_data (GTK_OBJECT (menubar), XEMACS_MENU_GUIID_TAG);
guint menu_position = 0;
GtkAccelGroup *menubar_accel_group;
/* Remove any existing protection for old menu items */
ungcpro_popup_callbacks (id);
/* GCPRO the whole damn thing */
gcpro_popup_callbacks (id, descr);
menubar_accel_group = gtk_accel_group_new();
EXTERNAL_LIST_LOOP (tail, value)
{
gpointer current_child = g_list_nth_data (GTK_MENU_SHELL (menubar)->children, menu_position);
item_descr = XCAR (tail);
if (NILP (item_descr))
{
/* Need to start right-justifying menus */
right_justify = TRUE;
menu_position--;
}
else if (VECTORP (item_descr))
{
/* It is a button description */
GtkWidget *item;
item = menu_descriptor_to_widget (item_descr, menubar_accel_group);
gtk_widget_set_name (item, "XEmacsMenuButton");
if (!item)
{
item = gtk_menu_item_new_with_label ("ITEM CREATION ERROR");
}
gtk_widget_show_all (item);
if (current_child) gtk_widget_destroy (GTK_WIDGET (current_child));
gtk_menu_bar_insert (GTK_MENU_BAR (menubar), item, menu_position);
}
else if (LISTP (item_descr))
{
/* Need to actually convert it into a menu and slap it in */
GtkWidget *widget;
gboolean reused_p = FALSE;
/* We may be able to reuse the widget, let's at least check. */
if (current_child && menu_can_reuse_widget (GTK_WIDGET (current_child),
XSTRING_DATA (XCAR (item_descr))))
{
widget = menu_convert (item_descr, GTK_WIDGET (current_child),
menubar_accel_group);
reused_p = TRUE;
}
else
{
widget = menu_convert (item_descr, NULL, menubar_accel_group);
if (current_child) gtk_widget_destroy (GTK_WIDGET (current_child));
gtk_menu_bar_insert (GTK_MENU_BAR (menubar), widget, menu_position);
}
if (widget)
{
if (right_justify) gtk_menu_item_right_justify (GTK_MENU_ITEM (widget));
}
else
{
widget = gtk_menu_item_new_with_label ("ERROR");
/* abort() */
}
gtk_widget_show_all (widget);
}
else if (STRINGP (item_descr))
{
/* Do I really want to be this careful? Anything else in a
menubar description is illegal */
}
menu_position++;
}
/* Need to delete any menu items that were past the bounds of the new one */
{
GList *l = NULL;
while ((l = g_list_nth (GTK_MENU_SHELL (menubar)->children, menu_position)))
{
gpointer data = l->data;
g_list_remove_link (GTK_MENU_SHELL (menubar)->children, l);
if (data)
{
gtk_widget_destroy (GTK_WIDGET (data));
}
}
}
/* Attach the new accelerator group to the frame. */
gtk_window_add_accel_group (GTK_WINDOW (FRAME_GTK_SHELL_WIDGET(f)),
menubar_accel_group);
}
/* Deal with getting/setting the menubar */
#ifndef GNOME_IS_APP
#define GNOME_IS_APP(x) 0
#define gnome_app_set_menus(x,y)
#endif
static gboolean
run_menubar_hook (GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
if (!GTK_MENU_SHELL(widget)->active)
{
run_hook (Qactivate_menubar_hook);
}
return(FALSE);
}
static void
create_menubar_widget (struct frame *f)
{
GUI_ID id = new_gui_id ();
GtkWidget *handlebox = NULL;
GtkWidget *menubar = gtk_xemacs_menubar_new (f);
if (GNOME_IS_APP (FRAME_GTK_SHELL_WIDGET (f)))
{
gnome_app_set_menus (GNOME_APP (FRAME_GTK_SHELL_WIDGET (f)), GTK_MENU_BAR (menubar));
}
else if (dockable_menubar)
{
handlebox = gtk_handle_box_new ();
gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (handlebox), GTK_POS_LEFT);
gtk_container_add (GTK_CONTAINER (handlebox), menubar);
gtk_box_pack_start (GTK_BOX (FRAME_GTK_CONTAINER_WIDGET (f)), handlebox, FALSE, FALSE, 0);
}
else
{
gtk_box_pack_start (GTK_BOX (FRAME_GTK_CONTAINER_WIDGET (f)), menubar, FALSE, FALSE, 0);
}
gtk_signal_connect (GTK_OBJECT (menubar), "button-press-event",
GTK_SIGNAL_FUNC (run_menubar_hook), NULL);
FRAME_GTK_MENUBAR_WIDGET (f) = menubar;
gtk_object_set_data (GTK_OBJECT (menubar), XEMACS_MENU_GUIID_TAG, (gpointer) id);
gtk_object_weakref (GTK_OBJECT (menubar), __remove_gcpro_by_id, (gpointer) id);
}
static int
set_frame_menubar (struct frame *f, int first_time_p)
{
Lisp_Object menubar;
int menubar_visible;
/* As for the toolbar, the minibuffer does not have its own menubar. */
struct window *w = XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f));
if (! FRAME_GTK_P (f))
return 0;
/***** first compute the contents of the menubar *****/
if (! first_time_p)
{
/* evaluate `current-menubar' in the buffer of the selected window
of the frame in question. */
menubar = symbol_value_in_buffer (Qcurrent_menubar, w->buffer);
}
else
{
/* That's a little tricky the first time since the frame isn't
fully initialized yet. */
menubar = Fsymbol_value (Qcurrent_menubar);
}
if (NILP (menubar))
{
menubar = Vblank_menubar;
menubar_visible = 0;
}
else
{
menubar_visible = !NILP (w->menubar_visible_p);
}
if (!FRAME_GTK_MENUBAR_WIDGET (f))
{
create_menubar_widget (f);
}
/* Populate the menubar, but nothing is shown yet */
{
Lisp_Object old_buffer;
int count = specpdl_depth ();
old_buffer = Fcurrent_buffer ();
record_unwind_protect (Fset_buffer, old_buffer);
Fset_buffer (XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer);
menu_create_menubar (f, menubar);
Fset_buffer (old_buffer);
unbind_to (count, Qnil);
}
FRAME_MENUBAR_DATA (f) = Fcons (XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->buffer, Qt);
return (menubar_visible);
}
/* Called from gtk_create_widgets() to create the inital menubar of a frame
before it is mapped, so that the window is mapped with the menubar already
there instead of us tacking it on later and thrashing the window after it
is visible. */
int
gtk_initialize_frame_menubar (struct frame *f)
{
create_menubar_widget (f);
return set_frame_menubar (f, 1);
}
static void
gtk_update_frame_menubar_internal (struct frame *f)
{
/* We assume the menubar contents has changed if the global flag is set,
or if the current buffer has changed, or if the menubar has never
been updated before.
*/
int menubar_contents_changed =
(f->menubar_changed
|| NILP (FRAME_MENUBAR_DATA (f))
|| (!EQ (XFRAME_MENUBAR_DATA_LASTBUFF (f),
XWINDOW (FRAME_LAST_NONMINIBUF_WINDOW (f))->buffer)));
gboolean menubar_was_visible = GTK_WIDGET_VISIBLE (FRAME_GTK_MENUBAR_WIDGET (f));
gboolean menubar_will_be_visible = menubar_was_visible;
gboolean menubar_visibility_changed;
if (menubar_contents_changed)
{
menubar_will_be_visible = set_frame_menubar (f, 0);
}
menubar_visibility_changed = menubar_was_visible != menubar_will_be_visible;
if (!menubar_visibility_changed)
{
return;
}
/* We hide and show the menubar's parent (which is actually the
GtkHandleBox)... this is to simplify the code that destroys old
menu items, etc. There is no easy way to get the child out of a
handle box, and I didn't want to add yet another stupid widget
slot to struct gtk_frame. */
if (menubar_will_be_visible)
{
gtk_widget_show_all (FRAME_GTK_MENUBAR_WIDGET (f)->parent);
}
else
{
gtk_widget_hide_all (FRAME_GTK_MENUBAR_WIDGET (f)->parent);
}
MARK_FRAME_SIZE_SLIPPED (f);
}
static void
gtk_update_frame_menubars (struct frame *f)
{
GtkWidget *menubar = NULL;
assert (FRAME_GTK_P (f));
menubar = FRAME_GTK_MENUBAR_WIDGET (f);
if ((GTK_MENU_SHELL (menubar)->active) ||
(GTK_MENU_SHELL (menubar)->have_grab) ||
(GTK_MENU_SHELL (menubar)->have_xgrab))
{
return;
}
gtk_update_frame_menubar_internal (f);
}
static void
gtk_free_frame_menubars (struct frame *f)
{
GtkWidget *menubar_widget;
assert (FRAME_GTK_P (f));
menubar_widget = FRAME_GTK_MENUBAR_WIDGET (f);
if (menubar_widget)
{
gtk_widget_destroy (menubar_widget);
}
}
static void popdown_menu_cb (GtkMenuShell *menu, gpointer user_data)
{
popup_up_p--;
}
static void
gtk_popup_menu (Lisp_Object menu_desc, Lisp_Object event)
{
struct Lisp_Event *eev = NULL;
GtkWidget *widget = NULL;
GtkWidget *menu = NULL;
gpointer id = NULL;
/* Do basic error checking first... */
if (SYMBOLP (menu_desc))
menu_desc = Fsymbol_value (menu_desc);
CHECK_CONS (menu_desc);
CHECK_STRING (XCAR (menu_desc));
/* Now lets get down to business... */
widget = menu_descriptor_to_widget (menu_desc, NULL);
menu = GTK_MENU_ITEM (widget)->submenu;
gtk_widget_set_name (widget, "XEmacsPopupMenu");
id = gtk_object_get_data (GTK_OBJECT (widget), XEMACS_MENU_GUIID_TAG);
__activate_menu (GTK_MENU_ITEM (widget), id);
if (!NILP (event))
{
CHECK_LIVE_EVENT (event);
eev = XEVENT (event);
if ((eev->event_type != button_press_event) &&
(eev->event_type != button_release_event))
wrong_type_argument (Qmouse_event_p, event);
}
else if (!NILP (Vthis_command_keys))
{
/* If an event wasn't passed, use the last event of the event
sequence currently being executed, if that event is a mouse
event. */
eev = XEVENT (Vthis_command_keys);
if ((eev->event_type != button_press_event) &&
(eev->event_type != button_release_event))
eev = NULL;
}
gtk_widget_show (menu);
popup_up_p++;
gtk_signal_connect (GTK_OBJECT (menu), "deactivate",
GTK_SIGNAL_FUNC (popdown_menu_cb), NULL);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
eev ? eev->event.button.button : 0,
eev ? eev->timestamp : GDK_CURRENT_TIME);
}
DEFUN ("gtk-build-xemacs-menu", Fgtk_build_xemacs_menu, 1, 1, 0, /*
Returns a GTK menu item from MENU, a standard XEmacs menu description.
See the definition of `popup-menu' for more information on the format of MENU.
*/
(menu))
{
GtkWidget *w = menu_descriptor_to_widget (menu, NULL);
return (w ? build_gtk_object (GTK_OBJECT (w)) : Qnil);
}
void
syms_of_menubar_gtk (void)
{
DEFSUBR (Fgtk_build_xemacs_menu);
}
void
console_type_create_menubar_gtk (void)
{
CONSOLE_HAS_METHOD (gtk, update_frame_menubars);
CONSOLE_HAS_METHOD (gtk, free_frame_menubars);
CONSOLE_HAS_METHOD (gtk, popup_menu);
}
void reinit_vars_of_menubar_gtk (void)
{
dockable_menubar = 1;
#ifdef TEAR_OFF_MENUS
tear_off_menus = 1;
#endif
}
void
vars_of_menubar_gtk (void)
{
Fprovide (intern ("gtk-menubars"));
DEFVAR_BOOL ("menubar-dockable-p", &dockable_menubar /*
If non-nil, the frame menubar can be detached into its own top-level window.
*/ );
#ifdef TEAR_OFF_MENUS
DEFVAR_BOOL ("menubar-tearable-p", &tear_off_menus /*
If non-nil, menus can be torn off into their own top-level windows.
*/ );
#endif
reinit_vars_of_menubar_gtk ();
}
- 3 participants
- 5 comments
Package paths and relocatable binary kits
19 years
Vin Shelton
Vin Shelton
Hi, Michael,
Sorry to bring this up again, I know this topic has been hashed out
multiple times, but I'm in a small fix and I could use some help. I
hope I've just missed something with respect to package configuration.
As you may know, I've recently created a Windows-native setup kit for
21.4. This setup kit can run on the user's machine and the resulting
software can be installed in a directory of the user's choosing. The
kit includes both core 21.4 (binaries and lisp) and also a default set
of packages. If I understand correctly, in order for those packages
to be found at run-time, the builder of the 21.4 kit must either: 1)
know an absolute path where the packages will be installed or 2) the
packages must be installed under the root of the XEmacs 21.4 tree.
To be more concrete, if I use the following settings in the nt/config.inc file:
INSTALL_DIR=c:\Program Files\XEmacs\XEmacs-$(XEMACS_VERSION_STRING)
PACKAGE_PREFIX=C:\Program Files\XEmacs
and build and install XEmacs 21.4, then I can run from
c:\Program Files\XEmacs\XEmacs-21.4.18\i586-pc-win32\xemacs.exe
and Bob's my uncle and all works great. But if once I make a setup
kit from that build, I (or any other user) can install to a different
hierarchy, say "c:\Program Files\XEmacs1" and the packages will not be
found when running the XEmacs binary.
As far as I understand, assuming I want the users to be able to
install to arbitrary locations, I can fix this in either of 2 ways:
1) I can install the packages underneath the 21.4.18 hierarchy or
2) I can set EMACSPACKAGEPATH (either through the registry or an
environment variable) to point to the package hierarchy.
Both of those solutions are slightly problematic from my point of
view: #1 is kind of aesthetically yucky (the packages and the core are
distinct and I don't want to install my packages underneath my core)
and besides, I'd like to be able to install multiple cores (21.4.18,
21.4.19 and 21.5.b23, for instance) in parallel directories and not
force each one to have its own package tree. #2 currently does not
seem to work identically for 21.4 and 21.5 - "xemacs-packages" gets
appended to EMACSPACKAGEPATH for 21.4 but not for 21.5. Other than
that, I suppose solution #2 works, but it would be nice not to have to
have to set the envariable; it's one more thing that can go wrong in
the user's installation.
Michael - do you have any suggestions or insights? At configuration
time, Is it possible to specify a package path _relative_ to the
installation directory? (I just tried specifying
--with-package-prefix=.. (on my Linux box) to a 21.5 configure, and
when running XEmacs, that got interpreted as relative to the current
directory at run time.) Alternatively, is there a small amount of
lisp I could generate at install time and add it to site-start.el? My
thinking is that this code could propose an alternate package root at
startup time. Or does site-start.el run too late in the init process?
Thank you for your help,
Vin
- 2 participants
- 5 comments
Inscription à la liste : master
19 years
Le Courrielleur
Le Courrielleur
Inscription à la liste: master
L'adresse de courriel xemacs-beta(a)xemacs.org a été ajoutée.
Cliquez sur le lien suivant pour vous désinscrire :
http://go.courrielleur.com/opt-out.php?lid=3423&uid=16260&uemail=xemacs-b...
Cette liste est gérée par Le Courrielleur
http://www.courrielleur.com
- 1 participants
- 0 comments
Re: [C] xemacsweb: Add more generated download files, InnoSetup info, Makefile update, minor fixes
19 years
Adrian Aichner
Adrian Aichner
Vin Shelton <acs(a)xemacs.org> writes:
> On 12/18/05, Adrian Aichner <adrian(a)xemacs.org> wrote:
>> COMMIT
>>
>> This is all open for suggestions.
>>
>> Please report any problems.
>> xemacsweb ChangeLog patch:
>> Diff command: cvs -q diff -U 0
>> Files affected: Releases/ChangeLog Install/ChangeLog Download/win32/ChangeLog ChangeLog
>
> Adrian,
>
> Thanks for taking this on! That looks really good! Thanks again.
>
> I wonder if we should point users to cygwin now that there's an
> official cygwin XEmacs package. At the bottom of the page we indicate
> that cygwin is a good thing, but I don't think we tell people that
> they can install XEmacs through the cygwin setup kit. It's a lot
I agree, I just haven't come up with a good idea how to plug the
upstream cygwin XEmacs package.
Patches welcome, as always, while I still have to think about a
solution.
Perhaps we should ping Volker about this?
Ping!
Adrian
> better than using the netinstaller, because the version is now 21.4.18
> instead of 21.4.13. Just a thought.
>
> Regards,
> Vin
>
>
--
Adrian Aichner
mailto:adrian＠xemacs.org
http://www.xemacs.org/
- 3 participants
- 3 comments
Inscription à la liste : master
19 years
Le Courrielleur
Le Courrielleur
Inscription à la liste: master
L'adresse de courriel xemacs-beta(a)xemacs.org a été ajoutée.
Cliquez sur le lien suivant pour vous désinscrire :
http://go.courrielleur.com/opt-out.php?lid=3423&uid=16260&uemail=xemacs-b...
Cette liste est gérée par Le Courrielleur
http://www.courrielleur.com
- 1 participants
- 0 comments
[AC21.4] Fix --without-tty builds on BSD/MacOS X.
19 years
Vin Shelton
Vin Shelton
Malcolm Purvis <malcolmp(a)xemacs.org> writes:
> 21.4
>
> This is the 21.4 version of my --without-tty build fix. Looking through CVS
> it seems that this problem has been around for a long while.
>
> Malcolm
>
>
> src/ChangeLog addition:
>
> 2005-12-18 Malcolm Purvis <malcolmp(a)xemacs.org>
>
> * console.c (stuff_buffered_input): Compile body only if
> HAVE_TTY.
>
>
> xemacs-21.4-micro-patches source patch:
> Diff command: cvs -q diff -u
> Files affected: src/console.c
>
> Index: src/console.c
> ===================================================================
> RCS file: /pack/xemacscvs/XEmacs/xemacs/src/console.c,v
> retrieving revision 1.19.2.2
> diff -u -r1.19.2.2 console.c
> --- src/console.c 2005/01/31 02:55:06 1.19.2.2
> +++ src/console.c 2005/12/18 12:41:26
> ＠＠ -882,7 +882,7 ＠＠
> stuff_buffered_input (Lisp_Object stuffstring)
> {
> /* stuff_char works only in BSD, versions 4.2 and up. */
> -#if defined (BSD)
> +#if defined (BSD) && defined(HAVE_TTY)
> if (!CONSOLEP (Vcontrolling_terminal) ||
> !CONSOLE_LIVE_P (XCONSOLE (Vcontrolling_terminal)))
> return;
> ＠＠ -908,7 +908,7 ＠＠
> stuff_char (XCONSOLE (Vcontrolling_terminal), *kbd_fetch_ptr++);
> }
> # endif
> -#endif /* BSD */
> +#endif /* BSD && HAVE_TTY */
> }
>
> DEFUN ("suspend-console", Fsuspend_console, 0, 1, "", /*
>
APPROVE COMMIT 21.4
Thanks for the patch, Malcolm. It will appear in 21.4.19.
- Vin
- 1 participants
- 0 comments
Crash on Unicode font name (fixed in CVS)
19 years
Stephen J. Turnbull
Stephen J. Turnbull
In XEmacs 21.5.24, if your fontconfig configuration picks up fonts
whose names are not ASCII, you will get a crash. Already fixed in
CVS. I recommend updating if you use Xft (many Linux distros provide
a wide range of fonts, such as UnDotum for Korean, which is the one
that crashed me).
The fix is still suboptimal, maybe, as if some broken font specifies a
name that is _not_ compatible with the specified encoding (Latin 1 for
XLFDs and UTF-8 for fontconfig/Xft), you'll get an error---there's no
way to use such a font.
Patch is on XEmacs Patches.
--
School of Systems and Information Engineering http://turnbull.sk.tsukuba.ac.jp
University of Tsukuba Tennodai 1-1-1 Tsukuba 305-8573 JAPAN
Ask not how you can "do" free software business;
ask what your business can "do for" free software.
- 1 participants
- 0 comments
[BUG: gnus 1.87] not work menu Attachments -> Attach file.
19 years
Andrey Slusar
Andrey Slusar
Hi. XEmacs developers!
I am upgraded sumo package to new release. This is contains package
gnus 1.87.
I'm posted message by gnus and add attach by C-c C-m f - it's
worked fine. When i am add attach by click Attachments->Attach
File... - it's not work. This is tested and reproduced on the XEmacs
21.4.18 and 21.5-b23.
When i'm use the xemacs -vanilla option, this bug is reproduced too.
--
Regards,
Andrey.
- 2 participants
- 2 comments
Chevron Email Firewall Alert
19 years
no-reply＠chevron.com
no-reply＠chevron.com
Your message with subject delivery failed sent on 12/22/05, 18:44:31
contained one or more attachments not allowed by Chevron and was
blocked. If you did not send such an email, your email address may have
been spoofed. In this case, no further action is required on your part
and you may disregard this message. For more details on spoofing, please
visit http://messaging.chevrontexaco.com/html/spam/spooffaq.asp.
- 1 participants
- 0 comments
[Enrico Scholz] Avoid usage of corrupted stack in open-network-stream()
19 years
Vin Shelton
Vin Shelton
Ari and Kristian
I wonder if the attached patch could have caused the nntp hang problem
you have observed? You could apply it to the 21.4.18 sources with 'patch -R'
(it's reversed) and see if the problem goes away.
HTH,
Vin
- 1 participants
- 0 comments