static ad_device_data *
sound_nas_create(Lisp_Object nas_options)
{
sound_nas_data_t *snd;
char *server[6] = {NULL, NULL, NULL, NULL, NULL, NULL};
int i, server_cnt = 0;
AuServer *aud = NULL;
Lisp_Object opt_server = Qnil;
/* parse options */
opt_server = Fplist_get(nas_options, intern(":server"), Qnil);
if (!NILP(opt_server) && !STRINGP(opt_server) && !DEVICEP(opt_server)) {
wrong_type_argument(Qstringp, opt_server);
return NULL;
}
if (NILP(opt_server))
nas_setup_defaults(server, &server_cnt);
else if (STRINGP(opt_server))
server[server_cnt++] = (char*)XSTRING_DATA(opt_server);
#ifdef HAVE_X_WINDOWS
else if (DEVICEP(opt_server) && DEVICE_X_P(XDEVICE(opt_server)))
server[server_cnt++] =
(char*)XSTRING_DATA(
DEVICE_CONNECTION(XDEVICE(opt_server)));
#endif
NAS_DEBUG("trying %d connections\n", server_cnt);
for (i = 0; i<server_cnt; i++)
if ((aud = nas_try_connection(server[i])))
break;
if (!aud) {
NAS_DEBUG_C("cannot contact any NAS server\n");
warn_when_safe(Qnas, Qwarning,
GETTEXT("No NAS servers in sight.\n"));
return NULL; /* Could not contact NAS server */
}
/* -- initialise -- */
snd = xnew_and_zero(sound_nas_data_t);
snd->aud = aud;
/* round up SOUND_MAX_AUDIO_FRAME_SIZE to multiple of NAS_FRAG_SIZE
* divide by 3 first because of 2:1 split */
snd->proposed_buffer_size =
(SOUND_MAX_AUDIO_FRAME_SIZE/3 + NAS_FRAG_SIZE-1)
& ~(NAS_FRAG_SIZE-1);
NAS_DEBUG_C("proposed buffer size: %u\n", snd->proposed_buffer_size);
NAS_DEBUG_C("created: 0x%x\n", (unsigned int)snd);
return snd;
}
Extbyte *add_accel_and_to_external(Lisp_Object string)
{
int i;
int found_accel = 0;
Extbyte *retval;
Bufbyte *name = XSTRING_DATA(string);
for (i = 0; name[i]; ++i)
if (name[i] == '%' && name[i + 1] == '_') {
found_accel = 1;
break;
}
if (found_accel)
LISP_STRING_TO_EXTERNAL_MALLOC(string, retval, Qlwlib_encoding);
else {
size_t namelen = XSTRING_LENGTH(string);
Bufbyte *chars = (Bufbyte *) alloca(namelen + 3);
chars[0] = '%';
chars[1] = '_';
memcpy(chars + 2, name, namelen + 1);
C_STRING_TO_EXTERNAL_MALLOC(chars, retval, Qlwlib_encoding);
}
return retval;
}
static int
gtk_initialize_color_instance (struct Lisp_Color_Instance *c, Lisp_Object name,
Lisp_Object device, Error_behavior errb)
{
GdkColor color;
int result;
result = gtk_parse_nearest_color (XDEVICE (device), &color,
XSTRING_DATA (name),
XSTRING_LENGTH (name),
errb);
if (!result)
return 0;
/* Don't allocate the data until we're sure that we will succeed,
or the finalize method may get f****d. */
c->data = xnew (struct gtk_color_instance_data);
if (result == 3)
COLOR_INSTANCE_GTK_DEALLOC (c) = 0;
else
COLOR_INSTANCE_GTK_DEALLOC (c) = 1;
COLOR_INSTANCE_GTK_COLOR (c) = gdk_color_copy (&color);
return 1;
}
static void
weird_doc (Lisp_Object sym, const Ascbyte *weirdness, const Ascbyte *type,
int pos)
{
if (!strcmp (weirdness, "duplicate")) return;
message ("Note: Strange doc (%s) for %s %s @ %d",
GETTEXT (weirdness), GETTEXT (type),
XSTRING_DATA (XSYMBOL (sym)->name), pos);
}
static ad_device_data *
sound_ao_create(Lisp_Object ao_options)
{
int driver;
ao_device *device;
ao_option *options;
ao_sample_format *fmt;
/* result */
sound_ao_data_t *aod;
/* option keywords */
Lisp_Object opt_driver;
char *optext_driver = NULL;
/* parse options */
opt_driver = Fplist_get(ao_options, intern(":driver"), Qnil);
if (!NILP(opt_driver) && !STRINGP(opt_driver)) {
wrong_type_argument(Qstringp, opt_driver);
return NULL;
} else if (STRINGP(opt_driver))
optext_driver = (char*)XSTRING_DATA(opt_driver);
/* -- initialise -- */
ao_initialize();
fmt = xmalloc(sizeof(ao_sample_format));
/* -- Setup for driver -- */
if (optext_driver != NULL)
driver = ao_driver_id(optext_driver);
else
driver = ao_default_driver_id();
/* just some generics */
fmt->channels = 2;
fmt->rate = 44100;
fmt->bits = 16;
fmt->byte_format = AO_FMT_LITTLE;
options = NULL;
/* -- Open driver -- */
device = ao_open_live(driver, fmt, options);
if (device == NULL) {
message(GETTEXT("audio-ao: Unsupported driver."));
xfree(fmt);
aod = NULL;
} else {
aod = xnew_and_zero(sound_ao_data_t);
aod->ad = device;
aod->options = NULL;
aod->fmt = fmt;
aod->driver_id = driver;
}
return aod;
}
static void
nas_setup_defaults(char **server, int *cnt)
{
int i;
Lisp_Object tmp;
/* considering some defaults */
NAS_DEBUG("trying to find some defaults\n");
#ifdef HAVE_X_WINDOWS
/* check for the device connection of the currently active frame */
tmp = Fselected_device(Qnil);
if (DEVICEP(tmp) && DEVICE_X_P(XDEVICE(tmp)))
server[(*cnt)++] =
(char*)XSTRING_DATA(
DEVICE_CONNECTION(XDEVICE(tmp)));
/* tbd: check for conn of the initial frame */
#endif
/* try to look for $AUDIOSERVER */
if ((server[(*cnt)] = getenv("AUDIOSERVER"))) {
/* only add the stuff, if not already in the try queue */
for (i=0; i < (*cnt); i++)
if (strcmp(server[i], server[(*cnt)]) == 0)
break;
if (i == (*cnt))
(*cnt)++;
}
/* try to look for $DISPLAY */
if ((server[(*cnt)] = getenv("DISPLAY"))){
/* only add the stuff, if not already in the try queue */
for (i=0; i < (*cnt); i++)
if (strcmp(server[i], server[(*cnt)]) == 0)
break;
if (i == (*cnt))
(*cnt)++;
}
/* oh, let's try localhost:0.0, if not already there of course */
for (i=0; i < (*cnt); i++)
if (strcmp(server[i], "localhost:0.0") == 0)
break;
if (i == (*cnt))
server[(*cnt)++] = "localhost:0.0";
/* finally we try NULL, too */
server[(*cnt)++] = NULL;
return;
}
static int
gtk_font_spec_matches_charset (struct device *d, Lisp_Object charset,
const Bufbyte *nonreloc, Lisp_Object reloc,
Bytecount offset, Bytecount length)
{
if (UNBOUNDP (charset))
return 1;
/* Hack! Short font names don't have the registry in them,
so we just assume the user knows what they're doing in the
case of ASCII. For other charsets, you gotta give the
long form; sorry buster.
*/
if (EQ (charset, Vcharset_ascii))
{
const Bufbyte *the_nonreloc = nonreloc;
int i;
Bytecount the_length = length;
if (!the_nonreloc)
the_nonreloc = XSTRING_DATA (reloc);
fixup_internal_substring (nonreloc, reloc, offset, &the_length);
the_nonreloc += offset;
if (!memchr (the_nonreloc, '*', the_length))
{
for (i = 0;; i++)
{
const Bufbyte *new_nonreloc = (const Bufbyte *)
memchr (the_nonreloc, '-', the_length);
if (!new_nonreloc)
break;
new_nonreloc++;
the_length -= new_nonreloc - the_nonreloc;
the_nonreloc = new_nonreloc;
}
/* If it has less than 5 dashes, it's a short font.
Of course, long fonts always have 14 dashes or so, but short
fonts never have more than 1 or 2 dashes, so this is some
sort of reasonable heuristic. */
if (i < 5)
return 1;
}
}
return (fast_string_match (XCHARSET_REGISTRY (charset),
nonreloc, reloc, offset, length, 1,
ERROR_ME, 0) >= 0);
}
static void
print_console (Lisp_Object obj, Lisp_Object printcharfun,
int UNUSED (escapeflag))
{
struct console *con = XCONSOLE (obj);
if (print_readably)
printing_unreadable_lisp_object (obj, XSTRING_DATA (con->name));
write_fmt_string (printcharfun, "#<%s-console",
!CONSOLE_LIVE_P (con) ? "dead" : CONSOLE_TYPE_NAME (con));
if (CONSOLE_LIVE_P (con) && !NILP (CONSOLE_CONNECTION (con)))
write_fmt_string_lisp (printcharfun, " on %S", 1,
CONSOLE_CONNECTION (con));
write_fmt_string (printcharfun, " 0x%x>", LISP_OBJECT_UID (obj));
}
static void
print_ldap(Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
char buf[32];
Lisp_LDAP *ldap = XLDAP(obj);
if (print_readably)
error("printing unreadable object #<ldap %s>",
XSTRING_DATA(ldap->host));
write_c_string("#<ldap ", printcharfun);
print_internal(ldap->host, printcharfun, 1);
if (!ldap->ld)
write_c_string("(dead) ", printcharfun);
write_fmt_string(printcharfun, " 0x%lx>", (long)ldap);
}
static void
print_device (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
{
struct device *d = XDEVICE (obj);
char buf[256];
if (print_readably)
error ("printing unreadable object #<device %s 0x%x>",
XSTRING_DATA (d->name), d->header.uid);
sprintf (buf, "#<%s-device", !DEVICE_LIVE_P (d) ? "dead" :
DEVICE_TYPE_NAME (d));
write_c_string (buf, printcharfun);
if (DEVICE_LIVE_P (d) && !NILP (DEVICE_CONNECTION (d)))
{
write_c_string (" on ", printcharfun);
print_internal (DEVICE_CONNECTION (d), printcharfun, 1);
}
sprintf (buf, " 0x%x>", d->header.uid);
write_c_string (buf, printcharfun);
}
static Lisp_Object
casify_object (enum case_action flag, Lisp_Object string_or_char,
Lisp_Object buffer)
{
struct buffer *buf = decode_buffer (buffer, 0);
retry:
if (CHAR_OR_CHAR_INTP (string_or_char))
{
Ichar c;
CHECK_CHAR_COERCE_INT (string_or_char);
c = XCHAR (string_or_char);
if (flag == CASE_DOWN)
{
c = DOWNCASE (buf, c);
}
else if (flag == CASE_UP)
{
c = UPCASE (buf, c);
}
else
{
c = CANONCASE (buf, c);
}
return make_char (c);
}
if (STRINGP (string_or_char))
{
Lisp_Object syntax_table = buf->mirror_syntax_table;
Ibyte *storage =
alloca_ibytes (XSTRING_LENGTH (string_or_char) * MAX_ICHAR_LEN);
Ibyte *newp = storage;
Ibyte *oldp = XSTRING_DATA (string_or_char);
Ibyte *endp = oldp + XSTRING_LENGTH (string_or_char);
int wordp = 0, wordp_prev;
while (oldp < endp)
{
Ichar c = itext_ichar (oldp);
switch (flag)
{
case CASE_UP:
c = UPCASE (buf, c);
break;
case CASE_DOWN:
c = DOWNCASE (buf, c);
break;
case CASE_CANONICALIZE:
c = CANONCASE (buf, c);
break;
case CASE_CAPITALIZE:
case CASE_CAPITALIZE_UP:
wordp_prev = wordp;
wordp = WORD_SYNTAX_P (syntax_table, c);
if (!wordp) break;
if (wordp_prev)
{
if (flag == CASE_CAPITALIZE)
c = DOWNCASE (buf, c);
}
else
c = UPCASE (buf, c);
break;
}
newp += set_itext_ichar (newp, c);
INC_IBYTEPTR (oldp);
}
return make_string (storage, newp - storage);
}
string_or_char = wrong_type_argument (Qchar_or_string_p, string_or_char);
goto retry;
}
EXTERNAL_PROPERTY_LIST_LOOP(list, keyword, value, search_plist)
{
/* Host */
if (EQ (keyword, Qhost))
{
CHECK_STRING (value);
ldap_host = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_host, (char *)XSTRING_DATA (value));
}
/* Filter */
else if (EQ (keyword, Qfilter))
{
CHECK_STRING (value);
ldap_filter = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_filter, (char *)XSTRING_DATA (value));
}
/* Attributes */
else if (EQ (keyword, Qattributes))
{
if (! NILP (value))
{
Lisp_Object attr_left = value;
struct gcpro ngcpro1;
NGCPRO1 (attr_left);
CHECK_CONS (value);
ldap_attributes = alloca ((XINT (Flength (value)) + 1)*sizeof (char *));
for (i=0; !NILP (attr_left); i++) {
CHECK_STRING (XCAR (attr_left));
ldap_attributes[i] = alloca (XSTRING_LENGTH (XCAR (attr_left)) + 1);
strcpy(ldap_attributes[i],
(char *)(XSTRING_DATA( XCAR (attr_left))));
attr_left = XCDR (attr_left);
}
ldap_attributes[i] = NULL;
NUNGCPRO;
}
}
/* Attributes Only */
else if (EQ (keyword, Qattrsonly))
{
CHECK_SYMBOL (value);
ldap_attrsonly = NILP (value) ? 0 : 1;
}
/* Base */
else if (EQ (keyword, Qbase))
{
if (!NILP (value))
{
CHECK_STRING (value);
ldap_base = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_base, (char *)XSTRING_DATA (value));
}
}
/* Scope */
else if (EQ (keyword, Qscope))
{
CHECK_SYMBOL (value);
if (EQ (value, Qbase))
ldap_scope = LDAP_SCOPE_BASE;
else if (EQ (value, Qonelevel))
ldap_scope = LDAP_SCOPE_ONELEVEL;
else if (EQ (value, Qsubtree))
ldap_scope = LDAP_SCOPE_SUBTREE;
else
signal_simple_error ("Invalid scope", value);
}
/* Authentication method */
else if (EQ (keyword, Qauth))
{
CHECK_SYMBOL (value);
if (EQ (value, Qsimple))
ldap_auth = LDAP_AUTH_SIMPLE;
#ifdef LDAP_AUTH_KRBV41
else if (EQ (value, Qkrbv41))
ldap_auth = LDAP_AUTH_KRBV41;
#endif
#ifdef LDAP_AUTH_KRBV42
else if (EQ (value, Qkrbv42))
ldap_auth = LDAP_AUTH_KRBV42;
#endif
else
signal_simple_error ("Invalid authentication method", value);
}
/* Bind DN */
else if (EQ (keyword, Qbinddn))
{
if (!NILP (value))
{
CHECK_STRING (value);
ldap_binddn = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_binddn, (char *)XSTRING_DATA (value));
}
}
/* Password */
else if (EQ (keyword, Qpasswd))
{
if (!NILP (value))
{
CHECK_STRING (value);
ldap_passwd = alloca (XSTRING_LENGTH (value) + 1);
strcpy (ldap_passwd, (char *)XSTRING_DATA (value));
}
}
/* Deref */
else if (EQ (keyword, Qderef))
{
CHECK_SYMBOL (value);
if (EQ (value, Qnever))
ldap_deref = LDAP_DEREF_NEVER;
else if (EQ (value, Qsearch))
ldap_deref = LDAP_DEREF_SEARCHING;
else if (EQ (value, Qfind))
ldap_deref = LDAP_DEREF_FINDING;
else if (EQ (value, Qalways))
ldap_deref = LDAP_DEREF_ALWAYS;
else
signal_simple_error ("Invalid deref value", value);
}
/* Timelimit */
else if (EQ (keyword, Qtimelimit))
{
if (!NILP (value))
{
CHECK_INT (value);
ldap_timelimit = XINT (value);
}
}
/* Sizelimit */
else if (EQ (keyword, Qsizelimit))
{
if (!NILP (value))
{
CHECK_INT (value);
ldap_sizelimit = XINT (value);
}
}
}
static Lisp_Object
casify_object(enum case_action flag, Lisp_Object string_or_char,
Lisp_Object buffer)
{
struct buffer *buf = decode_buffer(buffer, 0);
retry:
if (CHAR_OR_CHAR_INTP(string_or_char)) {
Emchar c;
CHECK_CHAR_COERCE_INT(string_or_char);
c = XCHAR(string_or_char);
c = (flag == CASE_DOWN) ? DOWNCASE(buf, c) : UPCASE(buf, c);
return make_char(c);
}
if (STRINGP(string_or_char)) {
Lisp_Char_Table *syntax_table =
XCHAR_TABLE(buf->mirror_syntax_table);
Bufbyte *storage =
alloca_array(Bufbyte,
XSTRING_LENGTH(string_or_char) *
MAX_EMCHAR_LEN);
Bufbyte *newp = storage;
Bufbyte *oldp = XSTRING_DATA(string_or_char);
int wordp = 0, wordp_prev;
while (*oldp) {
Emchar c = charptr_emchar(oldp);
switch (flag) {
case CASE_UP:
c = UPCASE(buf, c);
break;
case CASE_DOWN:
c = DOWNCASE(buf, c);
break;
case CASE_CAPITALIZE:
case CASE_CAPITALIZE_UP:
wordp_prev = wordp;
wordp = WORD_SYNTAX_P(syntax_table, c);
if (!wordp)
break;
if (wordp_prev) {
if (flag == CASE_CAPITALIZE)
c = DOWNCASE(buf, c);
} else
c = UPCASE(buf, c);
break;
/* can't happen */
default:
/* abort()? */
break;
}
newp += set_charptr_emchar(newp, c);
INC_CHARPTR(oldp);
}
return make_string(storage, newp - storage);
}
string_or_char = wrong_type_argument(Qchar_or_string_p, string_or_char);
goto retry;
}
static Lisp_Object
get_object_file_name (Lisp_Object filepos)
{
REGISTER int fd;
REGISTER Ibyte *name_nonreloc = 0;
EMACS_INT position;
Lisp_Object file, tem;
Lisp_Object name_reloc = Qnil;
int standard_doc_file = 0;
if (FIXNUMP (filepos))
{
file = Vinternal_doc_file_name;
standard_doc_file = 1;
position = XFIXNUM (filepos);
}
else if (CONSP (filepos) && FIXNUMP (XCDR (filepos)))
{
file = XCAR (filepos);
position = XFIXNUM (XCDR (filepos));
if (position < 0)
position = - position;
}
else
return Qnil;
if (!STRINGP (file))
return Qnil;
/* Put the file name in NAME as a C string.
If it is relative, combine it with Vdoc_directory. */
tem = Ffile_name_absolute_p (file);
if (NILP (tem))
{
Bytecount minsize;
/* XEmacs: Move this check here. OK if called during loadup to
load byte code instructions. */
if (!STRINGP (Vdoc_directory))
return Qnil;
minsize = XSTRING_LENGTH (Vdoc_directory);
/* sizeof ("../lib-src/") == 12 */
if (minsize < 12)
minsize = 12;
name_nonreloc = alloca_ibytes (minsize + XSTRING_LENGTH (file) + 8);
string_join (name_nonreloc, Vdoc_directory, file);
}
else
name_reloc = file;
fd = qxe_open (name_nonreloc ? name_nonreloc :
XSTRING_DATA (name_reloc), O_RDONLY | OPEN_BINARY, 0);
if (fd < 0)
{
if (purify_flag)
{
/* sizeof ("../lib-src/") == 12 */
name_nonreloc = alloca_ibytes (12 + XSTRING_LENGTH (file) + 8);
/* Preparing to dump; DOC file is probably not installed.
So check in ../lib-src. */
qxestrcpy_ascii (name_nonreloc, "../lib-src/");
qxestrcat (name_nonreloc, XSTRING_DATA (file));
fd = qxe_open (name_nonreloc, O_RDONLY | OPEN_BINARY, 0);
}
if (fd < 0)
report_file_error ("Cannot open doc string file",
name_nonreloc ? build_istring (name_nonreloc) :
name_reloc);
}
tem = extract_object_file_name (fd, position, name_nonreloc, name_reloc,
standard_doc_file);
retry_close (fd);
if (!STRINGP (tem))
signal_error_1 (Qinvalid_byte_code, tem);
return tem;
}
static void
gtk_output_toolbar_button (struct frame *f, Lisp_Object button)
{
int shadow_thickness = 2;
int x_adj, y_adj, width_adj, height_adj;
GdkWindow *x_win = FRAME_GTK_TEXT_WIDGET (f)->window;
GdkGC *background_gc = get_toolbar_gc (f);
Lisp_Object instance, frame, window, glyph;
struct toolbar_button *tb = XTOOLBAR_BUTTON (button);
struct Lisp_Image_Instance *p;
struct window *w;
int vertical = tb->vertical;
int border_width = tb->border_width;
if (vertical)
{
x_adj = border_width;
width_adj = - 2 * border_width;
y_adj = 0;
height_adj = 0;
}
else
{
x_adj = 0;
width_adj = 0;
y_adj = border_width;
height_adj = - 2 * border_width;
}
XSETFRAME (frame, f);
window = FRAME_LAST_NONMINIBUF_WINDOW (f);
w = XWINDOW (window);
glyph = get_toolbar_button_glyph (w, tb);
if (tb->enabled)
{
if (tb->down)
{
shadow_thickness = -2;
}
else
{
shadow_thickness = 2;
}
}
else
{
shadow_thickness = 0;
}
background_gc = get_toolbar_gc (f);
/* Clear the entire area. */
gdk_draw_rectangle (x_win, background_gc, TRUE,
tb->x + x_adj,
tb->y + y_adj,
tb->width + width_adj,
tb->height + height_adj);
/* Draw the outline. */
if (shadow_thickness)
gtk_output_shadows (f, tb->x + x_adj, tb->y + y_adj,
tb->width + width_adj, tb->height + height_adj,
shadow_thickness);
/* Do the border. */
gdk_draw_rectangle (x_win, background_gc, TRUE, tb->x, tb->y,
(vertical ? border_width : tb->width),
(vertical ? tb->height : border_width));
gdk_draw_rectangle (x_win, background_gc, TRUE,
(vertical ? tb->x + tb->width - border_width : tb->x),
(vertical ? tb->y : tb->y + tb->height - border_width),
(vertical ? border_width : tb->width),
(vertical ? tb->height : border_width));
background_gc = get_toolbar_gc (f);
/* #### It is currently possible for users to trash us by directly
changing the toolbar glyphs. Avoid crashing in that case. */
if (GLYPHP (glyph))
instance = glyph_image_instance (glyph, window, ERROR_ME_NOT, 1);
else
instance = Qnil;
if (IMAGE_INSTANCEP (instance))
{
int width = tb->width + width_adj - shadow_thickness * 2;
int height = tb->height + height_adj - shadow_thickness * 2;
int x_offset = x_adj + shadow_thickness;
int y_offset = y_adj + shadow_thickness;
p = XIMAGE_INSTANCE (instance);
if (IMAGE_INSTANCE_PIXMAP_TYPE_P (p))
{
if (width > (int) IMAGE_INSTANCE_PIXMAP_WIDTH (p))
{
x_offset += ((int) (width - IMAGE_INSTANCE_PIXMAP_WIDTH (p))
/ 2);
width = IMAGE_INSTANCE_PIXMAP_WIDTH (p);
}
if (height > (int) IMAGE_INSTANCE_PIXMAP_HEIGHT (p))
{
y_offset += ((int) (height - IMAGE_INSTANCE_PIXMAP_HEIGHT (p))
/ 2);
height = IMAGE_INSTANCE_PIXMAP_HEIGHT (p);
}
gtk_output_gdk_pixmap (f, XIMAGE_INSTANCE (instance), tb->x + x_offset,
tb->y + y_offset, 0, 0, 0, 0, width, height,
0, 0, 0, background_gc);
}
else if (IMAGE_INSTANCE_TYPE (p) == IMAGE_TEXT)
{
/* #### We need to make the face used configurable. */
struct face_cachel *cachel =
WINDOW_FACE_CACHEL (w, DEFAULT_INDEX);
struct display_line dl;
Lisp_Object string = IMAGE_INSTANCE_TEXT_STRING (p);
unsigned char charsets[NUM_LEADING_BYTES];
Emchar_dynarr *buf;
struct font_metric_info fm;
/* This could be true if we were called via the Expose event
handler. Mark the button as dirty and return
immediately. */
if (f->window_face_cache_reset)
{
tb->dirty = 1;
MARK_TOOLBAR_CHANGED;
return;
}
buf = Dynarr_new (Emchar);
convert_bufbyte_string_into_emchar_dynarr
(XSTRING_DATA (string), XSTRING_LENGTH (string), buf);
find_charsets_in_emchar_string (charsets, Dynarr_atp (buf, 0),
Dynarr_length (buf));
ensure_face_cachel_complete (cachel, window, charsets);
face_cachel_charset_font_metric_info (cachel, charsets, &fm);
dl.ascent = fm.ascent;
dl.descent = fm.descent;
dl.ypos = tb->y + y_offset + fm.ascent;
if (fm.ascent + fm.descent <= height)
{
dl.ypos += (height - fm.ascent - fm.descent) / 2;
dl.clip = 0;
}
else
{
dl.clip = fm.ascent + fm.descent - height;
}
gtk_output_string (w, &dl, buf, tb->x + x_offset, 0, 0, width,
DEFAULT_INDEX, 0, 0, 0, 0);
Dynarr_free (buf);
}
/* We silently ignore the image if it isn't a pixmap or text. */
}
tb->dirty = 0;
}
static void
mswindows_format_file (WIN32_FIND_DATA *file, char *buf, int display_size,
int add_newline)
{
char *cptr;
int len;
Lisp_Object luser;
double file_size;
len = strlen(file->cFileName);
file_size =
file->nFileSizeHigh * (double)UINT_MAX + file->nFileSizeLow;
cptr = buf;
#if INDENT_LISTING
*cptr++ = ' ';
*cptr++ = ' ';
#endif
if (display_size)
{
sprintf(cptr, "%6d ", (int)((file_size + 1023.) / 1024.));
cptr += 7;
}
if (file->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
*cptr++ = 'd';
} else {
*cptr++ = '-';
}
cptr[0] = cptr[3] = cptr[6] = 'r';
if (file->dwFileAttributes & FILE_ATTRIBUTE_READONLY)
{
cptr[1] = cptr[4] = cptr[7] = '-';
} else {
cptr[1] = cptr[4] = cptr[7] = 'w';
}
if ((file->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
(len > 4 &&
(_stricmp(&file->cFileName[len - 4], ".exe") == 0
|| _stricmp(&file->cFileName[len - 4], ".com") == 0
|| _stricmp(&file->cFileName[len - 4], ".bat") == 0
#if 0
|| _stricmp(&file->cFileName[len - 4], ".pif") == 0
#endif
)))
{
cptr[2] = cptr[5] = cptr[8] = 'x';
} else {
cptr[2] = cptr[5] = cptr[8] = '-';
}
cptr += 9;
if (file->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
strcpy(cptr, " 2 ");
} else {
strcpy(cptr, " 1 ");
}
cptr += 5;
luser = Fuser_login_name(Qnil);
if (!STRINGP(luser))
{
sprintf(cptr, "%-9d", 0);
} else {
char *str;
str = XSTRING_DATA(luser);
sprintf(cptr, "%-8s ", str);
}
while (*cptr)
{
++cptr;
}
sprintf(cptr, "%-8d ", getgid());
cptr += 9;
if (file_size > 99999999.0)
{
file_size = (file_size + 1023.0) / 1024.;
if (file_size > 999999.0)
{
sprintf(cptr, "%6.0fMB ", (file_size + 1023.0) / 1024.);
} else {
sprintf(cptr, "%6.0fKB ", file_size);
}
} else {
sprintf(cptr, "%8.0f ", file_size);
}
while (*cptr)
{
++cptr;
}
{
time_t t, now;
char *ctimebuf;
extern char *sys_ctime(const time_t *t); /* in nt.c */
if (
#if 0
/*
* This doesn't work.
* This code should be correct ...
*/
FileTimeToLocalFileTime(&file->ftLastWriteTime, &localtime) &&
((t = convert_time(localtime)) != 0) &&
#else
/*
* But this code "works" ...
*/
((t = convert_time(file->ftLastWriteTime)) != 0) &&
#endif
((ctimebuf = sys_ctime(&t)) != NULL))
{
memcpy(cptr, &ctimebuf[4], 7);
now = time(NULL);
if (now - t > (365. / 2.0) * 86400.)
{
/* more than 6 months */
cptr[7] = ' ';
memcpy(&cptr[8], &ctimebuf[20], 4);
} else {
/* less than 6 months */
memcpy(&cptr[7], &ctimebuf[11], 5);
}
cptr += 12;
*cptr++ = ' ';
}
}
if (add_newline)
{
sprintf(cptr, "%s\n", file->cFileName);
}
else
{
strcpy(cptr, file->cFileName);
}
}
