* GTK patches part 2
@ 2002-12-08 22:33 Jan D.
2002-12-09 21:25 ` Eric Gillespie
0 siblings, 1 reply; 12+ messages in thread
From: Jan D. @ 2002-12-08 22:33 UTC (permalink / raw
[-- Attachment #1: Type: text/plain, Size: 106 bytes --]
Hello.
These are the new files in the GTK port. Most of the GTK specific code is
here.
Jan D.
[-- Attachment #2: gtkutil.h --]
[-- Type: text/plain, Size: 6201 bytes --]
/* Definitions and headers for GTK widgets.
Copyright (C) 2002
Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs 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.
GNU Emacs 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 GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef GTKUTIL_H
#define GTKUTIL_H
#ifdef USE_GTK
#include <gtk/gtk.h>
#include "frame.h"
/* Minimum and maximum values used for GTK scroll bars */
#define GTK_SB_MIN 0
#define GTK_SB_MAX 10000000
#define GTK_SB_RANGE (GTK_SB_MAX - GTK_SB_MIN)
/* Key for data that is the frame pointer */
#define G_FRAME_DATA "emacs_frame"
/* Key for data that is the last scrollbar value */
#define G_LAST_SB_DATA "emacs_last_sb_value"
/* Button types in menus. */
enum button_type
{
BUTTON_TYPE_NONE,
BUTTON_TYPE_TOGGLE,
BUTTON_TYPE_RADIO
};
/* This structure is the callback data for menus. We need to keep it
separate from the frame structure due to detachable menus.
The data in the frame structure is only valid while the menu is
popped up. */
struct menu_gtk_data
{
FRAME_PTR f;
Lisp_Object menu_bar_vector;
int menu_bar_items_used;
int ref_count;
struct menu_gtk_data *next;
struct menu_gtk_data *prev;
};
/* Used to specify menus and dialogs.
This is an adaption from lwlib for Gtk so we can use more of the same
code as lwlib in xmenu.c. */
typedef struct _widget_value
{
/* name of widget */
char* name;
/* value (meaning depend on widget type) */
char* value;
/* keyboard equivalent. no implications for XtTranslations */
char* key;
/* Help string or nil if none.
GC finds this string through the frame's menu_bar_vector
or through menu_items. */
Lisp_Object help;
/* true if enabled */
gint enabled;
/* true if selected */
gint selected;
/* The type of a button. */
enum button_type button_type;
/* Contents of the sub-widgets, also selected slot for checkbox */
struct _widget_value* contents;
/* data passed to callback */
gpointer call_data;
/* next one in the list */
struct _widget_value* next;
/* we resource the widget_value structures; this points to the next
one on the free list if this one has been deallocated.
*/
struct _widget_value *free_list;
} widget_value;
extern widget_value *malloc_widget_value ();
extern void free_widget_value __P ((widget_value *));
extern GtkWidget *xg_create_widget __P ((char* type,
char* name,
FRAME_PTR f,
widget_value* val,
int pop_up_p,
GCallback activate_cb,
GCallback select_cb,
GCallback deactivate_cb,
GCallback help_cb));
extern void xg_modify_menubar_widgets __P ((GtkWidget *menubar,
FRAME_PTR f,
widget_value* val,
int deep_p,
GCallback activate_cb,
GCallback select_cb,
GCallback deactivate_cb,
GCallback help_cb));
extern int xg_update_frame_menubar __P ((FRAME_PTR f));
extern void xg_free_frame_menubar __P ((FRAME_PTR f));
extern void xg_resize_widgets __P ((FRAME_PTR f,
int pixelwidth,
int pixelheight));
extern void xg_frame_set_char_size __P ((FRAME_PTR f, int cols, int rows));
extern GtkWidget* xg_win_to_widget __P ((Window));
extern int xg_create_frame_widgets __P ((FRAME_PTR f));
extern void xg_set_wm_size_hints __P ((FRAME_PTR f,
long flags,
int user_position));
extern void xg_create_scroll_bar __P ((FRAME_PTR f,
struct scroll_bar *bar,
GCallback scroll_callback,
char *scroll_bar_name));
extern void xg_show_scroll_bar __P ((int scrollbar_id));
extern void xg_remove_scroll_bar __P ((FRAME_PTR f, int scrollbar_id));
extern void xg_update_scrollbar_pos __P ((FRAME_PTR f,
int scrollbar_id,
int top,
int left,
int width,
int height));
extern void xg_set_toolkit_scroll_bar_thumb __P ((struct scroll_bar *bar,
int portion,
int position,
int whole));
/* Set this to non-zero to skip Emacs event processing.
For dialogs and popups. */
extern int xg_pass_through_events;
/* Setting scrollbar values invokes the callback. Use this variable
to indicate that the callback should do nothing. */
extern int xg_ignore_gtk_scrollbar;
/* After we send a scroll bar event, x_set_toolkit_scroll_bar_thumb will
be called. For some reason that needs to be debugged, it gets called
with bad values. Thus, we set this variable to ignore those calls. */
extern int xg_ignore_next_thumb;
/* Mark all callback data that are Lisp_object:s during GC. */
extern void xg_mark_data ();
#endif /* USE_GTK */
#endif /* GTKUTIL_H */
[-- Attachment #3: gtkutil.c --]
[-- Type: text/plain, Size: 35720 bytes --]
/* Functions for creating and updating GTK widgets.
Copyright (C) 2002
Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs 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.
GNU Emacs 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 GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "config.h"
#ifdef USE_GTK
#include "lisp.h"
#include "xterm.h"
#include "blockinput.h"
#include "gtkutil.h"
#include <string.h>
\f
/***********************************************************************
Menus and dialog functions.
***********************************************************************/
/* Linked list of all allocated struct menu_gtk_data. Used for marking
during GC. */
static struct menu_gtk_data *menu_gtk_data_list = 0;
/* The next two variables and functions are taken from lwlib. */
static widget_value *widget_value_free_list = 0;
static int malloc_cpt = 0;
widget_value *
malloc_widget_value ()
{
widget_value *wv;
if (widget_value_free_list)
{
wv = widget_value_free_list;
widget_value_free_list = wv->free_list;
wv->free_list = 0;
}
else
{
wv = (widget_value *) malloc (sizeof (widget_value));
malloc_cpt++;
}
memset (wv, 0, sizeof (widget_value));
return wv;
}
/* this is analogous to free(). It frees only what was allocated
by malloc_widget_value(), and no substructures.
*/
void
free_widget_value (wv)
widget_value *wv;
{
if (wv->free_list)
abort ();
if (malloc_cpt > 25)
{
/* When the number of already allocated cells is too big,
We free it. */
free (wv);
malloc_cpt--;
}
else
{
wv->free_list = widget_value_free_list;
widget_value_free_list = wv;
}
}
/* Allocate and return a utf8 version of STR. If STR is already
utf8 or NULL, just return STR.
If not, a new string is allocated and the caller must free the result
with g_free(). */
static char*
get_utf8_string (str)
char *str;
{
char *utf8_str = str;
/* If not UTF-8, try current locale. */
if (str && !g_utf8_validate (str, -1, NULL))
utf8_str = g_locale_to_utf8 (str, -1, 0, 0, 0);
return utf8_str;
}
/* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count */
struct menu_gtk_data*
make_cl_data (cl_data, f)
struct menu_gtk_data *cl_data;
FRAME_PTR f;
{
if (! cl_data)
{
cl_data = (struct menu_gtk_data*) xmalloc (sizeof (*cl_data));
cl_data->f = f;
cl_data->menu_bar_vector = f->menu_bar_vector;
cl_data->menu_bar_items_used = f->menu_bar_items_used;
cl_data->ref_count = 0;
cl_data->next = menu_gtk_data_list;
if (menu_gtk_data_list)
menu_gtk_data_list->prev = cl_data;
cl_data->prev = 0;
menu_gtk_data_list = cl_data;
}
cl_data->ref_count++;
return cl_data;
}
/* Function that marks all lisp data during GC. */
void
xg_mark_data ()
{
struct menu_gtk_data *iter = menu_gtk_data_list;
while (iter)
{
mark_object (&iter->menu_bar_vector);
iter = iter->next;
}
}
/* Callback called when a menu item is destroyed. Used to free data. */
static void
menuitem_destroy_callback (w, client_data)
GtkWidget *w;
gpointer client_data;
{
struct menu_gtk_data *data = (struct menu_gtk_data*) client_data;
if (data && data->ref_count > 0)
{
data->ref_count--;
if (data->ref_count == 0)
{
if (data == menu_gtk_data_list)
{
menu_gtk_data_list = data->next;
if (menu_gtk_data_list)
menu_gtk_data_list->prev = 0;
}
else
{
data->prev->next = data->next;
if (data->next)
data->next->prev = data->prev;
}
xfree (data);
}
}
}
/* Make and return a menu item with the key to the right.
Unfortunately, keys don't line up as nicely as in Motif,
but the MacOS X version doesn't either, so I guess that is OK. */
static GtkWidget*
make_menu_item (utf8_label, utf8_key, item, group)
char *utf8_label;
char *utf8_key;
widget_value* item;
GSList **group;
{
GtkWidget *w;
GtkWidget *wtoadd = 0;
if (utf8_key)
{
GtkWidget *wlbl;
GtkWidget *wkey;
wtoadd = gtk_hbox_new (FALSE, 0);
wlbl = gtk_label_new_with_mnemonic (utf8_label);
wkey = gtk_label_new (utf8_key);
gtk_misc_set_alignment (GTK_MISC (wlbl), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (wkey), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (wtoadd), wlbl, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (wtoadd), wkey, FALSE, FALSE, 0);
gtk_widget_show (wlbl);
gtk_widget_show (wkey);
gtk_widget_show (wtoadd);
}
if (item->button_type == BUTTON_TYPE_TOGGLE)
{
*group = NULL;
if (utf8_key) w = gtk_check_menu_item_new ();
else w = gtk_check_menu_item_new_with_mnemonic (utf8_label);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), item->selected);
}
else if (item->button_type == BUTTON_TYPE_RADIO)
{
if (utf8_key) w = gtk_radio_menu_item_new (*group);
else w = gtk_radio_menu_item_new_with_mnemonic (*group, utf8_label);
*group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w));
if (item->selected)
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);
}
else
{
*group = NULL;
if (utf8_key) w = gtk_menu_item_new ();
else w = gtk_menu_item_new_with_mnemonic (utf8_label);
}
if (wtoadd) gtk_container_add (GTK_CONTAINER (w), wtoadd);
if (! item->enabled) gtk_widget_set_sensitive (w, FALSE);
return w;
}
/* Return non-zero if NAME specifies a separator (GTK only has one
separator type) */
static int
xg_separator_p (char *name)
{
return strcmp (name, "--") == 0
|| strcmp (name, "--:") == 0
|| strcmp (name, "---") == 0;
}
/* Create a full menu tree specified by DATA. */
static GtkWidget*
createMenus (data, f, activate_cb, select_cb, deactivate_cb, help_cb,
isPopup, isMenubar, topmenu, cl_data)
widget_value* data;
FRAME_PTR f;
GCallback activate_cb;
GCallback select_cb;
GCallback deactivate_cb;
int isMenubar;
GtkWidget *topmenu;
struct menu_gtk_data *cl_data;
{
widget_value* item;
GtkWidget* wmenu = topmenu;
GSList* group = NULL;
if (! topmenu)
{
if (! isMenubar) wmenu = gtk_menu_new ();
else wmenu = gtk_menu_bar_new ();
if (deactivate_cb)
g_signal_connect(wmenu, "deactivate", deactivate_cb, 0);
}
if (! isMenubar)
{
GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), tearoff);
gtk_widget_show (tearoff);
}
for (item = data; item; item = item->next)
{
GtkWidget *w;
if (isPopup && !item->contents && !item->call_data
&& !xg_separator_p (item->name))
{
char *utf8_label;
/* A title for a popup. We do the same as GTK does when
creating titles, but it is very ugly looking. */
group = NULL;
utf8_label = get_utf8_string (item->name);
gtk_menu_set_title(GTK_MENU(wmenu), utf8_label);
w = gtk_menu_item_new_with_mnemonic (utf8_label);
gtk_widget_set_sensitive (w, FALSE);
if (utf8_label && utf8_label != item->name) g_free (utf8_label);
}
else if (xg_separator_p (item->name))
{
group = NULL;
/* GTK only have one separator type. */
w = gtk_separator_menu_item_new ();
}
else
{
char *utf8_label;
char *utf8_key;
utf8_label = get_utf8_string (item->name);
utf8_key = get_utf8_string (item->key);
w = make_menu_item (utf8_label, utf8_key, item, &group);
if (utf8_label && utf8_label != item->name) g_free (utf8_label);
if (utf8_key && utf8_key != item->key) g_free (utf8_key);
/* Assume "Help" is the last menu in the menubar. */
if (isMenubar && ! item->next)
gtk_menu_item_right_justify (GTK_MENU_ITEM (w));
/* final item, not a submenu */
if (item->call_data && ! item->contents)
{
if (select_cb)
{
cl_data = make_cl_data (cl_data, f);
g_signal_connect(w, "activate", select_cb, item->call_data);
g_signal_connect(w, "destroy",
menuitem_destroy_callback, cl_data);
/* Put cl_data in widget, so select_cb can get it */
g_object_set_data (G_OBJECT (w),
G_FRAME_DATA,
(gpointer)cl_data);
}
/* help_cb NYI */
}
if (item->contents)
{
GtkWidget *submenu = createMenus (item->contents,
f,
activate_cb,
select_cb,
deactivate_cb,
help_cb,
0,
0,
0,
cl_data);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), submenu);
if (activate_cb) g_signal_connect(w, "activate", activate_cb, 0);
gtk_widget_show (submenu);
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), w);
gtk_widget_show (w);
}
return wmenu;
}
static char*
get_dialog_title (char key)
{
char *title = "";
switch (key) {
case 'E': case 'e':
title = "Error";
break;
case 'I': case 'i':
title = "Information";
break;
case 'L': case 'l':
title = "Prompt";
break;
case 'P': case 'p':
title = "Prompt";
break;
case 'Q': case 'q':
title = "Question";
break;
}
return title;
}
static GtkWidget*
createDialog (wv, select_cb, deactivate_cb)
widget_value* wv;
GCallback select_cb;
GCallback deactivate_cb;
{
char *title = get_dialog_title (wv->name[0]);
int total_buttons = wv->name[1] - '0';
int right_buttons = wv->name[4] - '0';
int left_buttons;
int button_nr = 0;
int button_spacing = 10;
GtkWidget *wdialog = gtk_dialog_new ();
widget_value* item;
if (right_buttons == 0) right_buttons = total_buttons/2;
left_buttons = total_buttons - right_buttons;
gtk_window_set_title (GTK_WINDOW (wdialog), title);
if (deactivate_cb)
{
g_signal_connect(wdialog, "close", deactivate_cb, 0);
g_signal_connect(wdialog, "response", deactivate_cb, 0);
}
for (item = wv->contents; item; item = item->next)
{
char *utf8_label = get_utf8_string (item->value);
GtkWidget *w;
GtkRequisition req;
if (strcmp (item->name, "message") == 0)
{
w = gtk_label_new (utf8_label);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog)->vbox),
gtk_label_new (""),
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog)->vbox), w,
TRUE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (w), 0.1, 0.5);
gtk_widget_realize (w);
/* Try to make dialog look better. */
gtk_widget_size_request (w, &req);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog)->vbox),
req.height);
if (strlen(item->value) > 0)
button_spacing = 2*req.width/strlen(item->value);
}
else
{
w = gtk_button_new_with_mnemonic (utf8_label);
if (! item->enabled) gtk_widget_set_sensitive (w, FALSE);
if (select_cb)
g_signal_connect(w, "clicked", select_cb, item->call_data);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog)->action_area),
w, TRUE, TRUE,
button_spacing);
if (++button_nr == left_buttons)
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog)->action_area),
gtk_label_new (""),
TRUE, TRUE,
button_spacing);
}
if (utf8_label && utf8_label != item->value) g_free (utf8_label);
gtk_widget_show (w);
}
return wdialog;
}
/* Create a menubar, popup menu or dialog, depending on the TYPE argument. */
GtkWidget*
xg_create_widget (type, name, f, val, pop_up_p,
activate_cb, select_cb, deactivate_cb, help_cb)
char* type;
char* name;
FRAME_PTR f;
widget_value* val;
int pop_up_p;
GCallback activate_cb;
GCallback select_cb;
GCallback deactivate_cb;
GCallback help_cb;
{
GtkWidget *w = 0;
if (strcmp (type, "dialog") == 0)
{
w = createDialog (val, select_cb, deactivate_cb);
gtk_window_set_transient_for (GTK_WINDOW (w),
GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
}
else if (strcmp (type, "menubar") == 0 || strcmp (type, "popup") == 0)
{
w = createMenus (val->contents,
f,
activate_cb,
select_cb,
deactivate_cb,
help_cb,
pop_up_p,
strcmp (type, "menubar") == 0,
0,
0);
}
else
{
fprintf (stderr, "bad type in xg_create_widget: %s, doing nothing\n",
type);
}
return w;
}
/* Remove all children in a GTK container. */
static void
remove_all_children (w)
GtkWidget *w;
{
GList *list = gtk_container_get_children (GTK_CONTAINER (w));
GList *iter;
if (! list) return;
for (iter = g_list_copy (list); iter; iter = g_list_next (iter))
{
GtkWidget *witem = GTK_WIDGET (iter->data);
gtk_container_remove (GTK_CONTAINER (w), witem);
}
g_list_free (iter);
}
/* Update the MENUBAR. If DEEP_P is non-zero, rebuild all but the
top level menu names in the MENUBAR.
If DEEP_P is zero, just rebuild everything. */
void
xg_modify_menubar_widgets (menubar, f, val, deep_p,
activate_cb, select_cb, deactivate_cb, help_cb)
GtkWidget *menubar;
FRAME_PTR f;
widget_value* val;
int deep_p;
GCallback activate_cb;
GCallback select_cb;
GCallback deactivate_cb;
GCallback help_cb;
{
GList *list = gtk_container_get_children (GTK_CONTAINER (menubar));
GList *iter;
if (! list) return;
if (! deep_p)
{
widget_value* cur = val->contents;
int is_changed = 0;
/* Check if the change is actually no change. */
for (iter = g_list_first (list);
iter && cur && ! is_changed;
cur = cur->next, iter = g_list_next (iter))
{
GtkMenuItem *witem = GTK_MENU_ITEM (iter->data);
GtkLabel *wlabel = GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem)));
char *utf8_label = get_utf8_string (cur->name);
is_changed = strcmp (utf8_label, gtk_label_get_label (wlabel));
}
is_changed = ! (cur == 0 && iter == 0);
if (! is_changed)
{
return;
}
/* Keep menubar, but change everything else. This is simple,
but not efficient. Ok for now. */
remove_all_children (menubar);
(void)createMenus (val->contents,
f,
activate_cb,
select_cb,
deactivate_cb,
help_cb,
0,
1,
menubar,
0);
}
else
{
/* Keep the top level submenu names intact, but change everything
else. This is simple, but not efficient.
We must keep the submenu names (GTK menu item widgets) since the
X Window in the XEvent that activates the menu are those widgets. */
widget_value* cur;
for (cur = val->contents; cur; cur = cur->next)
{
for (iter = list ; iter; iter = g_list_next (iter))
{
GtkMenuItem *witem = GTK_MENU_ITEM (iter->data);
GtkWidget *wlbl = gtk_bin_get_child (GTK_BIN (witem));
const char *text = gtk_label_get_text (GTK_LABEL (wlbl));
GtkWidget *sub = gtk_menu_item_get_submenu (witem);
GtkWidget *newsub;
if (strcmp (text, cur->name)) continue;
if (sub) gtk_menu_item_remove_submenu (witem);
newsub = createMenus (cur->contents,
f,
activate_cb,
select_cb,
deactivate_cb,
help_cb,
0,
0,
0,
0);
gtk_menu_item_set_submenu (witem, newsub);
break;
}
}
}
}
/* Recompute all the widgets of frame F, when the menu bar has been
changed. Value is non-zero if widgets were updated. */
int
xg_update_frame_menubar (f)
FRAME_PTR f;
{
struct x_output *x = f->output_data.x;
GtkRequisition req;
if (!x->menubar_widget || GTK_WIDGET_MAPPED (x->menubar_widget))
return 0;
BLOCK_INPUT;
gtk_box_pack_start (GTK_BOX (x->vbox_widget), x->menubar_widget,
FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (x->vbox_widget), x->menubar_widget, 0);
gtk_widget_show (x->menubar_widget);
gtk_widget_size_request (x->menubar_widget, &req);
FRAME_MENUBAR_HEIGHT (f) = req.height;
xg_set_wm_size_hints (f, 0, 0);
gtk_window_resize (GTK_WINDOW (x->widget),
PIXEL_WIDTH (f), req.height + PIXEL_HEIGHT (f));
gdk_window_process_all_updates ();
SET_FRAME_GARBAGED (f);
UNBLOCK_INPUT;
}
/* Get rid of the menu bar of frame F, and free its storage.
This is used when deleting a frame, and when turning off the menu bar. */
void
xg_free_frame_menubar (f)
FRAME_PTR f;
{
struct x_output *x = f->output_data.x;
if (x->menubar_widget)
{
int rows = f->height;
int columns = f->width;
int menubar_height = FRAME_MENUBAR_HEIGHT (f);
BLOCK_INPUT;
gtk_container_remove (GTK_CONTAINER (x->vbox_widget), x->menubar_widget);
/* The menubar and its children shall be deleted when removed from
the container. */
x->menubar_widget = 0;
FRAME_MENUBAR_HEIGHT (f) = 0;
/* base_height is now changed. */
xg_set_wm_size_hints (f, 0, 0);
SET_FRAME_GARBAGED (f);
UNBLOCK_INPUT;
}
}
\f
/***********************************************************************
General functions for creating widgets, resizing, events, e.t.c.
***********************************************************************/
/* Set this to non-zero to skip Emacs event processing. For dialogs
and popups. */
int xg_pass_through_events = FALSE;
/* Function to handle resize of our widgets. Since Emacs has some layouts
that does not fit well with GTK standard containers, we do most layout
manually. */
void
xg_resize_widgets (f, pixelwidth, pixelheight)
FRAME_PTR f;
int pixelwidth, pixelheight;
{
int mbheight = FRAME_MENUBAR_HEIGHT (f);
int rows = PIXEL_TO_CHAR_HEIGHT (f, pixelheight - mbheight);
int columns = PIXEL_TO_CHAR_WIDTH (f, pixelwidth);
if (FRAME_GTK_WIDGET (f)
&& (columns != FRAME_WIDTH (f) || rows != FRAME_HEIGHT (f)
|| pixelwidth != PIXEL_WIDTH (f) || pixelheight != PIXEL_HEIGHT (f)))
{
struct x_output *x = f->output_data.x;
GtkAllocation all;
all.y = mbheight;
all.x = 0;
all.width = pixelwidth;
all.height = pixelheight - mbheight;
gtk_widget_size_allocate (x->edit_widget, &all);
gdk_window_process_all_updates ();
change_frame_size (f, rows, columns, 0, 1, 0);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
}
}
/* Update our widget size to be COLS/ROWS */
void
xg_frame_set_char_size (f, cols, rows)
FRAME_PTR f;
int cols;
int rows;
{
int pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows) + FRAME_MENUBAR_HEIGHT (f);
int pixelwidth = CHAR_TO_PIXEL_WIDTH (f, cols);
xg_resize_widgets (f, pixelwidth, pixelheight);
}
/* Convert an X Window to its corresponding GtkWidget. Must be done like
this, because GtkWidget:s can have "hidden" X Window that aren't
accessible.
Return 0 if no widget match WDESC. */
GtkWidget*
xg_win_to_widget (wdesc)
Window wdesc;
{
BLOCK_INPUT;
gpointer gdkwin = gdk_xid_table_lookup (wdesc);
GtkWidget *gwdesc = 0;
if (gdkwin)
{
GdkEvent event;
event.any.window = gdkwin;
gwdesc = gtk_get_event_widget (&event);
}
UNBLOCK_INPUT;
return gwdesc;
}
static void
xg_pix2Gcolor (c, pixel)
GdkColor *c;
unsigned long pixel;
{
c->red = c->green = c->blue = 0;
c->pixel = pixel; /* I've looked at the Gdk source, this works for X */
}
int
xg_create_frame_widgets (f)
FRAME_PTR f;
{
GtkWidget *wtop;
GtkWidget *wvbox;
GtkWidget *wfixed;
GdkColor bg;
int i;
BLOCK_INPUT;
wtop = gtk_window_new (GTK_WINDOW_TOPLEVEL);
wvbox = gtk_vbox_new (FALSE, 0);
wfixed = gtk_fixed_new (); /* Must have this to place scrollbars */
if (! wtop || ! wvbox || ! wfixed)
{
if (wtop) gtk_widget_destroy (wtop);
if (wvbox) gtk_widget_destroy (wvbox);
if (wfixed) gtk_widget_destroy (wfixed);
return 0;
}
FRAME_GTK_OUTER_WIDGET (f) = wtop;
FRAME_GTK_WIDGET (f) = wfixed;
f->output_data.x->vbox_widget = wvbox;
gtk_fixed_set_has_window (GTK_FIXED (wfixed), TRUE);
gtk_widget_set_size_request (wfixed,
PIXEL_WIDTH (f),
PIXEL_HEIGHT (f));
gtk_container_add (GTK_CONTAINER (wtop), wvbox);
gtk_box_pack_end (GTK_BOX (wvbox), wfixed, TRUE, TRUE, 0);
gtk_widget_set_double_buffered (wvbox, FALSE);
gtk_widget_set_double_buffered (wfixed, FALSE);
gtk_widget_set_double_buffered (wtop, FALSE);
/* GTK documents says use gtk_window_set_resizable. But then a user
can't shrink the window from its starting size. */
gtk_window_set_policy (GTK_WINDOW (wtop), TRUE, TRUE, TRUE);
gtk_window_set_wmclass (GTK_WINDOW (wtop),
SDATA (Vx_resource_name),
SDATA (Vx_resource_class));
/* Convert our geometry parameters into a geometry string
and specify it.
GTK will itself handle calculating the real position this way. */
if (f->output_data.x->size_hint_flags & USPosition)
{
int left = f->output_data.x->left_pos;
int xneg = f->output_data.x->size_hint_flags & XNegative;
int top = f->output_data.x->top_pos;
int yneg = f->output_data.x->size_hint_flags & YNegative;
char geom_str[32];
if (xneg)
left = -left;
if (yneg)
top = -top;
sprintf (geom_str, "=%dx%d%c%d%c%d",
PIXEL_WIDTH (f),
PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f),
(xneg ? '-' : '+'), left,
(yneg ? '-' : '+'), top);
if (!gtk_window_parse_geometry (GTK_WINDOW (wtop), geom_str))
fprintf (stderr, "Failed to parse: '%s'\n", geom_str);
}
gtk_widget_add_events (wfixed,
GDK_POINTER_MOTION_MASK
| GDK_EXPOSURE_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_KEY_PRESS_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_FOCUS_CHANGE_MASK
| GDK_STRUCTURE_MASK
| GDK_VISIBILITY_NOTIFY_MASK);
/* Must realize the windows so the X window gets created. It is used
by callers of this function. */
gtk_widget_realize (wfixed);
FRAME_X_WINDOW (f) = GTK_WIDGET_TO_X_WIN (wfixed);
/* Since GTK clears its window by filling with the background color,
we must keep X and GTK background in sync. */
xg_pix2Gcolor (&bg, (f)->output_data.x->background_pixel);
gdk_window_set_background (wfixed->window, &bg);
/* GTK does not set any border, and they look bad with GTK. */
f->output_data.x->border_width = 0;
f->output_data.x->internal_border_width = 0;
UNBLOCK_INPUT;
return 1;
}
/* Set the normal size hints for the window manager, for frame F.
FLAGS is the flags word to use--or 0 meaning preserve the flags
that the window now has.
If USER_POSITION is nonzero, we set the User Position
flag (this is useful when FLAGS is 0). */
void
xg_set_wm_size_hints (f, flags, user_position)
FRAME_PTR f;
long flags;
int user_position;
{
if (FRAME_GTK_OUTER_WIDGET (f))
{
/* Must use GTK routines here, otherwise GTK resets the size hints
to its own defaults. */
GdkGeometry size_hints;
gint hint_flags = 0;
int base_width, base_height;
int min_rows = 0, min_cols = 0;
int win_gravity = f->output_data.x->win_gravity;
if (flags)
{
memset (&size_hints, 0, sizeof (size_hints));
f->output_data.x->size_hints = size_hints;
f->output_data.x->hint_flags = hint_flags;
}
else
flags = f->output_data.x->size_hint_flags;
size_hints = f->output_data.x->size_hints;
hint_flags = f->output_data.x->hint_flags;
hint_flags |= GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE;
size_hints.width_inc = FONT_WIDTH (f->output_data.x->font);
size_hints.height_inc = f->output_data.x->line_height;
hint_flags |= GDK_HINT_BASE_SIZE;
base_width = CHAR_TO_PIXEL_WIDTH (f, 0);
base_height = CHAR_TO_PIXEL_HEIGHT (f, 0) + FRAME_MENUBAR_HEIGHT (f);
check_frame_size (f, &min_rows, &min_cols);
size_hints.base_width = base_width;
size_hints.base_height = base_height;
size_hints.min_width = base_width + min_cols * size_hints.width_inc;
size_hints.min_height = base_height + min_rows * size_hints.height_inc;
/* These currently have a one to one mapping with the X values, but I
don't think we should rely on that. */
hint_flags |= GDK_HINT_WIN_GRAVITY;
size_hints.win_gravity = 0;
if (win_gravity == NorthWestGravity)
size_hints.win_gravity = GDK_GRAVITY_NORTH_WEST;
if (win_gravity == NorthGravity)
size_hints.win_gravity = GDK_GRAVITY_NORTH;
if (win_gravity == NorthEastGravity)
size_hints.win_gravity = GDK_GRAVITY_NORTH_EAST;
if (win_gravity == WestGravity)
size_hints.win_gravity = GDK_GRAVITY_WEST;
if (win_gravity == CenterGravity)
size_hints.win_gravity = GDK_GRAVITY_CENTER;
if (win_gravity == EastGravity)
size_hints.win_gravity = GDK_GRAVITY_EAST;
if (win_gravity == SouthWestGravity)
size_hints.win_gravity = GDK_GRAVITY_SOUTH_WEST;
if (win_gravity == SouthGravity)
size_hints.win_gravity = GDK_GRAVITY_SOUTH;
if (win_gravity == SouthEastGravity)
size_hints.win_gravity = GDK_GRAVITY_SOUTH_EAST;
if (win_gravity == StaticGravity)
size_hints.win_gravity = GDK_GRAVITY_STATIC;
if (flags & PPosition) hint_flags |= GDK_HINT_POS;
if (flags & USPosition) hint_flags |= GDK_HINT_USER_POS;
if (flags & USSize) hint_flags |= GDK_HINT_USER_SIZE;
if (user_position)
{
hint_flags &= ~GDK_HINT_POS;
hint_flags |= GDK_HINT_USER_POS;
}
BLOCK_INPUT;
gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
FRAME_GTK_OUTER_WIDGET (f),
&size_hints,
hint_flags);
f->output_data.x->size_hints = size_hints;
f->output_data.x->hint_flags = hint_flags;
UNBLOCK_INPUT;
}
}
\f
/***********************************************************************
Scrollbar functions
***********************************************************************/
/* Setting scrollbar values invokes the callback. Use this variable
to indicate that callback should do nothing. */
int xg_ignore_gtk_scrollbar = 0;
/* After we send a scroll bar event, x_set_toolkit_scroll_bar_thumb will
be called. For some reason that needs to be debugged, it gets called
with bad values. Thus, we set this variable to ignore those calls. */
int xg_ignore_next_thumb = 0;
/* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in
32 bits. But we want to store pointers, and they may be larger
than 32 bits. Keep a mapping from int to pointers to get around
the 32 bit limitation. */
static struct
{
GtkWidget **widgets;
int max_size;
int used;
} id_to_widget = { 0, 0, 0 };
/* Grow this much every time we need to allocate more */
#define ID_TO_WIDGET_INCR 32
/* Store a pointer in id_to_widget and return the int. */
static int
xg_store_widget_in_map (w)
GtkWidget *w;
{
int i;
if (id_to_widget.max_size == id_to_widget.used)
{
int new_size = id_to_widget.max_size + ID_TO_WIDGET_INCR;
id_to_widget.widgets = xrealloc (id_to_widget.widgets,
sizeof (GtkWidget *)*new_size);
for (i = id_to_widget.max_size; i < new_size; ++i)
id_to_widget.widgets[i] = 0;
id_to_widget.max_size = new_size;
}
/* Just loop over the array and find a free place. After all,
how many scrollbars are we creating? Should be a small number.
The check above guarantees we will find a free place. */
for (i = 0; i < id_to_widget.max_size; ++i)
{
if (! id_to_widget.widgets[i])
{
id_to_widget.widgets[i] = w;
++id_to_widget.used;
return i;
}
}
/* Should never end up here */
abort ();
}
/* Remove a pointer from id_to_widget. Called when scrollbar is destroyed. */
static void
xg_remove_widget_from_map (idx)
int idx;
{
if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
{
id_to_widget.widgets[idx] = 0;
--id_to_widget.used;
}
}
/* Get widget pointer from id_to_widget. */
static GtkWidget*
xg_get_widget_from_map (idx)
int idx;
{
if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0)
return id_to_widget.widgets[idx];
return 0;
}
/* Callback invoked when scrollbars are destroyed. We free pointer to
last scrollbar value here and remove the id. */
static void
xg_gtk_scroll_destroy (widget, data)
GtkWidget *widget;
gpointer data;
{
gpointer p;
int id = (int)data;
p = g_object_get_data (G_OBJECT (widget), G_LAST_SB_DATA);
if (p) xfree (p);
xg_remove_widget_from_map (id);
}
void
xg_create_scroll_bar (f, bar, scroll_callback, scroll_bar_name)
FRAME_PTR f;
struct scroll_bar *bar;
GCallback scroll_callback;
char *scroll_bar_name;
{
GtkWidget *wscroll;
GtkObject *vadj;
int scroll_id;
/* Page, step increment values are not so important here, they
will be corrected in x_set_toolkit_scroll_bar_thumb. */
vadj = gtk_adjustment_new (GTK_SB_MIN, GTK_SB_MIN, GTK_SB_MAX,
0.1, 0.1, 0.1);
/* KOKO, set fg & bg, cursor? */
wscroll = gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj));
gtk_widget_set_name (wscroll, scroll_bar_name);
gtk_range_set_update_policy (GTK_RANGE (wscroll), GTK_UPDATE_CONTINUOUS);
scroll_id = xg_store_widget_in_map (wscroll);
g_signal_connect (vadj,
"value-changed",
scroll_callback,
(gpointer)bar);
g_signal_connect (wscroll,
"destroy",
G_CALLBACK(xg_gtk_scroll_destroy),
(gpointer)scroll_id);
gtk_fixed_put (GTK_FIXED (f->output_data.x->edit_widget),
wscroll, 0, 0);
SET_SCROLL_BAR_X_WINDOW (bar, scroll_id);
}
void
xg_show_scroll_bar (scrollbar_id)
int scrollbar_id;
{
GtkWidget *w = xg_get_widget_from_map (scrollbar_id);
if (w)
gtk_widget_show (w);
}
void
xg_remove_scroll_bar (f, scrollbar_id)
FRAME_PTR f;
int scrollbar_id;
{
GtkWidget *w = xg_get_widget_from_map (scrollbar_id);
if (w)
{
gtk_widget_destroy (w);
SET_FRAME_GARBAGED (f);
}
}
/* Update the position of the vertical scrollbar wscroll in frame F. */
void
xg_update_scrollbar_pos (f, scrollbar_id, top, left, width, height)
FRAME_PTR f;
int scrollbar_id;
int top;
int left;
int width;
int height;
{
int gtop = top;
int gheight = max (height, 1);
GtkWidget *wscroll = xg_get_widget_from_map (scrollbar_id);
if (wscroll)
{
gtk_fixed_move (GTK_FIXED (f->output_data.x->edit_widget),
wscroll, left, gtop);
gtk_widget_set_size_request (wscroll, width, gheight);
gtk_widget_queue_draw (wscroll);
/* Since we are not using a pure gtk event loop, we must force out
pending update events with this call. */
gdk_window_process_all_updates ();
}
}
/* Set the thumb size and position of scroll bar BAR. We are currently
displaying PORTION out of a whole WHOLE, and our position POSITION. */
void
xg_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
struct scroll_bar *bar;
int portion, position, whole;
{
GtkWidget *wscroll = xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar));
if (wscroll && whole > 0 && ! xg_ignore_next_thumb)
{
GtkAdjustment* adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
gdouble top = GTK_SB_RANGE * ((gdouble) position / whole);
gdouble shown = GTK_SB_RANGE * ((gdouble) portion / whole);
adj->page_size = (int)shown;
/* Assume a page increment is about 95% of the page size */
adj->page_increment = (int) (0.95*adj->page_size);
/* Average 30 chars per line */
adj->step_increment = (int) (adj->page_size/30.0);
/* gtk_range_set_value invokes the callback. Set ignore_gtk_scrollbar
to make the callback do nothing */
xg_ignore_gtk_scrollbar = 1;
gtk_range_set_value (GTK_RANGE (wscroll), top);
xg_ignore_gtk_scrollbar = 0;
}
/* Make sure the scrollbar is redrawn with new thumb */
gtk_widget_queue_draw (wscroll);
gdk_window_process_all_updates (); /* See comment in gtkutil.c */
xg_ignore_next_thumb = 0;
}
#endif /* USE_GTK */
[-- Attachment #4: Type: text/plain, Size: 142 bytes --]
_______________________________________________
Emacs-devel mailing list
Emacs-devel@gnu.org
http://mail.gnu.org/mailman/listinfo/emacs-devel
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-08 22:33 GTK patches part 2 Jan D.
@ 2002-12-09 21:25 ` Eric Gillespie
2002-12-10 18:28 ` Jan D.
0 siblings, 1 reply; 12+ messages in thread
From: Eric Gillespie @ 2002-12-09 21:25 UTC (permalink / raw
"Jan D." <jan.h.d@swipnet.se> writes:
> These are the new files in the GTK port. Most of the GTK specific code is
> here.
gtkutil.c was missing at least <stdio.h> and <stdlib.h>,
possibly others.
--
Eric Gillespie <*> epg@pretzelnet.org
Build a fire for a man, and he'll be warm for a day. Set a man on
fire, and he'll be warm for the rest of his life. -Terry Pratchett
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-09 21:25 ` Eric Gillespie
@ 2002-12-10 18:28 ` Jan D.
2002-12-10 19:06 ` Eric Gillespie
0 siblings, 1 reply; 12+ messages in thread
From: Jan D. @ 2002-12-10 18:28 UTC (permalink / raw
Cc: emacs-devel
>
> "Jan D." <jan.h.d@swipnet.se> writes:
>
> > These are the new files in the GTK port. Most of the GTK specific code is
> > here.
>
> gtkutil.c was missing at least <stdio.h> and <stdlib.h>,
> possibly others.
Can you send compilation warnings/errors you are seeing or platform and
compiler flags?
Jan D.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-10 18:28 ` Jan D.
@ 2002-12-10 19:06 ` Eric Gillespie
2002-12-10 19:33 ` Jan D.
0 siblings, 1 reply; 12+ messages in thread
From: Eric Gillespie @ 2002-12-10 19:06 UTC (permalink / raw
"Jan D." <jan.h.d@swipnet.se> writes:
> Can you send compilation warnings/errors you are seeing or platform and
> compiler flags?
Why? You reference fprintf and stderr, so you need <stdio.h>.
You reference malloc, so you need <stdlib.h>. End of story.
--
Eric Gillespie <*> epg@pretzelnet.org
Build a fire for a man, and he'll be warm for a day. Set a man on
fire, and he'll be warm for the rest of his life. -Terry Pratchett
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-10 19:06 ` Eric Gillespie
@ 2002-12-10 19:33 ` Jan D.
2002-12-10 20:08 ` Eric Gillespie
0 siblings, 1 reply; 12+ messages in thread
From: Jan D. @ 2002-12-10 19:33 UTC (permalink / raw
Cc: emacs-devel
>
> "Jan D." <jan.h.d@swipnet.se> writes:
>
> > Can you send compilation warnings/errors you are seeing or platform and
> > compiler flags?
>
> Why? You reference fprintf and stderr, so you need <stdio.h>.
> You reference malloc, so you need <stdlib.h>. End of story.
Well, I don't usually add include:s unless needed. For example,
xterm.h includes X11 headers who in turn includes a lot of standard
headers. If what is needed gets included that way, I'm fine with it.
Jan D.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-10 19:33 ` Jan D.
@ 2002-12-10 20:08 ` Eric Gillespie
2002-12-10 20:44 ` Jan D.
0 siblings, 1 reply; 12+ messages in thread
From: Eric Gillespie @ 2002-12-10 20:08 UTC (permalink / raw
"Jan D." <jan.h.d@swipnet.se> writes:
> Well, I don't usually add include:s unless needed. For example,
> xterm.h includes X11 headers who in turn includes a lot of standard
> headers. If what is needed gets included that way, I'm fine with it.
You can't rely on that. If *you* make reference to symbols or
macros, *you* need to include the appropriate header file,
regardless of whether or not some other header you include also
needs that header file. Sometimes people just dump all their
includes into one local header file and just include that. It
gets the job done, but then each file isn't explicitly declaring
what it needs.
--
Eric Gillespie <*> epg@pretzelnet.org
Build a fire for a man, and he'll be warm for a day. Set a man on
fire, and he'll be warm for the rest of his life. -Terry Pratchett
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-10 20:08 ` Eric Gillespie
@ 2002-12-10 20:44 ` Jan D.
2002-12-10 21:23 ` Eric Gillespie
0 siblings, 1 reply; 12+ messages in thread
From: Jan D. @ 2002-12-10 20:44 UTC (permalink / raw
Cc: emacs-devel
>
> "Jan D." <jan.h.d@swipnet.se> writes:
>
> > Well, I don't usually add include:s unless needed. For example,
> > xterm.h includes X11 headers who in turn includes a lot of standard
> > headers. If what is needed gets included that way, I'm fine with it.
>
> You can't rely on that. If *you* make reference to symbols or
> macros, *you* need to include the appropriate header file,
> regardless of whether or not some other header you include also
> needs that header file. Sometimes people just dump all their
There is no such requrement in the C standard, even if it makes
sense for some people.
> includes into one local header file and just include that. It
> gets the job done, but then each file isn't explicitly declaring
> what it needs.
For example, stdlib.h is included by config.h, so it is clearly
redundant to do so elsewhere. I can put in stdio.h just for the
sake of portability.
Jan D.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-10 20:44 ` Jan D.
@ 2002-12-10 21:23 ` Eric Gillespie
2002-12-11 17:45 ` Richard Stallman
2002-12-11 17:48 ` Jan D.
0 siblings, 2 replies; 12+ messages in thread
From: Eric Gillespie @ 2002-12-10 21:23 UTC (permalink / raw
"Jan D." <jan.h.d@swipnet.se> writes:
> > You can't rely on that. If *you* make reference to symbols or
> > macros, *you* need to include the appropriate header file,
> > regardless of whether or not some other header you include also
> > needs that header file. Sometimes people just dump all their
>
> There is no such requrement in the C standard, even if it makes
> sense for some people.
Who said anything about the standard? Standards have nothing to
do with this. The fact is that if you don't include relevant
headers yourself (having them in local header files such as
config.h as you mention below counts as "yourself", of course),
you cannot count on the declarations being available. Unless
you only want the program to work on your system, of course (no,
i'm not accusing you of that, i know it was a simple mistake :).
> For example, stdlib.h is included by config.h, so it is clearly
Whoops. When i noticed the stderr problem also noticed malloc
being called with no stdlib.h. As i said, my preferred style
would be to go ahead and explicitly include stdlib.h in gtkutil.c
itself. But i don't get to make such decisions for emacs, nor do
i want to; it works and that's all that matters to me.
> redundant to do so elsewhere. I can put in stdio.h just for the
> sake of portability.
Thanks.
Just out of curiosity, which header included stdio.h for you on
your system?
--
Eric Gillespie <*> epg@pretzelnet.org
Build a fire for a man, and he'll be warm for a day. Set a man on
fire, and he'll be warm for the rest of his life. -Terry Pratchett
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-10 21:23 ` Eric Gillespie
@ 2002-12-11 17:45 ` Richard Stallman
2002-12-11 20:04 ` Eric Gillespie
2002-12-11 17:48 ` Jan D.
1 sibling, 1 reply; 12+ messages in thread
From: Richard Stallman @ 2002-12-11 17:45 UTC (permalink / raw
Cc: emacs-devel
> For example, stdlib.h is included by config.h, so it is clearly
Whoops. When i noticed the stderr problem also noticed malloc
being called with no stdlib.h.
config.h does indeed include stdlib.h, so I think the question is, how
did it happen that stdlib.h failed to get included when you tried
this? That could be a bug, but it would be a bug in a different
place.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-10 21:23 ` Eric Gillespie
2002-12-11 17:45 ` Richard Stallman
@ 2002-12-11 17:48 ` Jan D.
1 sibling, 0 replies; 12+ messages in thread
From: Jan D. @ 2002-12-11 17:48 UTC (permalink / raw
Cc: emacs-devel
> "Jan D." <jan.h.d@swipnet.se> writes:
>> For example, stdlib.h is included by config.h, so it is clearly
>
> Whoops. When i noticed the stderr problem also noticed malloc
> being called with no stdlib.h. As i said, my preferred style
> would be to go ahead and explicitly include stdlib.h in gtkutil.c
> itself. But i don't get to make such decisions for emacs, nor do
> i want to; it works and that's all that matters to me.
I'm not sure what the Emacs policy is. The GNU coding standards don't
say much on the issue. It has a passage that discusses the advantage
of not declaring system functions at all rather than declaring them
yourself, but I don't think that applies.
> Just out of curiosity, which header included stdio.h for you on
> your system?
s/gnu-linux.h in Emacs does actually.
Jan D.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-11 17:45 ` Richard Stallman
@ 2002-12-11 20:04 ` Eric Gillespie
2002-12-12 6:05 ` Eli Zaretskii
0 siblings, 1 reply; 12+ messages in thread
From: Eric Gillespie @ 2002-12-11 20:04 UTC (permalink / raw
Richard Stallman <rms@gnu.org> writes:
> config.h does indeed include stdlib.h, so I think the question is, how
> did it happen that stdlib.h failed to get included when you tried
> this? That could be a bug, but it would be a bug in a different
> place.
As i think i said in another post, my suggesting stdlib.h was
over-zealousness on my part. The missing stdio.h was real (got
an error about stderr reference) and noticed malloc usage while
i was there. Bad assumptions lead to bad advice.
In another post, Jan reveals why the stdio.h problem was not
obvious until i tried to build: s/gnu-linux.h includes stdio.h.
This sort of thing is bound to happen again in the future, which
is why i suggest that it is better to include the headers you
need, rather than relying on system-dependent header files to do
it for you.
--
Eric Gillespie <*> epg@pretzelnet.org
Build a fire for a man, and he'll be warm for a day. Set a man on
fire, and he'll be warm for the rest of his life. -Terry Pratchett
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: GTK patches part 2
2002-12-11 20:04 ` Eric Gillespie
@ 2002-12-12 6:05 ` Eli Zaretskii
0 siblings, 0 replies; 12+ messages in thread
From: Eli Zaretskii @ 2002-12-12 6:05 UTC (permalink / raw
Cc: emacs-devel
On Wed, 11 Dec 2002, Eric Gillespie wrote:
> In another post, Jan reveals why the stdio.h problem was not
> obvious until i tried to build: s/gnu-linux.h includes stdio.h.
> This sort of thing is bound to happen again in the future, which
> is why i suggest that it is better to include the headers you
> need, rather than relying on system-dependent header files to do
> it for you.
FWIW, I agree. I didn't check in this particular case, but I'm guessing
that s/gnu-linux.h included stdio.h because it used something from that
header. Other system-dependent headers might not do that. Including
stdio.h in each of the *.c files that use stdio will thus prevent
compilation problems on some platforms.
^ permalink raw reply [flat|nested] 12+ messages in thread
end of thread, other threads:[~2002-12-12 6:05 UTC | newest]
Thread overview: 12+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2002-12-08 22:33 GTK patches part 2 Jan D.
2002-12-09 21:25 ` Eric Gillespie
2002-12-10 18:28 ` Jan D.
2002-12-10 19:06 ` Eric Gillespie
2002-12-10 19:33 ` Jan D.
2002-12-10 20:08 ` Eric Gillespie
2002-12-10 20:44 ` Jan D.
2002-12-10 21:23 ` Eric Gillespie
2002-12-11 17:45 ` Richard Stallman
2002-12-11 20:04 ` Eric Gillespie
2002-12-12 6:05 ` Eli Zaretskii
2002-12-11 17:48 ` Jan D.
Code repositories for project(s) associated with this public inbox
https://git.savannah.gnu.org/cgit/emacs.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).