the detecting source. Then code detectors can handle the tailing
byte sequence more accurately.
- Fix me: This is not an perfect solution. It is better that we
+ Fix me: This is not a perfect solution. It is better that we
add one more argument, say LAST_BLOCK, to all detect_coding_XXX.
*/
if (to == Z || (to == GPT && GAP_SIZE > 0))
{
int len;
int c = STRING_CHAR_AND_LENGTH (p, MAX_MULTIBYTE_LENGTH, len);
-
+
if (c >= 128
&& (CHAR_TABLE_P (safe_chars)
? NILP (CHAR_TABLE_REF (safe_chars, c))
Lisp_Object Vsystem_time_locale;
Lisp_Object Vprevious_system_time_locale;
-/* If non-zero, emacs should not attempt to use an window-specific code,
+/* If non-zero, emacs should not attempt to use a window-specific code,
but instead should use the virtual terminal under which it was started. */
int inhibit_window_system;
/* Assuming that a right child exists, perform the following operation:
- A B
- / \ / \
+ A B
+ / \ / \
B => A
- / \ / \
+ / \ / \
c c
*/
new->total_length = new_length + new->right->total_length;
balance_an_interval (new);
}
-
+
balance_possible_root_interval (interval);
return new;
new->total_length = new_length + new->left->total_length;
balance_an_interval (new);
}
-
+
balance_possible_root_interval (interval);
return new;
if (NULL_INTERVAL_P (i))
return NULL_INTERVAL;
- while (1)
+ while (1)
{
- if (pos < i->position)
+ if (pos < i->position)
{
/* Move left. */
- if (pos >= i->position - TOTAL_LENGTH (i->left))
+ if (pos >= i->position - TOTAL_LENGTH (i->left))
{
i->left->position = i->position - TOTAL_LENGTH (i->left)
+ LEFT_TOTAL_LENGTH (i->left);
i = i->left; /* Move to the left child */
}
- else if (NULL_PARENT (i))
+ else if (NULL_PARENT (i))
error ("Point before start of properties");
- else
+ else
i = INTERVAL_PARENT (i);
continue;
}
else if (pos >= INTERVAL_LAST_POS (i))
{
/* Move right. */
- if (pos < INTERVAL_LAST_POS (i) + TOTAL_LENGTH (i->right))
+ if (pos < INTERVAL_LAST_POS (i) + TOTAL_LENGTH (i->right))
{
i->right->position = INTERVAL_LAST_POS (i) +
LEFT_TOTAL_LENGTH (i->right);
i = i->right; /* Move to the right child */
}
- else if (NULL_PARENT (i))
+ else if (NULL_PARENT (i))
error ("Point after end of properties");
- else
+ else
i = INTERVAL_PARENT (i);
continue;
}
- else
+ else
return i;
}
}
int eobp = 0;
Lisp_Object parent;
int offset;
-
+
if (TOTAL_LENGTH (tree) == 0) /* Paranoia */
abort ();
temp->total_length += length;
temp = balance_possible_root_interval (temp);
}
-
+
/* If at least one interval has sticky properties,
we check the stickiness property by property.
temp = balance_possible_root_interval (temp);
}
}
-
+
return tree;
}
cat = textget (props, Qcategory);
if (! NILP (front)
- &&
+ &&
/* If we have inherited a front-stick category property that is t,
we don't need to set up a detailed one. */
! (! NILP (cat) && SYMBOLP (cat)
}
\f
-/* Delete an node I from its interval tree by merging its subtrees
+/* Delete a node I from its interval tree by merging its subtrees
into one subtree which is then returned. Caller is responsible for
storing the resulting subtree into its parent. */
else
{
/* How much can we delete from this interval? */
- int my_amount = ((tree->total_length
+ int my_amount = ((tree->total_length
- RIGHT_TOTAL_LENGTH (tree))
- relative_position);
tree->total_length -= amount;
if (LENGTH (tree) == 0)
delete_interval (tree);
-
+
return amount;
}
The properties of under are the result of
adjust_intervals_for_insertion, so stickiness has
already been taken care of. */
-
+
while (! NULL_INTERVAL_P (over))
{
if (LENGTH (over) < LENGTH (under))
/* Get the value of property PROP from PLIST,
which is the plist of an interval.
- We check for direct properties, for categories with property PROP,
+ We check for direct properties, for categories with property PROP,
and for PROP appearing on the default-text-properties list. */
Lisp_Object
BUF_PT (buffer) = charpos;
}
-/* Set point in BUFFER to CHARPOS. If the target position is
+/* Set point in BUFFER to CHARPOS. If the target position is
before an intangible character, move to an ok place. */
void
TEST_OFFS should be either 0 or -1, and ADJ should be either 1 or -1.
Note that `stickiness' is determined by overlay marker insertion types,
- if the invisible property comes from an overlay. */
+ if the invisible property comes from an overlay. */
static int
adjust_for_invis_intang (pos, test_offs, adj, test_intang)
}
/* Set point in BUFFER to CHARPOS, which corresponds to byte
- position BYTEPOS. If the target position is
+ position BYTEPOS. If the target position is
before an intangible character, move to an ok place. */
void
}
- /* If the whole stretch between PT and POSITION isn't intangible,
+ /* If the whole stretch between PT and POSITION isn't intangible,
try moving to POSITION (which means we actually move farther
if POSITION is inside of intangible text). */
*start = i->position;
next = next_interval (i);
- while (! NULL_INTERVAL_P (next)
+ while (! NULL_INTERVAL_P (next)
&& EQ (*val, textget (next->plist, prop)))
i = next, next = next_interval (next);
*end = i->position + LENGTH (i);
int l2 = strlen (s2);
char *p = s1 + l1;
int i;
-
+
strncat (s1, s2, n);
for (i = 0; i < l2; i++)
{
/* Convert a Mac pathname to Posix form. A Mac full pathname is one
that does not begin with a ':' and contains at least one ':'. A Mac
- full pathname causes an '/' to be prepended to the Posix pathname.
+ full pathname causes a '/' to be prepended to the Posix pathname.
The algorithm for the rest of the pathname is as follows:
For each segment between two ':',
if it is non-null, copy as is and then add a '/' at the end,
otherwise, insert a "../" into the Posix pathname.
Returns 1 if successful; 0 if fails. */
-
+
int
mac_to_posix_pathname (const char *mfn, char *ufn, int ufnbuflen)
{
const char *p, *q, *pe;
-
+
strcpy (ufn, "");
-
+
if (*mfn == '\0')
return 1;
-
+
p = strchr (mfn, ':');
if (p != 0 && p != mfn) /* full pathname */
strcat (ufn, "/");
-
+
p = mfn;
if (*p == ':')
p++;
p = pe;
}
}
-
+
return 1;
}
/* Convert a Posix pathname to Mac form. Approximately reverse of the
above in algorithm. */
-
+
int
posix_to_mac_pathname (const char *ufn, char *mfn, int mfnbuflen)
{
const char *p, *q, *pe;
char expanded_pathname[MAXPATHLEN+1];
-
+
strcpy (mfn, "");
-
+
if (*ufn == '\0')
return 1;
p = ufn;
-
+
/* Check for and handle volume names. Last comparison: strangely
somewhere "/.emacs" is passed. A temporary fix for now. */
if (*p == '/' && strchr (p+1, '/') == NULL && strcmp (p, "/.emacs") != 0)
strcat (expanded_pathname, p);
p = expanded_pathname;
/* now p points to the pathname with emacs dir prefix */
- }
+ }
else if (*p != '/') /* relative pathname */
strcat (mfn, ":");
-
+
if (*p == '/')
p++;
p = pe;
}
}
-
+
return 1;
}
cipb.hFileInfo.ioDirID = 0;
cipb.hFileInfo.ioFDirIndex = 0;
/* set to 0 to get information about specific dir or file */
-
+
errno = PBGetCatInfo (&cipb, false);
if (errno == -43) /* -43: fnfErr defined in Errors.h */
errno = ENOENT;
if (cipb.hFileInfo.ioFlAttrib & 0x10) /* bit 4 = 1 for directories */
{
buf->st_mode = S_IFDIR | S_IREAD | S_IEXEC;
-
+
if (!(cipb.hFileInfo.ioFlAttrib & 0x1))
buf->st_mode |= S_IWRITE; /* bit 1 = 1 for locked files/directories */
buf->st_ino = cipb.dirInfo.ioDrDirID;
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
-
+
return stat_noalias (true_pathname, buf);
}
stat (const char *path, struct stat *sb)
{
int result;
- char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
+ char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
-
+
if ((result = stat_noalias (path, sb)) >= 0 &&
! (sb->st_mode & S_IFLNK))
return result;
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
-
+
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
{
HFileParam hfpb;
char true_pathname[MAXPATHLEN+1], mac_pathname[MAXPATHLEN+1];
-
+
if (find_true_pathname (dirname, true_pathname, MAXPATHLEN+1) == -1)
return -1;
-
+
if (posix_to_mac_pathname (true_pathname, mac_pathname, MAXPATHLEN+1) == 0)
return -1;
hfpb.ioNamePtr = mac_pathname;
hfpb.ioVRefNum = 0; /* ignored unless name is invalid */
hfpb.ioDirID = 0; /* parent is the root */
-
+
errno = PBDirCreate ((HParmBlkPtr) &hfpb, false);
/* just return the Mac OSErr code for now */
return errno == noErr ? 0 : -1;
{
HFileParam hfpb;
char mac_pathname[MAXPATHLEN+1];
-
+
if (posix_to_mac_pathname (dirname, mac_pathname, MAXPATHLEN+1) == 0)
return -1;
hfpb.ioNamePtr = mac_pathname;
hfpb.ioVRefNum = 0; /* ignored unless name is invalid */
hfpb.ioDirID = 0; /* parent is the root */
-
+
errno = PBHDelete ((HParmBlkPtr) &hfpb, false);
return errno == noErr ? 0 : -1;
}
int
utime (const char *path, const struct utimbuf *times)
{
- char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
+ char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
CInfoPBRec cipb;
-
+
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
-
+
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
cipb.hFileInfo.ioNamePtr = mac_pathname;
cipb.hFileInfo.ioVRefNum = 0;
cipb.hFileInfo.ioDirID = 0;
- cipb.hFileInfo.ioFDirIndex = 0;
+ cipb.hFileInfo.ioFDirIndex = 0;
/* set to 0 to get information about specific dir or file */
-
+
errno = PBGetCatInfo (&cipb, false);
if (errno != noErr)
return -1;
int
access (const char *path, int mode)
{
- char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
+ char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
CInfoPBRec cipb;
-
+
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
-
+
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
cipb.hFileInfo.ioDirID = 0;
cipb.hFileInfo.ioFDirIndex = 0;
/* set to 0 to get information about specific dir or file */
-
+
errno = PBGetCatInfo (&cipb, false);
if (errno != noErr)
return -1;
int
sys_open (const char *path, int oflag)
{
- char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
+ char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
-
+
if (strcmp (path, "/dev/null") == 0)
return DEV_NULL_FD; /* some bogus fd to be ignored in write */
-
+
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
-
+
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
int
sys_creat (const char *path, mode_t mode)
{
- char true_pathname[MAXPATHLEN+1];
+ char true_pathname[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
-
+
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
int
sys_unlink (const char *path)
{
- char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
+ char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
-
+
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
-
+
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
sys_rename (const char * old_name, const char * new_name)
{
char true_old_pathname[MAXPATHLEN+1], true_new_pathname[MAXPATHLEN+1];
- char fully_resolved_old_name[MAXPATHLEN+1];
+ char fully_resolved_old_name[MAXPATHLEN+1];
int len;
char mac_old_name[MAXPATHLEN+1], mac_new_name[MAXPATHLEN+1];
-
+
if (find_true_pathname (old_name, true_old_pathname, MAXPATHLEN+1) == -1)
return -1;
-
+
len = readlink (true_old_pathname, fully_resolved_old_name, MAXPATHLEN);
if (len > -1)
fully_resolved_old_name[len] = '\0';
if (find_true_pathname (new_name, true_new_pathname, MAXPATHLEN+1) == -1)
return -1;
-
+
if (strcmp (fully_resolved_old_name, true_new_pathname) == 0)
return 0;
mac_old_name,
MAXPATHLEN+1))
return -1;
-
+
if (!posix_to_mac_pathname(true_new_pathname, mac_new_name, MAXPATHLEN+1))
return -1;
file in Unix. CW version fails in these situation. So we add a
call to unlink here. */
(void) unlink (mac_new_name);
-
+
return rename (mac_old_name, mac_new_name);
}
FILE *
sys_fopen (const char *name, const char *mode)
{
- char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
+ char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
-
+
if (find_true_pathname (name, true_pathname, MAXPATHLEN+1) == -1)
return 0;
-
+
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
EMACS_GET_TIME (end_time);
EMACS_ADD_TIME (end_time, end_time, *timeout);
-
+
do
{
/* Also return true if an event other than a keyDown has
{
Point mouse_pos;
static Point old_mouse_pos = {-1, -1};
-
+
GetMouse (&mouse_pos);
if (!EqualPt (mouse_pos, old_mouse_pos))
{
return 1;
}
}
-
+
WaitNextEvent (0, &e, 1UL, NULL); /* Accept no event; wait 1
tic. by T.I. */
-
+
EMACS_GET_TIME (now);
EMACS_SUB_TIME (now, end_time, now);
}
{
EventRecord e;
unsigned long tick;
-
+
if (!target_ticks) /* no alarm pending */
return -1;
if ((tick = TickCount ()) < target_ticks)
WaitNextEvent (0, &e, target_ticks - tick, NULL); /* Accept no event;
just wait. by T.I. */
-
+
target_ticks = 0;
if (alarm_signal_func)
(*alarm_signal_func)(SIGALRM);
-
+
return 0;
}
alarm (int seconds)
{
long remaining = target_ticks ? (TickCount () - target_ticks) / 60 : 0;
-
+
target_ticks = seconds ? TickCount () + 60 * seconds : 0;
-
+
return (remaining < 0) ? 0 : (unsigned int) remaining;
}
else
{
#ifdef __MRC__
- __sigfun old_signal_func;
+ __sigfun old_signal_func;
#elif __MWERKS__
- __signal_func_ptr old_signal_func;
+ __signal_func_ptr old_signal_func;
#else
You lose!!!
#endif
/* Get time since boot */
Microseconds (&uw_microseconds);
-
+
/* Convert to time since midnight*/
w_microseconds.hi = uw_microseconds.hi;
w_microseconds.lo = uw_microseconds.lo;
sys_gmtime (const time_t *timer)
{
time_t unix_time = *timer + CW_OR_MPW_UNIX_EPOCH_DIFF;
-
+
return gmtime (&unix_time);
}
#else
time_t unix_time = *timer + CW_OR_MPW_UNIX_EPOCH_DIFF;
#endif
-
+
return localtime (&unix_time);
}
#else
time_t unix_time = *timer + CW_OR_MPW_UNIX_EPOCH_DIFF;
#endif
-
+
return ctime (&unix_time);
}
if (timer)
*timer = mac_time;
-
+
return mac_time;
}
{
int len, k;
static seqnum = 0;
-
+
len = strlen (template);
k = len - 1;
while (k >= 0 && template[k] == 'X')
k--;
-
+
k++; /* make k index of first 'X' */
-
+
if (k < len)
{
/* Zero filled, number of digits equal to the number of X's. */
sprintf (&template[k], "%0*d", len-k, seqnum++);
-
+
return template;
}
else
- return 0;
+ return 0;
}
static char my_passwd_name[PASSWD_FIELD_SIZE];
static char my_passwd_dir[MAXPATHLEN+1];
-static struct passwd my_passwd =
+static struct passwd my_passwd =
{
my_passwd_name,
my_passwd_dir,
}
}
}
-
+
if (!found)
{
/* Setting to "/" probably won't work but set it to something
}
-static struct passwd emacs_passwd =
+static struct passwd emacs_passwd =
{
"emacs",
emacs_passwd_dir,
getpwuid (uid_t uid)
{
if (!my_passwd_inited)
- {
+ {
init_my_passwd ();
my_passwd_inited = 1;
}
-
+
return &my_passwd;
}
return &emacs_passwd;
if (!my_passwd_inited)
- {
+ {
init_my_passwd ();
my_passwd_inited = 1;
}
-
+
return &my_passwd;
}
sigblock (int mask)
{
return 0;
-}
+}
void
err = PBGetCatInfo (&cipb, false);
if (err != noErr)
return 0;
-
+
p2cstr (dir_name);
if (strlen (dir_name) + strlen (path) + 1 >= man_path_len)
return 0;
}
while (cipb.dirInfo.ioDrDirID != fsRtDirID);
/* stop when we see the volume's root directory */
-
+
return 1; /* success */
}
return -1;
buf[0] = '\0';
-
+
p = path;
if (*p == '/')
q = strchr (p + 1, '/');
p = q + 1;
q = strchr(p, '/');
}
-
+
if (len + strlen (p) + 1 >= bufsiz)
return -1;
-
+
strcat (buf, p);
return len + strlen (p);
}
dup2 (int oldd, int newd)
{
int fd, ret;
-
+
close (newd);
fd = dup (oldd);
CInfoPBRec cpb;
char unix_dir_name[MAXPATHLEN+1];
DIR *dir;
-
+
/* Cache directory name with pointer temp_dir_name.
Look for it only the first time. */
if (!temp_dir_name)
&vol_ref_num, &dir_id);
if (err != noErr)
return NULL;
-
+
if (!path_from_vol_dir_name (full_path, 255, vol_ref_num, dir_id, "\p"))
return NULL;
if (strlen (full_path) + 6 <= MAXPATHLEN)
strcat (full_path, "Emacs:");
- else
+ else
return NULL;
if (!mac_to_posix_pathname (full_path, unix_dir_name, MAXPATHLEN+1))
return NULL;
-
+
dir = opendir (unix_dir_name); /* check whether temp directory exists */
if (dir)
closedir (dir);
/* Allocate and construct an array of pointers to strings from a list
of strings stored in a 'STR#' resource. The returned pointer array
is stored in the style of argv and environ: if the 'STR#' resource
- contains numString strings, an pointer array with numString+1
+ contains numString strings, a pointer array with numString+1
elements is returned in which the last entry contains a null
pointer. The pointer to the pointer array is passed by pointer in
parameter t. The resource ID of the 'STR#' resource is passed in
CInfoPBRec cpb;
static char system_folder_unix_name[MAXPATHLEN+1];
DIR *dir;
-
+
err = FindFolder (kOnSystemDisk, kSystemFolderType, kDontCreateFolder,
&vol_ref_num, &dir_id);
if (err != noErr)
return NULL;
-
+
if (!path_from_vol_dir_name (full_path, 255, vol_ref_num, dir_id, "\p"))
return NULL;
if (!mac_to_posix_pathname (full_path, system_folder_unix_name,
MAXPATHLEN+1))
return NULL;
-
+
return system_folder_unix_name;
}
init_environ ()
{
int i;
-
+
get_string_list (&environ, ENVIRON_STRING_LIST_ID);
i = 0;
char *
mystrtok (char *s)
-{
+{
while (*s)
s++;
RgnHandle cursor_region_handle;
TargetID targ;
unsigned long ref_con, len;
-
+
if (posix_to_mac_pathname (workdir, macworkdir, MAXPATHLEN+1) == 0)
return -1;
if (posix_to_mac_pathname (infn, macinfn, MAXPATHLEN+1) == 0)
return -1;
if (posix_to_mac_pathname (errfn, macerrfn, MAXPATHLEN+1) == 0)
return -1;
-
+
paramlen = strlen (macworkdir) + strlen (macinfn) + strlen (macoutfn)
+ strlen (macerrfn) + 4; /* count nulls at end of strings */
&& argc == 3 && strcmp (argv[1], "-c") == 0)
{
char *command, *t, tempmacpathname[MAXPATHLEN+1];
-
+
/* The arguments for the command in argv[2] are separated by
spaces. Count them and put the count in newargc. */
command = (char *) alloca (strlen (argv[2])+2);
strcpy (command, argv[2]);
if (command[strlen (command) - 1] != ' ')
strcat (command, " ");
-
+
t = command;
newargc = 0;
t = mystrchr (t, ' ');
newargc++;
t = mystrchr (t+1, ' ');
}
-
+
newargv = (char **) alloca (sizeof (char *) * newargc);
-
+
t = command;
for (j = 0; j < newargc; j++)
{
t = mystrtok (t);
paramlen += strlen (newargv[j]) + 1;
}
-
+
if (strncmp (newargv[0], "~emacs/", 7) == 0)
{
if (posix_to_mac_pathname (newargv[0], tempmacpathname, MAXPATHLEN+1)
strcpy (macappname, tempmacpathname);
}
else
- {
+ {
if (posix_to_mac_pathname (argv[0], macappname, MAXPATHLEN+1) == 0)
return -1;
newargv = (char **) alloca (sizeof (char *) * argc);
- newargc = argc;
+ newargc = argc;
for (j = 1; j < argc; j++)
{
if (strncmp (argv[j], "~emacs/", 7) == 0)
}
}
else
- newargv[j] = argv[j];
+ newargv[j] = argv[j];
paramlen += strlen (newargv[j]) + 1;
}
}
/* null terminate strings sent so it's possible to use strcpy over there */
strcpy (p, macinfn);
p += strlen (macinfn);
- *p++ = '\0';
+ *p++ = '\0';
strcpy (p, macoutfn);
p += strlen (macoutfn);
- *p++ = '\0';
+ *p++ = '\0';
strcpy (p, macerrfn);
p += strlen (macerrfn);
- *p++ = '\0';
+ *p++ = '\0';
for (j = 1; j < newargc; j++)
{
strcpy (p, newargv[j]);
p += strlen (newargv[j]);
- *p++ = '\0';
+ *p++ = '\0';
}
-
+
c2pstr (macappname);
-
+
iErr = FSMakeFSSpec (0, 0, macappname, &spec);
-
+
if (iErr != noErr)
{
free (param);
}
cursor_region_handle = NewRgn ();
-
+
/* Wait for the subprocess to finish, when it will send us a ERPY
high level event. */
while (1)
cursor_region_handle)
&& reply_event.message == kEmacsSubprocessReply)
break;
-
+
/* The return code is sent through the refCon */
iErr = AcceptHighLevelEvent (&targ, &ref_con, NULL, &len);
if (iErr != noErr)
free (param);
return -1;
}
-
+
DisposeHandle ((Handle) cursor_region_handle);
free (param);
DIR *
opendir (const char *dirname)
{
- char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
+ char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
char mac_pathname[MAXPATHLEN+1], vol_name[MAXPATHLEN+1];
DIR *dirp;
CInfoPBRec cipb;
HVolumeParam vpb;
int len, vol_name_len;
-
+
if (find_true_pathname (dirname, true_pathname, MAXPATHLEN+1) == -1)
return 0;
-
+
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
len = strlen (mac_pathname);
if (mac_pathname[len - 1] != ':' && len < MAXPATHLEN)
strcat (mac_pathname, ":");
-
+
/* Extract volume name */
vol_name_len = strchr (mac_pathname, ':') - mac_pathname;
strncpy (vol_name, mac_pathname, vol_name_len);
cipb.hFileInfo.ioDirID = 0;
cipb.hFileInfo.ioFDirIndex = 0;
/* set to 0 to get information about specific dir or file */
-
+
errno = PBGetCatInfo (&cipb, false);
if (errno != noErr)
{
}
dirp->vol_ref_num = vpb.ioVRefNum;
-
+
return dirp;
}
hpblock.volumeParam.ioNamePtr = s_name;
hpblock.volumeParam.ioVRefNum = 0;
hpblock.volumeParam.ioVolIndex = dp->current_index;
-
+
errno = PBHGetVInfo (&hpblock, false);
if (errno != noErr)
{
errno = ENOENT;
return 0;
}
-
+
p2cstr (s_name);
strcat (s_name, "/"); /* need "/" for stat to work correctly */
s_dirent.d_ino = hpblock.volumeParam.ioVRefNum;
s_dirent.d_name = s_name;
-
+
return &s_dirent;
}
else
cipb.hFileInfo.ioDirID = dp->dir_id;
/* directory ID found by opendir */
cipb.hFileInfo.ioFDirIndex = dp->current_index;
-
+
errno = PBGetCatInfo (&cipb, false);
if (errno != noErr)
{
errno = ENOENT;
return 0;
}
-
- /* insist on an visibile entry */
+
+ /* insist on a visible entry */
if (cipb.hFileInfo.ioFlAttrib & 0x10) /* directory? */
done = !(cipb.dirInfo.ioDrUsrWds.frFlags & fInvisible);
else
done = !(cipb.hFileInfo.ioFlFndrInfo.fdFlags & fInvisible);
-
+
dp->current_index++;
}
p2cstr (s_name);
-
+
p = s_name;
while (*p)
{
s_dirent.d_ino = cipb.dirInfo.ioDrDirID;
/* value unimportant: non-zero for valid file */
s_dirent.d_name = s_name;
-
+
return &s_dirent;
}
}
{
AEDesc null_desc;
OSAError osaerror;
-
+
/* if open fails, as_scripting_component is set to NULL. Its
subsequent use in OSA calls will fail with badComponentInstance
error. */
long status;
CHECK_STRING (script);
-
+
status = do_applescript (SDATA (script), &result);
if (status)
{
char posix_filename[MAXPATHLEN+1];
CHECK_STRING (mac_filename);
-
+
if (mac_to_posix_pathname (SDATA (mac_filename), posix_filename,
MAXPATHLEN))
return build_string (posix_filename);
char mac_filename[MAXPATHLEN+1];
CHECK_STRING (posix_filename);
-
+
if (posix_to_mac_pathname (SDATA (posix_filename), mac_filename,
MAXPATHLEN))
return build_string (mac_filename);
if (GetScrapFlavorData (scrap, kScrapFlavorTypeText, &s, data) != noErr
|| s == 0)
return Qnil;
-
+
/* Emacs expects clipboard contents have Unix-style eol's */
for (i = 0; i < s; i++)
if (data[i] == '\r')
value = make_string (*my_handle, rc);
HUnlock (my_handle);
-
+
DisposeHandle (my_handle);
return value;
/* fixme: ignore the push flag for now */
CHECK_STRING (value);
-
+
len = SCHARS (value);
buf = (char *) alloca (len+1);
bcopy (SDATA (value), buf, len);
buf[len] = '\0';
-
+
/* convert to Mac-style eol's before sending to clipboard */
for (i = 0; i < len; i++)
if (buf[i] == '\n')
ZeroScrap ();
PutScrap (len, 'TEXT', buf);
#endif /* not TARGET_API_MAC_CARBON */
-
+
return Qnil;
}
{
QCLIPBOARD = intern ("CLIPBOARD");
staticpro (&QCLIPBOARD);
-
+
defsubr (&Smac_paste_function);
defsubr (&Smac_cut_function);
defsubr (&Sx_selection_exists_p);
return f;
}
-/* Let the user specify an display with a frame.
+/* Let the user specify a display with a frame.
nil stands for the selected frame--or, if that is not a mac frame,
the first display on the list. */
}
}
\f
-/* Return the Emacs frame-object corresponding to an mac window.
+/* Return the Emacs frame-object corresponding to a mac window.
It could be the frame's main window or an icon window. */
/* This function can be called during GC, so use GC_xxx type test macros. */
if (value < 0.0 || value > 1.0)
break;
val = (unsigned long)(0x100 * value);
- /* We used 0x100 instead of 0xFF to give an continuous
+ /* We used 0x100 instead of 0xFF to give a continuous
range between 0.0 and 1.0 inclusive. The next statement
fixes the 1.0 case. */
if (val == 0x100)
/* Set the border-color of frame F to pixel value PIX.
Note that this does not fully take effect if done before
- F has an window. */
+ F has a window. */
void
x_set_border_pixel (f, pix)
struct frame *f;
XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
}
\f
-/* Subroutines of creating an frame. */
+/* Subroutines of creating a frame. */
/* Make sure that Vx_resource_name is set to a reasonable value.
Fix it up, or set it to `emacs' if it is too hopeless. */
f->height = 0;
SET_FRAME_WIDTH (f, 0);
change_frame_size (f, height, width, 1, 0, 0);
-
+
/* Add `tooltip' frame parameter's default value. */
if (NILP (Fframe_parameter (frame, intern ("tooltip"))))
Fmodify_frame_parameters (frame, Fcons (Fcons (intern ("tooltip"), Qt),
if (invalidate)
invalidate = !EQ (tmp_table, gl_state.old_prop); /* Need to invalidate? */
-
+
if (invalidate) /* Did not get to adjacent interval. */
{ /* with the same table => */
/* invalidate the old range. */
if (EQ (Fsyntax_table_p (tmp_table), Qt))
{
gl_state.use_global = 0;
- }
+ }
else if (CONSP (tmp_table))
{
gl_state.use_global = 1;
gl_state.global_code = tmp_table;
}
- else
+ else
{
gl_state.use_global = 0;
gl_state.current_syntax_table = current_buffer->syntax_table;
}
return;
}
- else if (cnt == INTERVALS_AT_ONCE)
+ else if (cnt == INTERVALS_AT_ONCE)
{
if (count > 0)
{
* int pos, pos_byte;
* {
* int c, val;
- *
+ *
* DEC_BOTH (pos, pos_byte);
* UPDATE_SYNTAX_TABLE_BACKWARD (pos);
* c = FETCH_CHAR (pos_byte);
int string_style = -1; /* Presumed outside of any string. */
int string_lossage = 0;
/* Not a real lossage: indicates that we have passed a matching comment
- starter plus an non-matching comment-ender, meaning that any matching
+ starter plus a non-matching comment-ender, meaning that any matching
comment-starter we might see later could be a false positive (hidden
inside another comment).
Test case: { a (* b } c (* d *) */
There's no way to grok this scanning backwards. */
string_lossage = 1;
break;
-
+
case Scomment:
/* We've already checked that it is the relevant comstyle. */
if (string_style != -1 || comment_lossage || string_lossage)
from_byte = CHAR_TO_BYTE (from);
UPDATE_SYNTAX_TABLE_FORWARD (from - 1);
}
-
+
done:
*charpos_ptr = from;
*bytepos_ptr = from_byte;
if (!(CHAR_TABLE_P (obj)
&& EQ (XCHAR_TABLE (obj)->purpose, Qsyntax_table)))
wrong_type_argument (Qsyntax_table_p, obj);
-}
+}
DEFUN ("syntax-table", Fsyntax_table, Ssyntax_table, 0, 0, 0,
doc: /* Return the current syntax table.
val |= 1 << 22;
break;
}
-
+
if (val < XVECTOR (Vsyntax_code_object)->size && NILP (match))
return XVECTOR (Vsyntax_code_object)->contents[val];
else
/* I really don't know why this is interactive
help-form should at least be made useful whilst reading the second arg. */
-DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3,
+DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3,
"cSet syntax for character: \nsSet syntax for %s to: ",
doc: /* Set syntax for character CHAR according to string NEWENTRY.
The syntax is changed only for table SYNTAX_TABLE, which defaults to
/* Avoid jumping out of an input field. */
val = XFASTINT (Fconstrain_to_field (make_number (val), make_number (PT),
Qt, Qnil, Qnil));
-
+
SET_PT (val);
return val == orig_val ? Qt : Qnil;
}
nesting++;
INC_BOTH (from, from_byte);
UPDATE_SYNTAX_TABLE_FORWARD (from);
-
+
forw_incomment:
if (from < stop && SYNTAX_FLAGS_COMEND_FIRST (syntax)
&& SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style
&& (c1 = FETCH_CHAR (from_byte),
SYNTAX_COMSTART_SECOND (c1)))
{
- /* We have encountered a comment start sequence and we
+ /* We have encountered a comment start sequence and we
are ignoring all text inside comments. We must record
the comment style this sequence begins so that later,
only a comment end of the same style actually ends
{
/* Skip until first preceding unquoted comment_fence. */
int found = 0, ini = from, ini_byte = from_byte;
-
+
while (1)
{
DEC_BOTH (from, from_byte);
UPDATE_SYNTAX_TABLE_BACKWARD (from);
c = FETCH_CHAR (from_byte);
if (SYNTAX (c) == Scomment_fence
- && !char_quoted (from, from_byte))
+ && !char_quoted (from, from_byte))
{
- found = 1;
+ found = 1;
break;
}
}
&& SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte))
&& parse_sexp_ignore_comments)
{
- /* we have encountered a comment start sequence and we
+ /* we have encountered a comment start sequence and we
are ignoring all text inside comments. We must record
the comment style this sequence begins so that later,
only a comment end of the same style actually ends
INC_BOTH (from, from_byte);
UPDATE_SYNTAX_TABLE_FORWARD (from);
}
-
+
if (prefix)
continue;
comstyle = SYNTAX_COMMENT_STYLE (c1);
comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
}
-
+
/* Quoting turns anything except a comment-ender
into a word character. Note that this cannot be true
if we decremented FROM in the if-statement above. */
DEC_BOTH (from, from_byte);
if (from == stop) goto lose;
UPDATE_SYNTAX_TABLE_BACKWARD (from);
- if (!char_quoted (from, from_byte)
+ if (!char_quoted (from, from_byte)
&& (c = FETCH_CHAR (from_byte),
SYNTAX_WITH_MULTIBYTE_CHECK (c) == code))
break;
}
if (code == Sstring_fence && !depth && sexpflag) goto done2;
break;
-
+
case Sstring:
stringterm = FETCH_CHAR (from_byte);
while (1)
int pos_byte = PT_BYTE;
int c;
- if (pos <= beg)
+ if (pos <= beg)
{
SET_PT_BOTH (opoint, opoint_byte);
oldstate = Fcdr (oldstate);
tem = Fcar (oldstate);
/* Check whether we are inside string_fence-style string: */
- state.instring = (!NILP (tem)
- ? (INTEGERP (tem) ? XINT (tem) : ST_STRING_STYLE)
+ state.instring = (!NILP (tem)
+ ? (INTEGERP (tem) ? XINT (tem) : ST_STRING_STYLE)
: -1);
oldstate = Fcdr (oldstate);
oldstate = Fcdr (oldstate);
oldstate = Fcdr (oldstate);
tem = Fcar (oldstate);
- state.comstyle = NILP (tem) ? 0 : (EQ (tem, Qsyntax_table)
+ state.comstyle = NILP (tem) ? 0 : (EQ (tem, Qsyntax_table)
? ST_COMMENT_STYLE : 1);
oldstate = Fcdr (oldstate);
state.comstr_start = from - 1;
if (stopbefore) goto stop; /* this arg means stop at sexp start */
curlevel->last = prev_from;
- state.instring = (code == Sstring
+ state.instring = (code == Sstring
? (FETCH_CHAR (prev_from_byte))
: ST_STRING_STYLE);
if (boundary_stop) goto done;
startinstring:
{
nofence = state.instring != ST_STRING_STYLE;
-
+
while (1)
{
int c;
3. non-nil if inside a string.
(it is the character that will terminate the string,
or t if the string should be terminated by a generic string delimiter.)
- 4. nil if outside a comment, t if inside a non-nestable comment,
+ 4. nil if outside a comment, t if inside a non-nestable comment,
else an integer (the current comment nesting).
5. t if following a quote character.
6. the minimum paren-depth encountered during this scan.
scan_sexps_forward (&state, XINT (from), CHAR_TO_BYTE (XINT (from)),
XINT (to),
target, !NILP (stopbefore), oldstate,
- (NILP (commentstop)
+ (NILP (commentstop)
? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));
SET_PT (state.location);
-
+
return Fcons (make_number (state.depth),
Fcons (state.prevlevelstart < 0 ? Qnil : make_number (state.prevlevelstart),
Fcons (state.thislevelstart < 0 ? Qnil : make_number (state.thislevelstart),
- Fcons (state.instring >= 0
- ? (state.instring == ST_STRING_STYLE
+ Fcons (state.instring >= 0
+ ? (state.instring == ST_STRING_STYLE
? Qt : make_number (state.instring)) : Qnil,
Fcons (state.incomment < 0 ? Qt :
(state.incomment == 0 ? Qnil :
make_number (state.incomment)),
Fcons (state.quoted ? Qt : Qnil,
Fcons (make_number (state.mindepth),
- Fcons ((state.comstyle
+ Fcons ((state.comstyle
? (state.comstyle == ST_COMMENT_STYLE
? Qsyntax_table : Qt) :
Qnil),
FARPROC track_mouse_event_fn;
/* W95 mousewheel handler */
-unsigned int msh_mousewheel = 0;
+unsigned int msh_mousewheel = 0;
/* Timers */
#define MOUSE_BUTTON_ID 1
/* Nonzero if we can use mouse menus.
You should not call this unless HAVE_MENUS is defined. */
-
+
int
have_menus_p ()
{
return f;
}
-/* Let the user specify an display with a frame.
+/* Let the user specify a display with a frame.
nil stands for the selected frame--or, if that is not a w32 frame,
the first display on the list. */
if (NILP (frame))
{
struct frame *sf = XFRAME (selected_frame);
-
+
if (FRAME_W32_P (sf) && FRAME_LIVE_P (sf))
return FRAME_W32_DISPLAY_INFO (sf);
else
if (hinst == NULL)
return -1;
-
+
result = XReadBitmapFile (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
filename, &width, &height, &bitmap, &xhot, &yhot);
if (result != BitmapSuccess)
They are independent of other properties, but other properties (e.g.,
cursor_color) are dependent upon them. */
/* Process default font as well, since fringe widths depends on it. */
- for (p = 0; p < i; p++)
+ for (p = 0; p < i; p++)
{
Lisp_Object prop, val;
if (NILP (Fequal (val, old_value)))
{
store_frame_param (f, prop, val);
-
+
param_index = Fget (prop, Qx_frame_parameter);
if (NATNUMP (param_index)
&& (XFASTINT (param_index)
position. Resize of the frame is taken care of in the code after
this if-statement. */
int new_left, new_top;
-
+
x_fullscreen_adjust (f, &width, &height, &new_top, &new_left);
x_fullscreen_move (f, new_top, new_left);
}
}
/* The default colors for the w32 color map */
-typedef struct colormap_t
+typedef struct colormap_t
{
char *name;
COLORREF colorref;
} colormap_t;
-colormap_t w32_color_map[] =
+colormap_t w32_color_map[] =
{
{"snow" , PALETTERGB (255,250,250)},
{"ghost white" , PALETTERGB (248,248,255)},
int i;
colormap_t *pc = w32_color_map;
Lisp_Object cmap;
-
+
BLOCK_INPUT;
-
+
cmap = Qnil;
-
- for (i = 0; i < sizeof (w32_color_map) / sizeof (w32_color_map[0]);
+
+ for (i = 0; i < sizeof (w32_color_map) / sizeof (w32_color_map[0]);
pc++, i++)
cmap = Fcons (Fcons (build_string (pc->name),
make_number (pc->colorref)),
cmap);
-
+
UNBLOCK_INPUT;
-
+
return (cmap);
}
-Lisp_Object
+Lisp_Object
w32_to_x_color (rgb)
Lisp_Object rgb;
{
Lisp_Object color;
-
+
CHECK_NUMBER (rgb);
-
+
BLOCK_INPUT;
-
+
color = Frassq (rgb, Vw32_color_map);
-
+
UNBLOCK_INPUT;
-
+
if (!NILP (color))
return (Fcar (color));
else
return ret;
}
-COLORREF
+COLORREF
x_to_w32_color (colorname)
char * colorname;
{
char *color;
int size;
color = colorname + 1;
-
+
size = strlen(color);
if (size == 3 || size == 6 || size == 9 || size == 12)
{
pos = 0;
size /= 3;
colorval = 0;
-
+
for (i = 0; i < 3; i++)
{
char *end;
{
char *end;
unsigned long value;
-
+
/* The check for 'x' in the following conditional takes into
account the fact that strtol allows a "0x" in front of
our numbers, and we don't. */
if (value < 0.0 || value > 1.0)
break;
val = (UINT)(0x100 * value);
- /* We used 0x100 instead of 0xFF to give an continuous
+ /* We used 0x100 instead of 0xFF to give a continuous
range between 0.0 and 1.0 inclusive. The next statement
fixes the 1.0 case. */
if (val == 0x100)
RGB. */
/* If we fail to lookup the color name in w32_color_map, then check the
- colorname to see if it can be crudely approximated: If the X color
+ colorname to see if it can be crudely approximated: If the X color
ends in a number (e.g., "darkseagreen2"), strip the number and
return the result of looking up the base color name. */
ret = w32_color_map_lookup (colorname);
- if (NILP (ret))
+ if (NILP (ret))
{
int len = strlen (colorname);
- if (isdigit (colorname[len - 1]))
+ if (isdigit (colorname[len - 1]))
{
char *ptr, *approx = alloca (len + 1);
strcpy (approx, colorname);
ptr = &approx[len - 1];
- while (ptr > approx && isdigit (*ptr))
+ while (ptr > approx && isdigit (*ptr))
*ptr-- = '\0';
ret = w32_color_map_lookup (approx);
}
}
-
+
UNBLOCK_INPUT;
return ret;
}
tem = x_to_w32_color (color);
- if (!NILP (tem))
+ if (!NILP (tem))
{
if (f)
{
one_w32_display_info.color_list;
struct w32_palette_entry ** prev =
&one_w32_display_info.color_list;
-
+
/* check if color is already mapped */
while (entry)
{
return 1;
}
- else
+ else
{
return 0;
}
else
hourglass_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_watch);
x_check_errors (FRAME_W32_DISPLAY (f), "bad busy pointer cursor: %s");
-
+
x_check_errors (FRAME_W32_DISPLAY (f), "bad nontext pointer cursor: %s");
if (!EQ (Qnil, Vx_mode_pointer_shape))
{
&& f->output_data.w32->modeline_cursor != 0)
XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->modeline_cursor);
f->output_data.w32->modeline_cursor = mode_cursor;
-
+
if (cross_cursor != f->output_data.w32->cross_cursor
&& f->output_data.w32->cross_cursor != 0)
XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->cross_cursor);
fore_pixel = FRAME_BACKGROUND_PIXEL (f);
pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
-
+
/* Make sure that the cursor color differs from the background color. */
if (pixel == FRAME_BACKGROUND_PIXEL (f))
{
/* Set the border-color of frame F to pixel value PIX.
Note that this does not fully take effect if done before
- F has an window. */
+ F has a window. */
void
x_set_border_pixel (f, pix)
struct frame *f;
if (NILP (arg) && NILP (oldval))
return;
- if (STRINGP (arg) && STRINGP (oldval)
+ if (STRINGP (arg) && STRINGP (oldval)
&& EQ (Fstring_equal (oldval, arg), Qt))
return;
? x_new_fontset (f, SDATA (fontset_name))
: x_new_font (f, SDATA (arg)));
UNBLOCK_INPUT;
-
+
if (EQ (result, Qnil))
error ("Font `%s' is not defined", SDATA (arg));
else if (EQ (result, Qt))
Lisp_Object name;
int explicit;
{
- /* Make sure that requests from lisp code override requests from
+ /* Make sure that requests from lisp code override requests from
Emacs redisplay code. */
if (explicit)
{
/* Put scroll bars on the right by default, as is conventional
on MS-Windows. */
EQ (Qleft, arg)
- ? vertical_scroll_bar_left
+ ? vertical_scroll_bar_left
: vertical_scroll_bar_right;
/* We set this parameter before creating the window for the
}
change_frame_size (f, 0, FRAME_WIDTH (f), 0, 0, 0);
XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
- XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
+ XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
}
\f
-/* Subroutines of creating an frame. */
+/* Subroutines of creating a frame. */
/* Make sure that Vx_resource_name is set to a reasonable value.
Fix it up, or set it to `emacs' if it is too hopeless. */
if (!strcmp (SDATA (tem), "on")
|| !strcmp (SDATA (tem), "true"))
return Qt;
- else
+ else
return Qnil;
case RES_TYPE_STRING:
extern LRESULT CALLBACK w32_wnd_proc ();
-BOOL
+BOOL
w32_init_class (hinst)
HINSTANCE hinst;
{
return (RegisterClass (&wc));
}
-HWND
+HWND
w32_createscrollbar (f, bar)
struct frame *f;
struct scroll_bar * bar;
return (CreateWindow ("SCROLLBAR", "", SBS_VERT | WS_CHILD | WS_VISIBLE,
/* Position and size of scroll bar. */
XINT(bar->left) + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
- XINT(bar->top),
+ XINT(bar->top),
XINT(bar->width) - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
XINT(bar->height),
FRAME_W32_WINDOW (f),
NULL));
}
-void
+void
w32_createwindow (f)
struct frame *f;
{
rect.left = rect.top = 0;
rect.right = PIXEL_WIDTH (f);
rect.bottom = PIXEL_HEIGHT (f);
-
+
AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
FRAME_EXTERNAL_MENU_BAR (f));
-
+
/* Do first time app init */
-
+
if (!hprevinst)
{
w32_init_class (hinst);
}
-
+
FRAME_W32_WINDOW (f) = hwnd
= CreateWindow (EMACS_CLASS,
f->namebuf,
/* Enable drag-n-drop. */
DragAcceptFiles (hwnd, TRUE);
-
+
/* Do this to discard the default setting specified by our parent. */
ShowWindow (hwnd, SW_HIDE);
}
}
-void
+void
my_post_msg (wmsg, hwnd, msg, wParam, lParam)
W32Msg * wmsg;
HWND hwnd;
}
/* Emacs can lose focus while a modifier key has been pressed. When
- it regains focus, be conservative and clear all modifiers since
+ it regains focus, be conservative and clear all modifiers since
we cannot reconstruct the left and right modifier state. */
static void
reset_modifiers ()
if (!modifiers_recorded)
return;
- if (!(GetKeyState (VK_CONTROL) & 0x8000))
+ if (!(GetKeyState (VK_CONTROL) & 0x8000))
modifiers[EMACS_RCONTROL] = modifiers[EMACS_LCONTROL] = 0;
- if (!(GetKeyState (VK_MENU) & 0x8000))
+ if (!(GetKeyState (VK_MENU) & 0x8000))
modifiers[EMACS_RMENU] = modifiers[EMACS_LMENU] = 0;
}
HWND focus_window;
msh_mousewheel = RegisterWindowMessage (MSH_MOUSEWHEEL);
-
+
while (GetMessage (&msg, NULL, 0, 0))
{
if (msg.hwnd == NULL)
PostThreadMessage (dwWindowsThreadId, WM_NULL, 0, 0);
}
-DWORD
+DWORD
w32_msg_worker (dw)
DWORD dw;
{
deferred_msg dummy_buf;
/* Ensure our message queue is created */
-
+
PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
-
+
if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
abort ();
/* Main window procedure */
-LRESULT CALLBACK
+LRESULT CALLBACK
w32_wnd_proc (hwnd, msg, wParam, lParam)
HWND hwnd;
UINT msg;
w32_clear_rect, because these functions must obtain a DC handle
from the frame struct using get_frame_dc which is thread-aware. */
- switch (msg)
+ switch (msg)
{
case WM_ERASEBKGND:
f = x_window_to_frame (dpyinfo, hwnd);
leave_crit ();
my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
-
+
return 0;
}
return 0;
break;
case VK_MENU:
- if (NILP (Vw32_pass_alt_to_system))
+ if (NILP (Vw32_pass_alt_to_system))
/* Prevent DefWindowProc from activating the menu bar if an
Alt key is pressed and released by itself. */
return 0;
windows_translate = 1;
break;
- case VK_CAPITAL:
+ case VK_CAPITAL:
/* Decide whether to treat as modifier or function key. */
if (NILP (Vw32_enable_caps_lock))
goto disable_lock_key;
w32_get_key_modifiers (wParam, lParam));
windows_translate = 1;
break;
- case VK_CONTROL:
+ case VK_CONTROL:
case VK_SHIFT:
case VK_PROCESSKEY: /* Generated by IME. */
windows_translate = 1;
int add;
int isdead = 0;
KEY_EVENT_RECORD key;
-
+
key.bKeyDown = TRUE;
key.wRepeatCount = 1;
key.wVirtualKeyCode = wParam;
}
/* Fall through */
-
+
case WM_SYSCHAR:
case WM_CHAR:
post_character_message (hwnd, msg, wParam, lParam,
{
if (up) ReleaseCapture ();
else SetCapture (hwnd);
- button = (button == 0) ? LMOUSE :
+ button = (button == 0) ? LMOUSE :
((button == 1) ? MMOUSE : RMOUSE);
if (up)
button_state &= ~button;
button_state |= button;
}
}
-
+
wmsg.dwModifiers = w32_get_modifiers ();
my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
return 0;
}
-
+
/* Hang onto mouse move and scroll messages for a bit, to avoid
sending such events to Emacs faster than it can process them.
If we get more events before the timer from the first message
saved_mouse_move_msg.msg.lParam = lParam;
saved_mouse_move_msg.msg.time = GetMessageTime ();
saved_mouse_move_msg.dwModifiers = w32_get_modifiers ();
-
+
return 0;
case WM_MOUSEWHEEL:
}
}
return 0;
-
+
case WM_NCACTIVATE:
/* Windows doesn't send us focus messages when putting up and
taking down a system popup dialog as for Ctrl-Alt-Del on Windows 95.
if (menu_free_timer)
{
KillTimer (hwnd, menu_free_timer);
- menu_free_timer = 0;
+ menu_free_timer = 0;
}
}
case WM_MOVE:
wp.length = sizeof (WINDOWPLACEMENT);
GetWindowPlacement (hwnd, &wp);
-
+
if (wp.showCmd != SW_SHOWMINIMIZED && (lppos->flags & SWP_NOSIZE) == 0)
{
RECT rect;
DWORD internal_border;
DWORD scrollbar_extra;
RECT wr;
-
+
wp.length = sizeof(wp);
GetWindowRect (hwnd, &wr);
-
+
enter_crit ();
-
+
font_width = GetWindowLong (hwnd, WND_FONTWIDTH_INDEX);
line_height = GetWindowLong (hwnd, WND_LINEHEIGHT_INDEX);
internal_border = GetWindowLong (hwnd, WND_BORDER_INDEX);
scrollbar_extra = GetWindowLong (hwnd, WND_SCROLLBAR_INDEX);
-
+
leave_crit ();
-
+
memset (&rect, 0, sizeof (rect));
- AdjustWindowRect (&rect, GetWindowLong (hwnd, GWL_STYLE),
+ AdjustWindowRect (&rect, GetWindowLong (hwnd, GWL_STYLE),
GetMenu (hwnd) != NULL);
/* Force width and height of client area to be exact
hdiff = (lppos->cy - (rect.bottom - rect.top)
- 2 * internal_border)
% line_height;
-
+
if (wdiff || hdiff)
{
- /* For right/bottom sizing we can just fix the sizes.
- However for top/left sizing we will need to fix the X
+ /* For right/bottom sizing we can just fix the sizes.
+ However for top/left sizing we will need to fix the X
and Y positions as well. */
-
+
lppos->cx -= wdiff;
lppos->cy -= hdiff;
-
- if (wp.showCmd != SW_SHOWMAXIMIZED
+
+ if (wp.showCmd != SW_SHOWMAXIMIZED
&& (lppos->flags & SWP_NOMOVE) == 0)
{
if (lppos->x != wr.left || lppos->y != wr.top)
lppos->flags |= SWP_NOMOVE;
}
}
-
+
return 0;
}
}
}
-
+
goto dflt;
case WM_GETMINMAXINFO:
CreateCaret (hwnd, NULL, 0,
w32_system_caret_height);
}
-
+
if (!SetCaretPos (w32_system_caret_x, w32_system_caret_y))
return 0;
/* Ensure visible caret gets turned on when requested. */
flags |= TPM_LEFTBUTTON;
else if (button_state & RMOUSE)
flags |= TPM_RIGHTBUTTON;
-
+
/* Remember we did a SetCapture on the initial mouse down event,
so for safety, we make sure the capture is cancelled now. */
ReleaseCapture ();
f = x_window_to_frame (dpyinfo, hwnd);
if (f)
f->output_data.w32->menubar_active = 1;
-
- if (TrackPopupMenu ((HMENU)wParam, flags, pos->x, pos->y,
+
+ if (TrackPopupMenu ((HMENU)wParam, flags, pos->x, pos->y,
0, hwnd, NULL))
{
MSG amsg;
my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
return 0;
}
-
+
dflt:
return DefWindowProc (hwnd, msg, wParam, lParam);
}
-
+
/* The most common default return code for handled messages is 0. */
return 0;
}
-void
+void
my_create_window (f)
struct frame * f;
{
indirectly via the Window thread, as we do not need to process Window
messages for the tooltip. Creating tooltips indirectly also creates
deadlocks when tooltips are created for menu items. */
-void
+void
my_create_tip_window (f)
struct frame *f;
{
for the window manager, so GC relocation won't bother it.
Elsewhere we specify the window name for the window manager. */
-
+
{
char *str = (char *) SDATA (Vx_resource_name);
f->namebuf = (char *) xmalloc (strlen (str) + 1);
#ifdef GLYPH_DEBUG
struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
#endif
-
+
x_free_frame_resources (f);
/* Check that reference counts are indeed correct. */
return Qt;
}
-
+
return Qnil;
}
if (! STRINGP (font))
font = build_string ("Fixedsys");
- x_default_parameter (f, parms, Qfont, font,
+ x_default_parameter (f, parms, Qfont, font,
"font", "Font", RES_TYPE_STRING);
}
end up in init_iterator with a null face cache, which should not
happen. */
init_frame_faces (f);
-
+
x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
"menuBar", "MenuBar", RES_TYPE_NUMBER);
x_default_parameter (f, parms, Qtool_bar_lines, make_number (1),
if (FRAME_TOOL_BAR_LINES (f))
{
int margin, relief, bar_height;
-
+
relief = (tool_bar_button_relief >= 0
? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF);
margin = XFASTINT (XCDR (Vtool_bar_button_margin));
else
margin = 0;
-
+
bar_height = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
f->height += (bar_height + CANON_Y_UNIT (f) - 1) / CANON_Y_UNIT (f);
}
;
}
UNGCPRO;
-
+
/* Make sure windows on this frame appear in calls to next-window
and similar functions. */
Vwindow_list = Qnil;
-
+
return unbind_to (count, frame);
}
font->hfont = CreateFontIndirect (&lf);
- if (font->hfont == NULL)
+ if (font->hfont == NULL)
{
ok = FALSE;
- }
- else
+ }
+ else
{
HDC hdc;
HANDLE oldobj;
}
-void
+void
w32_unload_font (dpyinfo, font)
struct w32_display_info *dpyinfo;
XFontStruct * font;
{
- if (font)
+ if (font)
{
if (font->per_char) xfree (font->per_char);
if (font->bdf) w32_free_bdf_font (font->bdf);
* )
*/
-static LONG
+static LONG
x_to_w32_weight (lpw)
char * lpw;
{
}
-static char *
+static char *
w32_to_x_weight (fnweight)
int fnweight;
{
sprintf (buf, "*-#%u", fncharset);
return buf;
}
-
+
{
Lisp_Object rest;
char * best_match = NULL;
int this_enc = atoi (x_charset + 8);
if (this_enc > 0 && this_enc < best_enc)
best_match = x_charset;
- }
+ }
}
}
sprintf (buf, "*-#%u", fncharset);
return Fcons (build_string (buf), Qnil);
}
-
+
{
Lisp_Object rest;
/* Look through w32-charset-info-alist for the character set.
/* Get the Windows codepage corresponding to the specified font. The
charset info in the font name is used to look up
w32-charset-to-codepage-alist. */
-int
+int
w32_codepage_for_font (char *fontname)
{
Lisp_Object codepage, entry;
}
-static BOOL
+static BOOL
w32_to_x_font (lplogfont, lpxstr, len, specific_charset)
LOGFONT * lplogfont;
char * lpxstr;
? 'p' : 'c', /* spacing */
width_pixels, /* avg width */
specific_charset ? specific_charset
- : w32_to_x_charset (lplogfont->lfCharSet)
+ : w32_to_x_charset (lplogfont->lfCharSet)
/* charset registry and encoding */
);
return (TRUE);
}
-static BOOL
+static BOOL
x_to_w32_font (lpxstr, lplogfont)
char * lpxstr;
LOGFONT * lplogfont;
* format:
* "<font name>[:height in pixels[:width in pixels[:weight]]]"
*/
-
+
if (*lpxstr == '-')
{
int fields, tem;
}
/* Assume parameter 1 is fully qualified, no wildcards. */
-static BOOL
+static BOOL
w32_font_match (fontname, pattern)
char * fontname;
char * pattern;
font from each family, the second pass lists all the fonts from
each family. */
-typedef struct enumfont_t
+typedef struct enumfont_t
{
HDC hdc;
int numFonts;
enum_font_maybe_add_to_list (enumfont_t *, LOGFONT *, char *, Lisp_Object);
-static int CALLBACK
+static int CALLBACK
enum_font_cb2 (lplf, lptm, FontType, lpef)
ENUMLOGFONT * lplf;
NEWTEXTMETRIC * lptm;
}
-static int CALLBACK
+static int CALLBACK
enum_font_cb1 (lplf, lptm, FontType, lpef)
ENUMLOGFONT * lplf;
NEWTEXTMETRIC * lptm;
newlist = second_best = Qnil;
- /* Make a list of the fonts that have the right width. */
+ /* Make a list of the fonts that have the right width. */
for (; CONSP (list); list = XCDR (list))
{
int found_size;
{
if (NILP (second_best))
second_best = tem;
-
+
else if (found_size < size)
{
if (XINT (XCDR (second_best)) > size
and because probably is more meaningful on Windows anyway */
if (cap < 0)
cap = 1 << min(dpyinfo->n_planes * dpyinfo->n_cbits, 24);
-
+
ReleaseDC (dpyinfo->root_window, hdc);
-
+
return make_number (cap);
}
int cap;
hdc = GetDC (dpyinfo->root_window);
-
+
cap = GetDeviceCaps (hdc, VERTSIZE);
-
+
ReleaseDC (dpyinfo->root_window, hdc);
-
+
return make_number (cap);
}
int cap;
hdc = GetDC (dpyinfo->root_window);
-
+
cap = GetDeviceCaps (hdc, HORZSIZE);
-
+
ReleaseDC (dpyinfo->root_window, hdc);
-
+
return make_number (cap);
}
Lisp_Object object;
{
int valid_p = 0;
-
+
if (CONSP (object) && EQ (XCAR (object), Qimage))
{
Lisp_Object tem;
was found more than once, it's an error. */
keywords[i].value = value;
++keywords[i].count;
-
+
if (keywords[i].count > 1)
return 0;
case IMAGE_FUNCTION_VALUE:
value = indirect_function (value);
- if (SUBRP (value)
+ if (SUBRP (value)
|| COMPILEDP (value)
|| (CONSP (value) && EQ (XCAR (value), Qlambda)))
break;
int *found;
{
Lisp_Object tail;
-
+
xassert (valid_image_p (spec));
for (tail = XCDR (spec);
return XCAR (XCDR (tail));
}
}
-
+
if (found)
*found = 0;
return Qnil;
}
-
+
DEFUN ("image-size", Fimage_size, Simage_size, 1, 3, 0,
doc: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
struct image *img = IMAGE_FROM_ID (f, id);
int width = img->width + 2 * img->hmargin;
int height = img->height + 2 * img->vmargin;
-
+
if (NILP (pixels))
size = Fcons (make_float ((double) width / CANON_X_UNIT (f)),
make_float ((double) height / CANON_Y_UNIT (f)));
unsigned hash;
{
struct image *img = (struct image *) xmalloc (sizeof *img);
-
+
xassert (valid_image_p (spec));
bzero (img, sizeof *img);
img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
if (img->pixmap == 0 && !img->load_failed_p)
img->load_failed_p = img->type->load (f, img) == 0;
}
-
+
/* Value is the number of pixels for the ascent of image IMG when
drawn in face FACE. */
for (i = best_count = 0; i < 4; ++i)
{
int j, n;
-
+
for (j = n = 0; j < 4; ++j)
if (corners[i] == corners[j])
++n;
img->mask = NULL;
img->background_transparent_valid = 0;
}
-
+
if (colors_p && img->ncolors)
{
#if 0 /* TODO: color table support. */
#if 0 /* TODO: color table support */
int class = FRAME_W32_DISPLAY_INFO (f)->visual->class;
-
+
/* If display has an immutable color map, freeing colors is not
necessary and some servers don't allow it. So don't do it. */
if (class != StaticColor
UNBLOCK_INPUT;
}
#endif
-
+
xfree (img->colors);
img->colors = NULL;
img->ncolors = 0;
{
struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
int size;
-
+
bzero (c, sizeof *c);
c->size = 50;
c->images = (struct image **) xmalloc (c->size * sizeof *c->images);
/* Cache should not be referenced by any frame when freed. */
xassert (c->refcount == 0);
-
+
for (i = 0; i < c->used; ++i)
free_image (f, c->images[i]);
xfree (c->images);
EMACS_GET_TIME (t);
old = EMACS_SECS (t) - XFASTINT (Vimage_cache_eviction_delay);
-
+
/* Block input so that we won't be interrupted by a SIGIO
while being in an inconsistent state. */
BLOCK_INPUT;
-
+
for (i = nfreed = 0; i < c->used; ++i)
{
struct image *img = c->images[i];
if (nfreed)
{
Lisp_Object tail, frame;
-
+
FOR_EACH_FRAME (tail, frame)
{
struct frame *f = XFRAME (frame);
if (EQ (frame, Qt))
{
Lisp_Object tail;
-
+
FOR_EACH_FRAME (tail, frame)
if (FRAME_W32_P (XFRAME (frame)))
clear_image_cache (XFRAME (frame), 1);
Lisp_Object mask;
spec = img->spec;
-
+
/* `:heuristic-mask t'
`:mask heuristic'
means build a mask heuristically.
image.
`:mask nil'
means remove a mask, if any. */
-
+
mask = image_spec_value (spec, QCheuristic_mask, NULL);
if (!NILP (mask))
x_build_heuristic_mask (f, img, mask);
else
{
int found_p;
-
+
mask = image_spec_value (spec, QCmask, &found_p);
-
+
if (EQ (mask, Qheuristic))
x_build_heuristic_mask (f, img, Qt);
else if (CONSP (mask)
img->mask = NULL;
}
}
-
-
+
+
/* Should we apply an image transformation algorithm? */
conversion = image_spec_value (spec, QCconversion, NULL);
if (EQ (conversion, Qdisabled))
specification. */
xassert (FRAME_WINDOW_P (f));
xassert (valid_image_p (spec));
-
+
GCPRO1 (spec);
/* Look up SPEC in the hash table of the image cache. */
if (XINT (XCDR (margin)) > 0)
img->vmargin = XFASTINT (XCDR (margin));
}
-
+
relief = image_spec_value (spec, QCrelief, NULL);
if (INTEGERP (relief))
{
/* We're using IMG, so set its timestamp to `now'. */
EMACS_GET_TIME (now);
img->timestamp = EMACS_SECS (now);
-
+
UNGCPRO;
-
+
/* Value is the image id. */
return img->id;
}
/* Try to find FILE in data-directory, then x-bitmap-file-path. */
fd = openp (search_path, file, Qnil, &file_found, Qnil);
-
+
if (fd == -1)
file_found = Qnil;
else
buf = NULL;
}
}
-
+
return buf;
}
XBM_TK_NUMBER
};
-
+
/* Return non-zero if OBJECT is a valid XBM-type image specification.
A valid specification is a list starting with the symbol `image'
The rest of the list is a property list which must contain an
Lisp_Object object;
{
struct image_keyword kw[XBM_LAST];
-
+
bcopy (xbm_format, kw, sizeof kw);
if (!parse_image_spec (object, kw, XBM_LAST, Qxbm))
return 0;
data = kw[XBM_DATA].value;
width = XFASTINT (kw[XBM_WIDTH].value);
height = XFASTINT (kw[XBM_HEIGHT].value);
-
+
/* Check type of data, and width and height against contents of
data. */
if (VECTORP (data))
{
int i;
-
+
/* Number of elements of the vector must be >= height. */
if (XVECTOR (data)->size < height)
return 0;
else if (isdigit (c))
{
int value = 0, digit;
-
+
if (c == '0' && *s < end)
{
c = *(*s)++;
if (LA1 != (TOKEN)) \
goto failure; \
else \
- match ()
+ match ()
#define expect_ident(IDENT) \
if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
{
if (strcmp (buffer, "unsigned") == 0)
{
- match ();
+ match ();
expect_ident ("char");
}
else if (strcmp (buffer, "short") == 0)
else
goto failure;
}
- else
+ else
goto failure;
expect (XBM_TK_IDENT);
*p++ = val;
if (!padding_p || ((i + 2) % bytes_per_line))
*p++ = value >> 8;
-
+
if (LA1 == ',' || LA1 == '}')
match ();
else
{
int val = value;
expect (XBM_TK_NUMBER);
-
+
*p++ = val;
if (LA1 == ',' || LA1 == '}')
int rc;
unsigned char *data;
int success_p = 0;
-
+
rc = xbm_read_bitmap_data (contents, end, &img->width, &img->height, &data);
if (rc)
{
unsigned long foreground = FRAME_FOREGROUND_PIXEL (f);
unsigned long background = FRAME_BACKGROUND_PIXEL (f);
Lisp_Object value;
-
+
xassert (img->width > 0 && img->height > 0);
/* Get foreground and background colors, maybe allocate colors. */
&w, &h, NULL));
}
-
+
/* Fill image IMG which is used on frame F with pixmap data. Value is
non-zero if successful. */
int i;
char *p;
int nbytes = (img->width + BITS_PER_CHAR - 1) / BITS_PER_CHAR;
-
+
p = bits = (char *) alloca (nbytes * img->height);
for (i = 0; i < img->height; ++i, p += nbytes)
{
return success_p;
}
-
+
\f
/***********************************************************************
XPM images
***********************************************************************/
-#if HAVE_XPM
+#if HAVE_XPM
static int xpm_image_p P_ ((Lisp_Object object));
static int xpm_load P_ ((struct frame *f, struct image *img));
Lisp_Object tail;
XpmColorSymbol *xpm_syms;
int i, size;
-
+
attrs.valuemask |= XpmColorSymbols;
/* Count number of symbols. */
UNBLOCK_INPUT;
return 0;
}
-
+
rc = XpmReadFileToPixmap (NULL, FRAME_W32_WINDOW (f),
SDATA (file), &img->pixmap, &img->mask,
&attrs);
case XpmOpenFailed:
image_error ("Error opening XPM file (%s)", img->spec, Qnil);
break;
-
+
case XpmFileInvalid:
image_error ("Invalid XPM file (%s)", img->spec, Qnil);
break;
-
+
case XpmNoMemory:
image_error ("Out of memory (%s)", img->spec, Qnil);
break;
-
+
case XpmColorFailed:
image_error ("Color allocation error (%s)", img->spec, Qnil);
break;
-
+
default:
image_error ("Unknown error (%s)", img->spec, Qnil);
break;
int rc;
BLOCK_INPUT;
-
+
cmap = DefaultColormapOfScreen (FRAME_X_SCREEN (f));
color.pixel = pixel;
XQueryColor (NULL, cmap, &color);
if (rc)
{
++ct_colors_allocated;
-
+
p = (struct ct_color *) xmalloc (sizeof *p);
p->r = color.red;
p->g = color.green;
colors = (unsigned long *) xmalloc (ct_colors_allocated
* sizeof *colors);
*n = ct_colors_allocated;
-
+
for (i = j = 0; i < CT_SIZE; ++i)
for (p = ct_table[i]; p; p = p->next)
colors[j++] = p->pixel;
for (y = 0; y < img->height; ++y)
{
XColor *row = p;
-
+
for (x = 0; x < img->width; ++x, ++p)
p->pixel = XGetPixel (ximg, x, y);
MATRIX is a nine-element array specifying the transformation
matrix. See emboss_matrix for an example.
-
+
COLOR_ADJUST is a color adjustment added to each pixel of the
outgoing image. */
p = COLOR (new, img->width - 1, y);
p->red = p->green = p->blue = 0xffff/2;
}
-
+
for (x = 1; x < img->width - 1; ++x)
{
p = COLOR (new, x, 0);
for (y = 1; y < img->height - 1; ++y)
{
p = COLOR (new, 1, y);
-
+
for (x = 1; x < img->width - 1; ++x, ++p)
{
int r, g, b, y1, x1;
{
int i = 0;
int trans[9];
-
+
if (CONSP (matrix))
{
for (i = 0;
/* Determine the background color of ximg. If HOW is `(R G B)'
take that as color. Otherwise, use the image's background color. */
use_img_background = 1;
-
+
if (CONSP (how))
{
int rgb[3], i;
use_img_background = 0;
}
}
-
+
if (use_img_background)
bg = four_corners_best (ximg, img->width, img->height);
Lisp_Object object;
{
struct image_keyword fmt[PBM_LAST];
-
+
bcopy (pbm_format, fmt, sizeof fmt);
-
+
if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm)
- || (fmt[PBM_ASCENT].count
+ || (fmt[PBM_ASCENT].count
&& XFASTINT (fmt[PBM_ASCENT].value) > 100))
return 0;
buf = NULL;
}
}
-
+
return buf;
}
/* Load PBM image IMG for use on frame F. */
-static int
+static int
pbm_load (f, img)
struct frame *f;
struct image *img;
case '1':
raw_p = 0, type = PBM_MONO;
break;
-
+
case '2':
raw_p = 0, type = PBM_GRAY;
break;
case '4':
raw_p = 1, type = PBM_MONO;
break;
-
+
case '5':
raw_p = 1, type = PBM_GRAY;
break;
-
+
case '6':
raw_p = 1, type = PBM_COLOR;
break;
if (raw_p && max_color_idx > 255)
max_color_idx = 255;
}
-
+
if (width < 0
|| height < 0
|| (type != PBM_MONO && max_color_idx < 0))
/* Parse the image specification. */
bcopy (pbm_format, fmt, sizeof fmt);
parse_image_spec (img->spec, fmt, PBM_LAST, Qpbm);
-
+
/* Get foreground and background colors, maybe allocate colors. */
if (fmt[PBM_FOREGROUND].count
&& STRINGP (fmt[PBM_FOREGROUND].value))
for (x = 0; x < width; ++x)
{
int r, g, b;
-
+
if (type == PBM_GRAY)
r = g = b = raw_p ? *p++ : pbm_scan_number (&p, end);
else if (raw_p)
g = pbm_scan_number (&p, end);
b = pbm_scan_number (&p, end);
}
-
+
if (r < 0 || g < 0 || b < 0)
{
x_destroy_x_image (ximg);
img->spec, Qnil);
goto error;
}
-
+
/* RGB values are now in the range 0..max_color_idx.
Scale this to the range 0..0xff supported by W32. */
r = (int) ((double) r * 255 / max_color_idx);
/* Maybe fill in the background field while we have ximg handy. */
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, ximg);
-
+
/* Put the image into a pixmap. */
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
-
+
img->width = width;
img->height = height;
{
struct image_keyword fmt[PNG_LAST];
bcopy (png_format, fmt, sizeof fmt);
-
+
if (!parse_image_spec (object, fmt, PNG_LAST, Qpng)
- || (fmt[PNG_ASCENT].count
+ || (fmt[PNG_ASCENT].count
&& XFASTINT (fmt[PNG_ASCENT].value) > 100))
return 0;
if (length > tbr->len - tbr->index)
png_error (png_ptr, "Read error");
-
+
bcopy (tbr->bytes + tbr->index, data, length);
tbr->index = tbr->index + length;
}
png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
&interlace_type, NULL, NULL);
- /* If image contains simply transparency data, we prefer to
+ /* If image contains simply transparency data, we prefer to
construct a clipping mask. */
if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
transparent_p = 1;
else
transparent_p = 0;
- /* This function is easier to write if we only have to handle
+ /* This function is easier to write if we only have to handle
one data format: RGB or RGBA with 8 bits per channel. Let's
transform other formats into that format. */
png_set_expand (png_ptr);
/* Convert grayscale images to RGB. */
- if (color_type == PNG_COLOR_TYPE_GRAY
+ if (color_type == PNG_COLOR_TYPE_GRAY
|| color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb (png_ptr);
}
}
else if (png_get_bKGD (png_ptr, info_ptr, &image_background))
- /* Image contains a background color with which to
+ /* Image contains a background color with which to
combine the image. */
png_set_background (png_ptr, image_background,
PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
else
{
/* Image does not contain a background color with which
- to combine the image data via an alpha channel. Use
+ to combine the image data via an alpha channel. Use
the frame's background instead. */
XColor color;
Colormap cmap;
if (!x_create_x_image_and_pixmap (f, width, height, 0, &ximg,
&img->pixmap))
goto error;
-
+
/* Create an image and pixmap serving as mask if the PNG image
contains an alpha channel. */
if (channels == 4
XPutPixel (ximg, x, y, lookup_rgb_color (f, r, g, b));
/* An alpha channel, aka mask channel, associates variable
- transparency with an image. Where other image formats
- support binary transparency---fully transparent or fully
+ transparency with an image. Where other image formats
+ support binary transparency---fully transparent or fully
opaque---PNG allows up to 254 levels of partial transparency.
The PNG library implements partial transparency by combining
the image with a specified background color.
I'm not sure how to handle this here nicely: because the
background on which the image is displayed may change, for
- real alpha channel support, it would be necessary to create
- a new image for each possible background.
+ real alpha channel support, it would be necessary to create
+ a new image for each possible background.
What I'm doing now is that a mask is created if we have
boolean transparency information. Otherwise I'm using
Lisp_Object object;
{
struct image_keyword fmt[JPEG_LAST];
-
+
bcopy (jpeg_format, fmt, sizeof fmt);
-
+
if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg)
- || (fmt[JPEG_ASCENT].count
+ || (fmt[JPEG_ASCENT].count
&& XFASTINT (fmt[JPEG_ASCENT].value) > 100))
return 0;
{
if (num_bytes > src->bytes_in_buffer)
ERREXIT (cinfo, JERR_INPUT_EOF);
-
+
src->bytes_in_buffer -= num_bytes;
src->next_input_byte += num_bytes;
}
src = (struct jpeg_source_mgr *) cinfo->src;
src->next_input_byte = data;
}
-
+
src = (struct jpeg_source_mgr *) cinfo->src;
src->init_source = our_init_source;
src->fill_input_buffer = our_fill_input_buffer;
/* Load image IMG for use on frame F. Patterned after example.c
from the JPEG lib. */
-static int
+static int
jpeg_load (f, img)
struct frame *f;
struct image *img;
UNGCPRO;
return 0;
}
-
+
fp = fopen (SDATA (file), "r");
if (fp == NULL)
{
return 0;
}
}
-
+
/* Customize libjpeg's error handling to call my_error_exit when an
error is detected. This function will perform a longjmp. */
cinfo.err = jpeg_std_error (&mgr.pub);
mgr.pub.error_exit = my_error_exit;
-
+
if ((rc = setjmp (mgr.setjmp_buffer)) != 0)
{
if (rc == 1)
image_error ("Error reading JPEG image `%s': %s", img->spec,
build_string (buffer));
}
-
+
/* Close the input file and destroy the JPEG object. */
if (fp)
fclose (fp);
jpeg_destroy_decompress (&cinfo);
-
+
/* If we already have an XImage, free that. */
x_destroy_x_image (ximg);
/* Free pixmap and colors. */
x_clear_image (f, img);
-
+
UNGCPRO;
return 0;
}
init_color_table ();
colors = (unsigned long *) alloca (cinfo.actual_number_of_colors
* sizeof *colors);
-
+
for (i = 0; i < cinfo.actual_number_of_colors; ++i)
{
/* Multiply RGB values with 255 because X expects RGB values
jpeg_destroy_decompress (&cinfo);
if (fp)
fclose (fp);
-
+
/* Maybe fill in the background field while we have ximg handy. */
if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
IMAGE_BACKGROUND (img, f, ximg);
-
+
/* Put the image into the pixmap. */
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
{
struct image_keyword fmt[TIFF_LAST];
bcopy (tiff_format, fmt, sizeof fmt);
-
+
if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff)
- || (fmt[TIFF_ASCENT].count
+ || (fmt[TIFF_ASCENT].count
&& XFASTINT (fmt[TIFF_ASCENT].value) > 100))
return 0;
-
+
/* Must specify either the :data or :file keyword. */
return fmt[TIFF_FILE].count + fmt[TIFF_DATA].count == 1;
}
case SEEK_SET: /* Go from beginning of source. */
idx = off;
break;
-
+
case SEEK_END: /* Go from end of source. */
idx = src->len + off;
break;
-
+
case SEEK_CUR: /* Go from current position. */
idx = src->index + off;
break;
-
+
default: /* Invalid `whence'. */
return -1;
}
-
+
if (idx > src->len || idx < 0)
return -1;
-
+
src->index = idx;
return src->index;
}
{
char buf[512];
int len;
-
+
len = sprintf (buf, "TIFF error: %s ", title);
vsprintf (buf + len, format, ap);
add_to_log (buf, Qnil, Qnil);
{
char buf[512];
int len;
-
+
len = sprintf (buf, "TIFF warning: %s ", title);
vsprintf (buf + len, format, ap);
add_to_log (buf, Qnil, Qnil);
UNGCPRO;
return 0;
}
-
+
/* Try to open the image file. */
tiff = TIFFOpen (SDATA (file), "r");
if (tiff == NULL)
TIFFGetField (tiff, TIFFTAG_IMAGEWIDTH, &width);
TIFFGetField (tiff, TIFFTAG_IMAGELENGTH, &height);
buf = (uint32 *) xmalloc (width * height * sizeof *buf);
-
+
rc = TIFFReadRGBAImage (tiff, width, height, buf, 0);
TIFFClose (tiff);
if (!rc)
for (y = 0; y < height; ++y)
{
uint32 *row = buf + y * width;
-
+
for (x = 0; x < width; ++x)
{
uint32 abgr = row[x];
int r = TIFFGetR (abgr) << 8;
int g = TIFFGetG (abgr) << 8;
int b = TIFFGetB (abgr) << 8;
- XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
+ XPutPixel (ximg, x, height - 1 - y, lookup_rgb_color (f, r, g, b));
}
}
{
struct image_keyword fmt[GIF_LAST];
bcopy (gif_format, fmt, sizeof fmt);
-
+
if (!parse_image_spec (object, fmt, GIF_LAST, Qgif)
- || (fmt[GIF_ASCENT].count
+ || (fmt[GIF_ASCENT].count
&& XFASTINT (fmt[GIF_ASCENT].value) > 100))
return 0;
-
+
/* Must specify either the :data or :file keyword. */
return fmt[GIF_FILE].count + fmt[GIF_DATA].count == 1;
}
UNGCPRO;
return 0;
}
-
+
/* Open the GIF file. */
gif = DGifOpenFileName (SDATA (file));
if (gif == NULL)
UNGCPRO;
return 0;
}
-
+
/* Allocate colors. */
gif_color_map = gif->SavedImages[ino].ImageDesc.ColorMap;
if (!gif_color_map)
gif_color_map = gif->SColorMap;
init_color_table ();
bzero (pixel_colors, sizeof pixel_colors);
-
+
for (i = 0; i < gif_color_map->ColorCount; ++i)
{
int r = gif_color_map->Colors[i].Red << 8;
free_color_table ();
/* Clear the part of the screen image that are not covered by
- the image from the GIF file. Full animated GIF support
+ the image from the GIF file. Full animated GIF support
requires more than can be done here (see the gif89 spec,
disposal methods). Let's simply assume that the part
not covered by a sub-image is in the frame's background color. */
while (row >= image_height)
row = interlace_start[++pass];
}
-
+
for (x = 0; x < image_width; x++)
{
int i = raster[(y * image_width) + x];
XPutPixel (ximg, x + image_left, row + image_top,
pixel_colors[i]);
}
-
+
row += interlace_increment[pass];
}
}
XPutPixel (ximg, x + image_left, y + image_top, pixel_colors[i]);
}
}
-
+
DGifCloseFile (gif);
/* Maybe fill in the background field while we have ximg handy. */
/* Put the image into the pixmap, then free the X image and its buffer. */
x_put_x_image (f, ximg, img->pixmap, width, height);
x_destroy_x_image (ximg);
-
+
UNGCPRO;
return 1;
}
struct image_keyword fmt[GS_LAST];
Lisp_Object tem;
int i;
-
+
bcopy (gs_format, fmt, sizeof fmt);
-
+
if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript)
- || (fmt[GS_ASCENT].count
+ || (fmt[GS_ASCENT].count
&& XFASTINT (fmt[GS_ASCENT].value) > 100))
return 0;
image_error ("Unable to create pixmap for `%s'", img->spec, Qnil);
return 0;
}
-
+
/* Call the loader to fill the pixmap. It returns a process object
if successful. We do not record_unwind_protect here because
other places in redisplay like calling window scroll functions
(unsigned long) FRAME_W32_WINDOW (f),
(unsigned long) img->pixmap);
window_and_pixmap_id = build_string (buffer);
-
+
sprintf (buffer, "%lu %lu",
FRAME_FOREGROUND_PIXEL (f),
FRAME_BACKGROUND_PIXEL (f));
pixel_colors = build_string (buffer);
-
+
XSETFRAME (frame, f);
loader = image_spec_value (img->spec, QCloader, NULL);
if (NILP (loader))
if (ximg)
{
int x, y;
-
+
/* Initialize the color table. */
init_color_table ();
-
+
/* For each pixel of the image, look its color up in the
color table. After having done so, the color table will
contain an entry for each color used by the image. */
else
image_error ("Cannot get X image of `%s'; colors will not be freed",
img->spec, Qnil);
-
+
UNBLOCK_INPUT;
}
rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
prop_atom, 0, bytes_remaining,
False, XA_STRING,
- &actual_type, &actual_format,
- &actual_size, &bytes_remaining,
+ &actual_type, &actual_format,
+ &actual_size, &bytes_remaining,
(unsigned char **) &tmp_data);
if (rc == Success)
prop_value = make_string (tmp_data, size);
#if 0 /* TODO: cursor shape changes. */
EMACS_TIME delay;
int secs, usecs = 0;
-
+
cancel_hourglass ();
if (INTEGERP (Vhourglass_delay)
}
else
secs = DEFAULT_HOURGLASS_DELAY;
-
+
EMACS_SET_SECS_USECS (delay, secs, usecs);
hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
show_hourglass, NULL);
cancel_atimer (hourglass_atimer);
hourglass_atimer = NULL;
}
-
+
if (hourglass_shown_p)
hide_hourglass ();
}
if (!hourglass_shown_p)
{
Lisp_Object rest, frame;
-
+
BLOCK_INPUT;
-
+
FOR_EACH_FRAME (rest, frame)
if (FRAME_W32_P (XFRAME (frame)))
{
struct frame *f = XFRAME (frame);
-
+
f->output_data.w32->hourglass_p = 1;
-
+
if (!f->output_data.w32->hourglass_window)
{
unsigned long mask = CWCursor;
XSetWindowAttributes attrs;
-
+
attrs.cursor = f->output_data.w32->hourglass_cursor;
-
+
f->output_data.w32->hourglass_window
= XCreateWindow (FRAME_X_DISPLAY (f),
FRAME_OUTER_WINDOW (f),
CopyFromParent,
mask, &attrs);
}
-
+
XMapRaised (FRAME_X_DISPLAY (f),
f->output_data.w32->hourglass_window);
XFlush (FRAME_X_DISPLAY (f));
FOR_EACH_FRAME (rest, frame)
{
struct frame *f = XFRAME (frame);
-
+
if (FRAME_W32_P (f)
/* Watch out for newly created frames. */
&& f->output_data.x->hourglass_window)
Lisp_Object, Lisp_Object));
static void compute_tip_xy P_ ((struct frame *, Lisp_Object, Lisp_Object,
Lisp_Object, int, int, int *, int *));
-
+
/* The frame of a currently visible tooltip. */
Lisp_Object tip_frame;
tip_window = NULL;
tip_frame = Qnil;
}
-
+
return deleted;
}
Ferase_buffer ();
Finsert (1, &text);
set_buffer_internal_1 (old_buffer);
-
+
FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
record_unwind_protect (unwind_create_tip_frame, frame);
else
font = x_new_font (f, SDATA (font));
}
-
+
/* Try out a font which we hope has bold and italic variations. */
if (!STRINGP (font))
font = x_new_font (f, "-*-Courier New-normal-r-*-*-*-100-*-*-c-*-iso8859-1");
if (NILP (Fframe_parameter (frame, intern ("tooltip"))))
Fmodify_frame_parameters (frame, Fcons (Fcons (intern ("tooltip"), Qt),
Qnil));
-
+
/* Set up faces after all frame parameters are known. This call
also merges in face attributes specified for new frames.
/* Set tip_frame here, so that */
tip_frame = frame;
call1 (Qface_set_after_frame_default, frame);
-
+
if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
Qnil));
}
-
+
f->no_split = 1;
UNGCPRO;
int *root_x, *root_y;
{
Lisp_Object left, top;
-
+
/* User-specified position? */
left = Fcdr (Fassq (Qleft, parms));
top = Fcdr (Fassq (Qtop, parms));
-
+
/* Move the tooltip window where the mouse pointer is. Resize and
show it. */
if (!INTEGERP (left) || !INTEGERP (top))
struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
int old_windows_or_buffers_changed = windows_or_buffers_changed;
int count = SPECPDL_INDEX ();
-
+
specbind (Qinhibit_redisplay, Qt);
GCPRO4 (string, parms, frame, timeout);
dx = make_number (5);
else
CHECK_NUMBER (dx);
-
+
if (NILP (dy))
dy = make_number (-10);
else
&& !NILP (Fequal (last_parms, parms)))
{
struct frame *f = XFRAME (tip_frame);
-
+
/* Only DX and DY have changed. */
if (!NILP (tip_timer))
{
w->width = make_number (80);
w->height = make_number (40);
}
-
+
f->window_width = XINT (w->width);
adjust_glyphs (f);
w->pseudo_window_p = 1;
else
#endif
row_width = row->pixel_width;
-
+
/* TODO: find why tips do not draw along baseline as instructed. */
height += row->height;
width = max (width, row_width);
/* Return quickly if nothing to do. */
if (NILP (tip_timer) && NILP (tip_frame))
return Qnil;
-
+
frame = tip_frame;
timer = tip_timer;
GCPRO2 (frame, timer);
tip_frame = tip_timer = deleted = Qnil;
-
+
count = SPECPDL_INDEX ();
specbind (Qinhibit_redisplay, Qt);
specbind (Qinhibit_quit, Qt);
-
+
if (!NILP (timer))
call1 (Qcancel_timer, timer);
doc: /* If non-zero, the virtual key code for an alternative quit key. */);
XSETINT (Vw32_quit_key, 0);
- DEFVAR_LISP ("w32-pass-lwindow-to-system",
+ DEFVAR_LISP ("w32-pass-lwindow-to-system",
&Vw32_pass_lwindow_to_system,
doc: /* Non-nil if the left \"Windows\" key is passed on to Windows.
When non-nil, the Start menu is opened by tapping the key. */);
Vw32_pass_lwindow_to_system = Qt;
- DEFVAR_LISP ("w32-pass-rwindow-to-system",
+ DEFVAR_LISP ("w32-pass-rwindow-to-system",
&Vw32_pass_rwindow_to_system,
doc: /* Non-nil if the right \"Windows\" key is passed on to Windows.
When non-nil, the Start menu is opened by tapping the key. */);
means that this hack won't interfere with any real key code. */
Vw32_phantom_key_code = 255;
- DEFVAR_LISP ("w32-enable-num-lock",
+ DEFVAR_LISP ("w32-enable-num-lock",
&Vw32_enable_num_lock,
doc: /* Non-nil if Num Lock should act normally.
Set to nil to see Num Lock as the key `kp-numlock'. */);
Vw32_enable_num_lock = Qt;
- DEFVAR_LISP ("w32-enable-caps-lock",
+ DEFVAR_LISP ("w32-enable-caps-lock",
&Vw32_enable_caps_lock,
doc: /* Non-nil if Caps Lock should act normally.
Set to nil to see Caps Lock as the key `capslock'. */);
DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
doc: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
display_hourglass_p = 1;
-
+
DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
doc: /* *Seconds to wait before displaying an hourglass pointer.
Value must be an integer or float. */);
doc: /* Maximum size for tooltips.
Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
-
+
DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager,
doc: /* Non-nil if no window manager is in use.
Emacs doesn't try to figure this out; this is always nil
Qxpm = intern ("xpm");
staticpro (&Qxpm);
#endif
-
+
#if HAVE_JPEG
Qjpeg = intern ("jpeg");
staticpro (&Qjpeg);
-#endif
+#endif
#if HAVE_TIFF
Qtiff = intern ("tiff");
staticpro (&Qtiff);
-#endif
+#endif
#if HAVE_GIF
Qgif = intern ("gif");
#if 0 /* TODO : Image support for W32 */
define_image_type (&gs_type);
#endif
-
+
#if HAVE_XPM
define_image_type (&xpm_type);
#endif
-
+
#if HAVE_JPEG
define_image_type (&jpeg_type);
#endif
-
+
#if HAVE_TIFF
define_image_type (&tiff_type);
#endif
#if HAVE_GIF
define_image_type (&gif_type);
#endif
-
+
#if HAVE_PNG
define_image_type (&png_type);
#endif
#undef abort
-void
+void
w32_abort()
{
int button;
/* If face attributes have been changed since the last redisplay,
free realized faces now because they depend on face definitions
- that might have changed. Don't free faces while there might be
+ that might have changed. Don't free faces while there might be
desired matrices pending which reference these faces. */
if (face_change_count && !inhibit_free_realized_faces)
{
get_next_display_element (it)
struct it *it;
{
- /* Non-zero means that we found an display element. Zero means that
+ /* Non-zero means that we found a display element. Zero means that
we hit the end of what we iterate over. Performance note: the
function pointer `method' used here turns out to be faster than
using a sequence of if-statements. */
redisplay_window_error);
/* Compare desired and current matrices, perform output. */
-
+
update:
/* If fonts changed, display again. */
if (fonts_changed_p)
PROPS is a property list to add to any string we encounter.
- If RISKY is nonzero, remove (disregard) any properties in any string
+ If RISKY is nonzero, remove (disregard) any properties in any string
we encounter, and ignore :eval and :propertize.
If the global variable `frame_title_ptr' is non-NULL, then the output
If COPY_STRING is non-zero, make a copy of LISP_STRING before adding
properties to the string.
- PROPS are the properties to add to the string.
+ PROPS are the properties to add to the string.
The mode_line_string_face face property is always added to the string.
*/
Fadd_text_properties (make_number (0), make_number (len),
props, lisp_string);
}
- else
+ else
{
len = XFASTINT (Flength (lisp_string));
if (precision > 0 && len > precision)
if (len > 0)
{
mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
- n += len;
+ n += len;
}
if (field_width > len)
Fadd_text_properties (make_number (0), make_number (field_width),
props, lisp_string);
mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
- n += field_width;
+ n += field_width;
}
return n;
/* We need a dummy last element in mode_line_string_list to
indicate we are building the propertized mode-line string.
Using mode_line_string_face_prop here GC protects it. */
- mode_line_string_list =
+ mode_line_string_list =
Fcons (mode_line_string_face_prop, Qnil);
frame_title_ptr = NULL;
}
int *width;
{
enum text_cursor_kinds type;
-
+
if (NILP (arg))
return NO_CURSOR;
*width = FRAME_BLINK_OFF_CURSOR_WIDTH (f);
return FRAME_BLINK_OFF_CURSOR (f);
}
-
- /* Finally perform built-in cursor blinking:
+
+ /* Finally perform built-in cursor blinking:
filled box <-> hollow box
wide [h]bar <-> narrow [h]bar
narrow [h]bar <-> no cursor
open to a session manager, just return 0.
Otherwise returns the number of events stored in buffer BUFP,
which can hold up to *NUMCHARS characters. At most one event is
- stored, an SAVE_SESSION_EVENT. */
+ stored, a SAVE_SESSION_EVENT. */
int
x_session_check_input (bufp, numchars)
struct input_event *bufp;
{
SELECT_TYPE read_fds;
EMACS_TIME tmout;
-
+
if (ice_fd == -1) return 0;
-
+
FD_ZERO (&read_fds);
FD_SET (ice_fd, &read_fds);
-
+
tmout.tv_sec = 0;
tmout.tv_usec = 0;
-
+
/* Reset this so wo can check kind after callbacks have been called by
IceProcessMessages. The smc_interact_CB sets the kind to
SAVE_SESSION_EVENT, but we don't know beforehand if that callback
ice_fd = -1;
return 0;
}
-
+
if (FD_ISSET (ice_fd, &read_fds))
IceProcessMessages (SmcGetIceConnection (smc_conn),
(IceReplyWaitInfo *)0, (Bool *)0);
-
+
/* Check if smc_interact_CB was called and we shall generate a
SAVE_SESSION_EVENT. */
if (*numchars > 0 && emacs_event.kind != NO_EVENT)
Bool fast;
{
#define NR_PROPS 5
-
+
SmProp *props[NR_PROPS];
SmProp prop_ptr[NR_PROPS];
-
+
SmPropValue values[20];
int val_idx = 0;
int props_idx = 0;
-
+
char cwd[MAXPATHLEN+1];
char *smid_opt;
props[props_idx]->vals[0].length = strlen (SDATA (Vinvocation_name));
props[props_idx]->vals[0].value = SDATA (Vinvocation_name);
++props_idx;
-
+
/* How to restart Emacs (i.e.: /path/to/emacs --smid=xxxx). */
props[props_idx] = &prop_ptr[props_idx];
props[props_idx]->name = SmRestartCommand;
smid_opt = xmalloc (strlen (SMID_OPT) + strlen (client_id) + 1);
strcpy (smid_opt, SMID_OPT);
strcat (smid_opt, client_id);
-
+
props[props_idx]->vals[1].length = strlen (smid_opt);
props[props_idx]->vals[1].value = smid_opt;
val_idx += 2;
props[props_idx]->vals[0].value = cwd;
++props_idx;
}
-
-
+
+
SmcSetProperties (smcConn, props_idx, props);
xfree (smid_opt);
ice_fd = -1;
return;
}
-
+
ice_fd = IceConnectionNumber (iceConn);
#ifndef F_SETOWN_BUG
#ifdef F_SETOWN
char* previous_id = NULL;
SmcCallbacks callbacks;
int name_len = 0;
-
+
/* Check if we where started by the session manager. If so, we will
have a previous id. */
if (! EQ (Vx_session_previous_id, Qnil) && STRINGP (Vx_session_previous_id))
if (! EQ (Vinvocation_directory, Qnil))
strcpy (emacs_program, SDATA (Vinvocation_directory));
strcat (emacs_program, SDATA (Vinvocation_name));
-
+
/* The SM protocol says all callbacks are mandatory, so set up all
here and in the mask passed to SmcOpenConnection */
callbacks.save_yourself.callback = smc_save_yourself_CB;
DEFUN ("handle-save-session", Fhandle_save_session,
Shandle_save_session, 1, 1, "e",
doc: /* Handle the save_yourself event from a session manager.
-A session manager can tell Emacs that the window system is shutting down
+A session manager can tell Emacs that the window system is shutting down
by sending Emacs a save_yourself message. Emacs executes this function when
such an event occurs. This function then executes `emacs-session-save'.
After that, this function informs the session manager that it can continue
DEFVAR_LISP ("x-session-previous-id", &Vx_session_previous_id,
doc: /* The previous session id Emacs got from session manager.
-If Emacs is running on a window system that has a session manager, the
-session manager gives Emacs a session id. It is feasible for Emacs lisp
-code to use the session id to save configuration in, for example, a file
-with a file name based on the session id. If Emacs is running when the
-window system is shut down, the session manager remembers that Emacs was
+If Emacs is running on a window system that has a session manager, the
+session manager gives Emacs a session id. It is feasible for Emacs lisp
+code to use the session id to save configuration in, for example, a file
+with a file name based on the session id. If Emacs is running when the
+window system is shut down, the session manager remembers that Emacs was
running and saves the session id Emacs had.
-When the window system is started again, the session manager restarts
-Emacs and hands Emacs the session id it had the last time it was
-running. This is now the previous session id and the value of this
-variable. If configuration was saved in a file as stated above, the
+When the window system is started again, the session manager restarts
+Emacs and hands Emacs the session id it had the last time it was
+running. This is now the previous session id and the value of this
+variable. If configuration was saved in a file as stated above, the
previous session id shall be used to reconstruct the file name.
-The session id Emacs has while it is running is in the variable
+The session id Emacs has while it is running is in the variable
`x-session-id'. The value of this variable and `x-session-id' may be the
same, depending on how the session manager works.
See also `emacs-save-session-functions', `emacs-session-save' and
`emacs-session-restore'." */);
Vx_session_previous_id = Qnil;
-
+
defsubr (&Shandle_save_session);
}
/* If a string, XTread_socket generates an event to display that string.
(The display is done in read_char.) */
-
+
static Lisp_Object help_echo;
static Lisp_Object help_echo_window;
static Lisp_Object help_echo_object;
static String Xt_default_resources[] = {0};
#endif /* USE_X_TOOLKIT */
-/* Nominal cursor position -- where to draw output.
+/* Nominal cursor position -- where to draw output.
HPOS and VPOS are window relative glyph matrix coordinates.
X and Y are window relative pixel coordinates. */
static void x_update_window_cursor P_ ((struct window *, int));
static void x_erase_phys_cursor P_ ((struct window *));
void x_display_and_set_cursor P_ ((struct window *, int, int, int, int, int));
-static void x_draw_fringe_bitmap P_ ((struct window *, struct glyph_row *,
+static void x_draw_fringe_bitmap P_ ((struct window *, struct glyph_row *,
enum fringe_bitmap_type, int left_p));
static void x_clip_to_row P_ ((struct window *, struct glyph_row *,
XTread_socket calls XPending. Removing XFlush improves
performance. */
-#define XFlush(DISPLAY) (void) 0
+#define XFlush(DISPLAY) (void) 0
\f
/***********************************************************************
/* This is a function useful for recording debugging information about
the sequence of occurrences in this file. */
-struct record
+struct record
{
char *locus;
int type;
/***********************************************************************
Starting and ending an update
***********************************************************************/
-
+
/* Start an update of frame F. This function is installed as a hook
for update_begin, i.e. it is called when update_begin is called.
This function is called prior to calls to x_update_window_begin for
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
struct x_display_info *display_info = FRAME_X_DISPLAY_INFO (f);
-
+
updated_window = w;
set_output_cursor (&w->cursor);
flag set. So, rows containing mouse-face glyphs are never
scrolled, and we don't have to switch the mouse highlight off
here to prevent it from being scrolled. */
-
+
/* Can we tell that this update does not affect the window
where the mouse highlight is? If so, no need to turn off.
Likewise, don't do anything if the frame is garbaged;
struct window *w;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
-
+
/* Redraw borders between horizontally adjacent windows. Don't
do it for frames with vertical scroll bars because either the
right scroll bar of a window, or the left scroll bar of its
window_box_edges (w, -1, &x0, &y0, &x1, &y1);
x1 += FRAME_X_RIGHT_FRINGE_WIDTH (f);
y1 -= 1;
-
- XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+
+ XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
f->output_data.x->normal_gc, x1, y0, x1, y1);
}
}
-
-
+
+
/* End update of window W (which is equal to updated_window).
Draw vertical borders between horizontally adjacent windows, and
int cursor_on_p, mouse_face_overwritten_p;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
-
+
if (!w->pseudo_window_p)
{
BLOCK_INPUT;
x_display_and_set_cursor (w, 1, output_cursor.hpos,
output_cursor.vpos,
output_cursor.x, output_cursor.y);
-
+
x_draw_vertical_border (w);
UNBLOCK_INPUT;
}
-
+
/* If a row with mouse-face was overwritten, arrange for
XTframe_up_to_date to redisplay the mouse highlight. */
if (mouse_face_overwritten_p)
dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
dpyinfo->mouse_face_window = Qnil;
}
-
+
updated_window = NULL;
}
struct window *w = updated_window;
struct frame *f;
int width, height;
-
+
xassert (w);
-
+
if (!desired_row->mode_line_p && !w->pseudo_window_p)
{
BLOCK_INPUT;
x_draw_row_fringe_bitmaps (w, desired_row);
UNBLOCK_INPUT;
}
-
+
/* When a window has disappeared, make sure that no rest of
full-width rows stays visible in the internal border. Could
check here if updated_window is the leftmost/rightmost window,
if (WINDOWP (f->tool_bar_window)
&& w == XWINDOW (f->tool_bar_window))
y -= width;
-
+
BLOCK_INPUT;
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
0, y, width, height, False);
h = left_height;
bits = left_bits;
break;
-
+
case OVERLAY_ARROW_BITMAP:
wd = ov_width;
h = ov_height;
bits = ov_bits;
break;
-
+
case RIGHT_TRUNCATION_BITMAP:
wd = right_width;
h = right_height;
h = continued_height;
bits = continued_bits;
break;
-
+
case CONTINUATION_LINE_BITMAP:
wd = continuation_width;
h = continuation_height;
if (b1 >= 0)
{
int header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
-
+
/* In case the same realized face is used for fringes and
for something displayed in the text (e.g. face `region' on
mono-displays, the fill style may have been changed to
XSetFillStyle (display, face->gc, FillOpaqueStippled);
else
XSetForeground (display, face->gc, face->background);
-
+
XFillRectangle (display, window, face->gc,
b1,
WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
XCopyArea (display, pixmap, window, gc, 0, 0, wd, h, x, y + dy);
XFreePixmap (display, pixmap);
}
-
+
XSetClipMask (display, gc, None);
}
HPOS and VPOS are column/row positions in a window glyph matrix. X
and Y are window text area relative pixel positions.
-
+
If this is done during an update, updated_window will contain the
window that is being updated and the position is the future output
cursor position for that window. If updated_window is null, use
ccl->reg[1] = char2b->byte1;
ccl->reg[2] = char2b->byte2;
}
-
+
ccl_driver (ccl, NULL, NULL, 0, 0, NULL);
-
+
/* We assume that MSBs are appropriately set/reset by CCL
program. */
if (font->max_byte1 == 0) /* 1-byte font */
/* Fixed encoding scheme. See fontset.h for the meaning of the
encoding numbers. */
int enc = font_info->encoding[charset];
-
+
if ((enc == 1 || enc == 2)
&& CHARSET_DIMENSION (charset) == 2)
char2b->byte1 |= 0x80;
-
+
if (enc == 1 || enc == 3)
char2b->byte2 |= 0x80;
}
else
{
int c1, c2, charset;
-
+
/* Split characters into bytes. If c2 is -1 afterwards, C is
really a one-byte character so that byte1 is zero. */
SPLIT_CHAR (c, charset, c1, c2);
xassert (face != NULL);
PREPARE_FACE_FOR_DISPLAY (f, face);
}
-
+
return face;
}
else
{
int c1, c2, charset;
-
+
/* Split characters into bytes. If c2 is -1 afterwards, C is
really a one-byte character so that byte1 is zero. */
SPLIT_CHAR (glyph->u.ch, charset, c1, c2);
}
-/* Store one glyph for IT->char_to_display in IT->glyph_row.
+/* Store one glyph for IT->char_to_display in IT->glyph_row.
Called from x_produce_glyphs when IT->glyph_row is non-null. */
static INLINE void
{
struct glyph *glyph;
enum glyph_row_area area = it->area;
-
+
xassert (it->glyph_row);
xassert (it->char_to_display != '\n' && it->char_to_display != '\t');
-
+
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
}
}
-/* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
+/* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
Called from x_produce_glyphs when IT->glyph_row is non-null. */
static INLINE void
{
struct glyph *glyph;
enum glyph_row_area area = it->area;
-
+
xassert (it->glyph_row);
-
+
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
it->pixel_width = img->width + 2 * img->hmargin;
it->nglyphs = 1;
-
+
if (face->box != FACE_NO_BOX)
{
if (face->box_line_width > 0)
it->ascent += face->box_line_width;
it->descent += face->box_line_width;
}
-
+
if (it->start_of_box_run_p)
it->pixel_width += abs (face->box_line_width);
if (it->end_of_box_run_p)
}
take_vertical_position_into_account (it);
-
+
if (it->glyph_row)
{
struct glyph *glyph;
enum glyph_row_area area = it->area;
-
+
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
/* Append a stretch glyph to IT->glyph_row. OBJECT is the source
- of the glyph, WIDTH and HEIGHT are the width and height of the
- stretch. ASCENT is the percentage/100 of HEIGHT to use for the
+ of the glyph, WIDTH and HEIGHT are the width and height of the
+ stretch. ASCENT is the percentage/100 of HEIGHT to use for the
ascent of the glyph (0 <= ASCENT <= 1). */
-
+
static void
x_append_stretch_glyph (it, object, width, height, ascent)
struct it *it;
enum glyph_row_area area = it->area;
xassert (ascent >= 0 && ascent <= 1);
-
+
glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
if (glyph < it->glyph_row->glyphs[area + 1])
{
being recognized:
1. `:width WIDTH' specifies that the space should be WIDTH *
- canonical char width wide. WIDTH may be an integer or floating
+ canonical char width wide. WIDTH may be an integer or floating
point number.
2. `:relative-width FACTOR' specifies that the width of the stretch
3. `:align-to HPOS' specifies that the space should be wide enough
to reach HPOS, a value in canonical character units.
- Exactly one of the above pairs must be present.
+ Exactly one of the above pairs must be present.
4. `:height HEIGHT' specifies that the height of the stretch produced
should be HEIGHT, measured in canonical character units.
XFontStruct *font = face->font ? face->font : FRAME_FONT (it->f);
PREPARE_FACE_FOR_DISPLAY (it->f, face);
-
+
/* List should start with `space'. */
xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
plist = XCDR (it->object);
property. */
struct it it2;
unsigned char *p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
-
+
it2 = *it;
if (it->multibyte_p)
{
else
/* Nothing specified -> width defaults to canonical char width. */
width = CANON_X_UNIT (it->f);
-
+
/* Compute height. */
if (prop = Fplist_get (plist, QCheight),
NUMVAL (prop) > 0)
else
height = FONT_HEIGHT (font);
- /* Compute percentage of height used for ascent. If
+ /* Compute percentage of height used for ascent. If
`:ascent ASCENT' is present and valid, use that. Otherwise,
derive the ascent from the font in use. */
if (prop = Fplist_get (plist, QCascent),
it->ascent += face->box_line_width;
it->descent += face->box_line_width;
}
-
+
if (it->start_of_box_run_p)
it->pixel_width += abs (face->box_line_width);
if (it->end_of_box_run_p)
it->pixel_width += abs (face->box_line_width);
}
-
+
take_vertical_position_into_account (it);
}
face = FACE_FROM_ID (it->f, it->face_id);
}
}
-
+
/* Get font to use. Encode IT->char_to_display. */
x_get_char_face_and_encoding (it->f, it->char_to_display,
it->face_id, &char2b,
if (face->box != FACE_NO_BOX)
{
int thick = face->box_line_width;
-
+
if (thick > 0)
{
it->ascent += thick;
it->ascent += 2;
take_vertical_position_into_account (it);
-
+
/* If we have to actually produce glyphs, do it. */
if (it->glyph_row)
{
/* Translate a space with a `space-width' property
into a stretch glyph. */
double ascent = (double) font->ascent / FONT_HEIGHT (font);
- x_append_stretch_glyph (it, it->object, it->pixel_width,
+ x_append_stretch_glyph (it, it->object, it->pixel_width,
it->ascent + it->descent, ascent);
}
else
it->nglyphs = 0;
it->ascent = it->phys_ascent = font->ascent + boff;
it->descent = it->phys_descent = font->descent - boff;
-
+
if (face->box != FACE_NO_BOX
&& face->box_line_width > 0)
{
tab stop after that. */
if (next_tab_x - x < CANON_X_UNIT (it->f))
next_tab_x += tab_width;
-
+
it->pixel_width = next_tab_x - x;
it->nglyphs = 1;
it->ascent = it->phys_ascent = font->ascent + boff;
it->descent = it->phys_descent = font->descent - boff;
-
+
if (it->glyph_row)
{
double ascent = (double) it->ascent / (it->ascent + it->descent);
- x_append_stretch_glyph (it, it->object, it->pixel_width,
+ x_append_stretch_glyph (it, it->object, it->pixel_width,
it->ascent + it->descent, ascent);
}
}
- else
+ else
{
/* A multi-byte character. Assume that the display width of the
character is the width of the character multiplied by the
}
else
thick = - thick;
-
+
if (it->start_of_box_run_p)
it->pixel_width += thick;
if (it->end_of_box_run_p)
it->pixel_width += thick;
}
-
+
/* If face has an overline, add the height of the overline
(1 pixel) and a 1 pixel margin to the character height. */
if (face->overline_p)
it->ascent += 2;
take_vertical_position_into_account (it);
-
+
if (it->glyph_row)
x_append_glyph (it);
}
{
it->char_to_display = unibyte_char_to_multibyte (it->c);
}
-
+
/* Get face and font to use. Encode IT->char_to_display. */
it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
face = FACE_FROM_ID (it->f, it->face_id);
ascent = font->ascent;
descent = font->descent;
}
-
+
rightmost = width;
lowest = - descent + boff;
highest = ascent + boff;
leftmost = 0;
-
+
if (font_info
&& font_info->default_ascent
&& CHAR_TABLE_P (Vuse_default_ascent)
int left, right, btm, top;
int ch = COMPOSITION_GLYPH (cmp, i);
int face_id = FACE_FOR_CHAR (it->f, face, ch);
-
+
face = FACE_FROM_ID (it->f, face_id);
x_get_char_face_and_encoding (it->f, ch, face->id, &char2b,
it->multibyte_p, 0);
}
else
thick = - thick;
-
+
if (it->start_of_box_run_p)
it->pixel_width += thick;
if (it->end_of_box_run_p)
it->pixel_width += thick;
}
-
+
/* If face has an overline, add the height of the overline
(1 pixel) and a 1 pixel margin to the character height. */
if (face->overline_p)
it->ascent += 2;
take_vertical_position_into_account (it);
-
+
if (it->glyph_row)
x_append_composite_glyph (it);
}
xassert (it->ascent >= 0 && it->descent >= 0);
if (it->area == TEXT_AREA)
it->current_x += it->pixel_width;
-
+
it->descent += it->extra_line_spacing;
-
+
it->max_ascent = max (it->max_ascent, it->ascent);
it->max_descent = max (it->max_descent, it->descent);
it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
height += 2 * face->box_line_width;
}
}
-
+
return height;
}
static void x_init_glyph_string P_ ((struct glyph_string *,
XChar2b *, struct window *,
struct glyph_row *,
- enum glyph_row_area, int,
+ enum glyph_row_area, int,
enum draw_glyphs_face));
static int x_draw_glyphs P_ ((struct window *, int , struct glyph_row *,
enum glyph_row_area, int, int,
/* Set up S->gc of glyph string S for drawing text in mouse face. */
-
+
static void
x_set_mouse_face_gc (s)
struct glyph_string *s;
-{
+{
int face_id;
struct face *face;
face = FACE_FROM_ID (s->f, face_id);
if (face == NULL)
face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
-
+
if (s->first_glyph->type == CHAR_GLYPH)
face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch);
else
but font FONT. */
XGCValues xgcv;
unsigned long mask;
-
+
xgcv.background = s->face->background;
xgcv.foreground = s->face->foreground;
IF_DEBUG (x_check_font (s->f, s->font));
xgcv.font = s->font->fid;
xgcv.graphics_exposures = False;
mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
-
+
if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
mask, &xgcv);
else
FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc
= XCreateGC (s->display, s->window, mask, &xgcv);
-
+
s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
}
static INLINE void
x_set_mode_line_face_gc (s)
struct glyph_string *s;
-{
+{
s->gc = s->face->gc;
}
struct glyph_string *s;
{
PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
-
+
if (s->hl == DRAW_NORMAL_TEXT)
{
s->gc = s->face->gc;
{
/* Draw full-width. X coordinates are relative to S->w->left. */
int canon_x = CANON_X_UNIT (s->f);
-
+
r->x = WINDOW_LEFT_MARGIN (s->w) * canon_x;
r->width = XFASTINT (s->w->width) * canon_x;
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s->f))
r->x -= width;
}
-
+
r->x += FRAME_INTERNAL_BORDER_WIDTH (s->f);
-
+
/* Unless displaying a mode or menu bar line, which are always
fully visible, clip to the visible part of the row. */
if (s->w->pseudo_window_p)
/* Compute overhangs and x-positions for glyph string S and its
predecessors, or successors. X is the starting x-position for S.
BACKWARD_P non-zero means process predecessors. */
-
+
static void
x_compute_overhangs_and_x (s, x, backward_p)
struct glyph_string *s;
int *left, *right;
{
*left = *right = 0;
-
+
if (glyph->type == CHAR_GLYPH)
{
XFontStruct *font;
struct glyph_string *s;
{
int k;
-
+
if (s->left_overhang)
{
int x = 0, i;
struct glyph *glyphs = s->row->glyphs[s->area];
int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
int end = s->row->used[s->area];
-
+
for (i = first; i < end && s->right_overhang > x; ++i)
x += glyphs[i].pixel_width;
struct x_display_info *dpyinfo;
Lisp_Object tail;
struct frame *f;
-
+
dpyinfo = x_display_info_for_display (XtDisplay (widget));
-
+
/* Find the top-level shell of the widget. Note that this function
can be called when the widget is not yet realized, so XtWindow
(widget) == 0. That's the reason we can't simply use
{
String params[1];
Cardinal nparams = 1;
-
+
params[0] = color_name;
XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
"badValue", "cvt_string_to_pixel",
to->size = sizeof (Pixel);
return False;
}
-
+
*(Pixel *) to->addr = pixel;
}
else
cvt_string_to_pixel_value = pixel;
to->addr = (XtPointer) &cvt_string_to_pixel_value;
}
-
+
to->size = sizeof (Pixel);
return True;
}
{
Screen *screen = dpyinfo->screen;
int i;
-
+
dpyinfo->ncolor_cells
= XDisplayCells (dpy, XScreenNumberOfScreen (screen));
dpyinfo->color_cells
= (XColor *) xmalloc (dpyinfo->ncolor_cells
* sizeof *dpyinfo->color_cells);
-
+
for (i = 0; i < dpyinfo->ncolor_cells; ++i)
dpyinfo->color_cells[i].pixel = i;
-
+
XQueryColors (dpy, dpyinfo->cmap,
dpyinfo->color_cells, dpyinfo->ncolor_cells);
}
{
x_query_colors (f, color, 1);
}
-
+
/* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
exact match can't be allocated, try the nearest color available.
nearest_delta = delta;
}
}
-
+
color->red = cells[nearest].red;
color->green = cells[nearest].green;
color->blue = cells[nearest].blue;
change in the colormap, so clear the color cache. */
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
XColor *cached_color;
-
+
if (dpyinfo->color_cells
&& (cached_color = &dpyinfo->color_cells[color->pixel],
(cached_color->red != color->red
if (rc)
register_color (color->pixel);
#endif /* DEBUG_X_COLORS */
-
+
return rc;
}
/* If we end up with the same color as before, try adding
delta to the RGB values. */
x_free_colors (f, &new.pixel, 1);
-
+
new.red = min (0xffff, delta + color.red);
new.green = min (0xffff, delta + color.green);
new.blue = min (0xffff, delta + color.blue);
success_p = 1;
*pixel = new.pixel;
}
-
+
return success_p;
}
DELTA lighter or darker than the relief's background which is found
in S->f->output_data.x->relief_background. If such a color cannot
be allocated, use DEFAULT_PIXEL, instead. */
-
+
static void
x_setup_relief_color (f, relief, factor, delta, default_pixel)
struct frame *f;
relief->allocated_p = 1;
xgcv.foreground = relief->pixel = pixel;
}
-
+
if (relief->gc == 0)
{
xgcv.stipple = dpyinfo->gray;
else
{
XGCValues xgcv;
-
+
/* Get the background color of the face. */
XGetGCValues (s->display, s->gc, GCBackground, &xgcv);
color = xgcv.background;
Window window = FRAME_X_WINDOW (f);
int i;
GC gc;
-
+
if (raised_p)
gc = f->output_data.x->white_relief.gc;
else
else
gc = f->output_data.x->white_relief.gc;
XSetClipRectangles (dpy, gc, 0, 0, clip_rect, 1, Unsorted);
-
+
/* Bottom. */
for (i = 0; i < width; ++i)
XDrawLine (dpy, window, gc,
left_x + i * left_p, bottom_y - i,
right_x + 1 - i * right_p, bottom_y - i);
-
+
/* Right. */
if (right_p)
for (i = 0; i < width; ++i)
XRectangle *clip_rect;
{
XGCValues xgcv;
-
+
XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
XSetForeground (s->display, s->gc, s->face->box_color);
XSetClipRectangles (s->display, s->gc, 0, 0, clip_rect, 1, Unsorted);
-
+
/* Top. */
XFillRectangle (s->display, s->window, s->gc,
left_x, top_y, right_x - left_x + 1, width);
/* Bottom. */
XFillRectangle (s->display, s->window, s->gc,
left_x, bottom_y - width + 1, right_x - left_x + 1, width);
-
+
/* Right. */
if (right_p)
XFillRectangle (s->display, s->window, s->gc,
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s->f))
last_x += FRAME_SCROLL_BAR_WIDTH (s->f) * CANON_X_UNIT (s->f);
}
-
+
/* The glyph that may have a right box line. */
last_glyph = (s->cmp || s->img
? s->first_glyph
xgcv.clip_y_origin = y;
xgcv.function = GXcopy;
XChangeGC (s->display, s->gc, mask, &xgcv);
-
+
x_get_glyph_string_clip_rect (s, &clip_rect);
image_rect.x = x;
image_rect.y = y;
if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
r.x - x, r.y - y, r.width, r.height, r.x, r.y);
-
+
/* When the image has a mask, we can expect that at
least part of a mouse highlight or a block cursor will
be visible. If the image doesn't have a mask, make
XRectangle r;
int x;
int y = s->ybase - image_ascent (s->img, s->face);
-
+
/* If first glyph of S has a left box line, start drawing it to the
right of that line. */
if (s->face->box != FACE_NO_BOX
x = s->x + abs (s->face->box_line_width);
else
x = s->x;
-
+
/* If there is a margin around the image, adjust x- and y-position
by that margin. */
x += s->img->hmargin;
y += s->img->vmargin;
-
+
if (s->hl == DRAW_IMAGE_SUNKEN
|| s->hl == DRAW_IMAGE_RAISED)
{
thick = abs (s->img->relief);
raised_p = s->img->relief > 0;
}
-
+
x0 = x - thick;
y0 = y - thick;
x1 = x + s->img->width + thick - 1;
y1 = y + s->img->height + thick - 1;
-
+
x_setup_relief_colors (s);
x_get_glyph_string_clip_rect (s, &r);
x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p, 1, 1, &r);
{
XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
0, 0, s->img->width, s->img->height, x, y);
-
+
/* When the image has a mask, we can expect that at
least part of a mouse highlight or a block cursor will
be visible. If the image doesn't have a mask, make
}
-/* Draw image glyph string S.
+/* Draw image glyph string S.
s->y
s->x +-------------------------
x = s->x + box_line_hwidth;
else
x = s->x;
-
+
y = s->y + box_line_vwidth;
-
+
if (s->img->mask)
{
/* Create a pixmap as large as the glyph string. Fill it
pixmap = XCreatePixmap (s->display, s->window,
s->background_width,
s->height, depth);
-
+
/* Don't clip in the following because we're working on the
pixmap. */
XSetClipMask (s->display, s->gc, None);
}
else
x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
-
+
s->background_filled_p = 1;
}
}
else
gc = s->face->gc;
-
+
x_get_glyph_string_clip_rect (s, &r);
XSetClipRectangles (s->display, gc, 0, 0, &r, 1, Unsorted);
-
+
if (s->face->stipple)
{
/* Fill background with a stipple pattern. */
else if (!s->background_filled_p)
x_draw_glyph_string_bg_rect (s, s->x, s->y, s->background_width,
s->height);
-
+
s->background_filled_p = 1;
}
ROUND ((maximum descent) / 2), with
ROUND(x) = floor (x + 0.5) */
-
+
if (x_use_underline_position_properties
&& XGetFontProperty (s->font, XA_UNDERLINE_POSITION, &tem))
y = s->ybase + (long) tem;
y = s->ybase + (s->face->font->max_bounds.descent + 1) / 2;
else
y = s->y + s->height - h;
-
+
if (s->face->underline_defaulted_p)
XFillRectangle (s->display, s->window, s->gc,
s->x, y, s->width, h);
XSetForeground (s->display, s->gc, xgcv.foreground);
}
}
-
+
/* Draw strike-through. */
if (s->face->strike_through_p)
{
XSetForeground (s->display, s->gc, xgcv.foreground);
}
}
-
+
/* Draw relief if not yet drawn. */
if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
x_draw_glyph_string_box (s);
}
-
+
/* Reset clipping. */
XSetClipMask (s->display, s->gc, None);
}
/* Fill glyph string S with composition components specified by S->cmp.
-
+
FACES is an array of faces for all components of this composition.
S->gidx is the index of the first component for S.
OVERLAPS_P non-zero means S should draw the foreground only, and
xassert (s);
s->for_overlaps_p = overlaps_p;
-
+
s->face = faces[s->gidx];
s->font = s->face->font;
s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
/* Adjust base line for subscript/superscript text. */
s->ybase += s->first_glyph->voffset;
-
+
xassert (s->face && s->face->gc);
/* This glyph string must always be drawn with 16-bit functions. */
/* Fill glyph string S from a sequence of character glyphs.
-
+
FACE_ID is the face id of the string. START is the index of the
first glyph to consider, END is the index of the last + 1.
OVERLAPS_P non-zero means S should draw the foreground only, and
struct glyph *glyph, *last;
int voffset;
int glyph_not_available_p;
-
+
xassert (s->f == XFRAME (s->w->frame));
xassert (s->nchars == 0);
xassert (start >= 0 && end > start);
glyph = s->row->glyphs[s->area] + start;
last = s->row->glyphs[s->area] + end;
voffset = glyph->voffset;
-
+
glyph_not_available_p = glyph->glyph_not_available_p;
while (glyph < last
s->font = s->face->font;
s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
-
+
/* If the specified font could not be loaded, use the frame's font,
but record the fact that we couldn't load it in
S->font_not_found_p so that we can draw rectangles for the
s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
s->font = s->face->font;
s->width = s->first_glyph->pixel_width;
-
+
/* Adjust base line for subscript/superscript text. */
s->ybase += s->first_glyph->voffset;
}
{
struct glyph *glyph, *last;
int voffset, face_id;
-
+
xassert (s->first_glyph->type == STRETCH_GLYPH);
-
+
glyph = s->row->glyphs[s->area] + start;
last = s->row->glyphs[s->area] + end;
face_id = glyph->face_id;
&& glyph->face_id == face_id);
++glyph)
s->width += glyph->pixel_width;
-
+
/* Adjust base line for subscript/superscript text. */
s->ybase += voffset;
and area within the row from which S is constructed. START is the
index of the first glyph structure covered by S. HL is a
face-override for drawing S. */
-
+
static void
x_init_glyph_string (s, char2b, w, row, area, start, hl)
struct glyph_string *s;
/* Display the internal border below the tool-bar window. */
if (s->w == XWINDOW (s->f->tool_bar_window))
s->y -= s->f->output_data.x->internal_border_width;
-
+
s->ybase = s->y + row->ascent;
}
/* If the face of this glyph string has to be drawn to the end of
the drawing area, set S->extends_to_end_of_line_p. */
struct face *default_face = FACE_FROM_ID (s->f, DEFAULT_FACE_ID);
-
+
if (start == s->row->used[s->area]
&& s->area == TEXT_AREA
&& ((s->hl == DRAW_NORMAL_TEXT
|| ((s->hl == DRAW_IMAGE_RAISED || s->hl == DRAW_IMAGE_SUNKEN)
&& s->row->fill_line_p)))
s->extends_to_end_of_line_p = 1;
-
+
/* If S extends its face to the end of the line, set its
background_width to the distance to the right edge of the drawing
area. */
OVERLAPS_P); \
} \
while (0)
-
+
/* Add a glyph string for a composite sequence to the list of strings
between HEAD and TAIL. START is the index of the first glyph in
++START; \
s = first_s; \
} while (0)
-
+
/* Build a list of glyph strings between HEAD and TAIL for the glyphs
of AREA of glyph row ROW on window W between indices START and END.
and clip to the physical height of ROW.
Value is the x-position reached, relative to AREA of W. */
-
+
static int
x_draw_glyphs (w, x, row, area, start, end, hl, overlaps_p)
struct window *w;
/* Prepend glyph strings for glyphs in front of the first glyph
string that are overwritten because of the first glyph
string's left overhang. The background of all strings
- prepended must be drawn because the first glyph string
+ prepended must be drawn because the first glyph string
draws over it. */
i = x_left_overwritten (head);
if (i >= 0)
{
int x0 = head ? head->x : x;
int x1 = tail ? tail->x + tail->background_width : x;
-
+
x0 = FRAME_TO_WINDOW_PIXEL_X (w, x0);
x1 = FRAME_TO_WINDOW_PIXEL_X (w, x1);
-
+
if (XFASTINT (w->left_margin_width) != 0)
{
int left_area_width = window_box_width (w, LEFT_MARGIN_AREA);
if (area > TEXT_AREA)
x_reached -= window_box_width (w, TEXT_AREA);
}
-
+
return x_reached;
}
enum glyph_row_area area;
{
int i, x;
-
+
BLOCK_INPUT;
-
+
if (area == LEFT_MARGIN_AREA)
x = 0;
else if (area == TEXT_AREA)
++i;
}
}
-
+
UNBLOCK_INPUT;
}
xassert (updated_window && updated_row);
BLOCK_INPUT;
-
+
/* Write glyphs. */
hpos = start - updated_row->glyphs[updated_area];
updated_window->phys_cursor_on_p = 0;
UNBLOCK_INPUT;
-
+
/* Advance the output cursor. */
output_cursor.hpos += len;
output_cursor.x = x;
hpos = start - row->glyphs[updated_area];
x_draw_glyphs (w, output_cursor.x, row, updated_area, hpos, hpos + len,
DRAW_NORMAL_TEXT, 0);
-
+
/* Advance the output cursor. */
output_cursor.hpos += len;
output_cursor.x += shift_by_width;
struct window *w = updated_window;
int max_x, min_y, max_y;
int from_x, from_y, to_y;
-
+
xassert (updated_window && updated_row);
f = XFRAME (w->frame);
-
+
if (updated_row->full_width_p)
{
max_x = XFASTINT (w->width) * CANON_X_UNIT (f);
to_x = min (to_x, max_x);
to_y = min (max_y, output_cursor.y + updated_row->height);
-
+
/* Notice if the cursor will be cleared by this operation. */
if (!updated_row->full_width_p)
notice_overwritten_cursor (w, updated_area,
MATRIX_ROW_BOTTOM_Y (updated_row));
from_x = output_cursor.x;
-
+
/* Translate to frame coordinates. */
if (updated_row->full_width_p)
{
from_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, from_x);
to_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, to_x);
}
-
+
min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
-
+
/* Prevent inadvertently clearing to end of the X window. */
if (to_x > from_x && to_y > from_y)
{
y.tv_usec -= 1000000 * nsec;
y.tv_sec += nsec;
}
-
+
if (x.tv_usec - y.tv_usec > 1000000)
{
int nsec = (y.tv_usec - x.tv_usec) / 1000000;
width, flash_height);
}
else
- /* If it is short, flash it all. */
+ /* If it is short, flash it all. */
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
width, flash_height);
}
else
- /* If it is short, flash it all. */
+ /* If it is short, flash it all. */
XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
XTring_bell ()
{
struct frame *f = SELECTED_FRAME ();
-
+
if (FRAME_X_DISPLAY (f))
{
#if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
}
BLOCK_INPUT;
-
+
/* Cursor off. Will be switched on again in x_update_window_end. */
updated_window = w;
x_clear_cursor (w);
x, from_y,
width, height,
x, to_y);
-
+
UNBLOCK_INPUT;
}
/***********************************************************************
Exposure Events
***********************************************************************/
-
+
/* Redisplay an exposed area of frame F. X and Y are the upper-left
corner of the exposed rectangle. W and H are width and height of
the exposed area. All are pixel values. W or H zero means redraw
{
struct frame *f = XFRAME (w->frame);
int mouse_face_overwritten_p = 0;
-
+
while (w && !FRAME_GARBAGED_P (f))
{
if (!NILP (w->hchild))
|= expose_window_tree (XWINDOW (w->vchild), r);
else
mouse_face_overwritten_p |= expose_window (w, r);
-
+
w = NILP (w->next) ? NULL : XWINDOW (w->next);
}
x += first->pixel_width;
++first;
}
-
+
/* Find the last one. */
last = first;
first_x = x;
x += last->pixel_width;
++last;
}
-
+
/* Repaint. */
if (last > first)
x_draw_glyphs (w, first_x - start_x, row, area,
DRAW_NORMAL_TEXT, 0);
}
}
-
+
/* Redraw the parts of the glyph row ROW on window W intersecting
rectangle R. R is in window-relative coordinates. Value is
XRectangle *r;
{
xassert (row->enabled_p);
-
+
if (row->mode_line_p || w->pseudo_window_p)
x_draw_glyphs (w, 0, row, TEXT_AREA, 0, row->used[TEXT_AREA],
DRAW_NORMAL_TEXT, 0);
struct glyph_row *last_overlapping_row;
{
struct glyph_row *row;
-
+
for (row = first_overlapping_row; row <= last_overlapping_row; ++row)
if (row->overlapping_p)
{
xassert (row->enabled_p && !row->mode_line_p);
-
+
if (row->used[LEFT_MARGIN_AREA])
x_fix_overlapping_area (w, row, LEFT_MARGIN_AREA);
-
+
if (row->used[TEXT_AREA])
x_fix_overlapping_area (w, row, TEXT_AREA);
-
+
if (row->used[RIGHT_MARGIN_AREA])
x_fix_overlapping_area (w, row, RIGHT_MARGIN_AREA);
}
struct glyph_row *row;
int cursor_cleared_p;
struct glyph_row *first_overlapping_row, *last_overlapping_row;
-
+
TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
r.x, r.y, r.width, r.height));
{
int y0 = row->y;
int y1 = MATRIX_ROW_BOTTOM_Y (row);
-
+
if ((y0 >= r.y && y0 < r.y + r.height)
|| (y1 > r.y && y1 < r.y + r.height)
|| (r.y >= y0 && r.y < y1)
first_overlapping_row = row;
last_overlapping_row = row;
}
-
+
if (expose_line (w, row, &r))
mouse_face_overwritten_p = 1;
}
-
+
if (y1 >= yb)
break;
}
/* Fix the display of overlapping rows. */
if (first_overlapping_row)
expose_overlaps (w, first_overlapping_row, last_overlapping_row);
-
+
/* Draw border between windows. */
x_draw_vertical_border (w);
-
+
/* Turn the cursor on again. */
if (cursor_cleared_p)
x_update_window_cursor (w, 1);
XRectangle *left, *right;
XRectangle *upper, *lower;
int intersection_p = 0;
-
+
/* Rearrange so that R1 is the left-most rectangle. */
if (r1->x < r2->x)
left = r1, right = r2;
if (right->x <= left->x + left->width)
{
result->x = right->x;
-
+
/* The right end of the intersection is the minimum of the
the right ends of left and right. */
result->width = (min (left->x + left->width, right->x + right->width)
if (lower->y <= upper->y + upper->height)
{
result->y = lower->y;
-
+
/* The lower end of the intersection is the minimum of the lower
ends of upper and lower. */
- result->height = (min (lower->y + lower->height,
+ result->height = (min (lower->y + lower->height,
upper->y + upper->height)
- result->y);
intersection_p = 1;
/* Handle FocusIn and FocusOut state changes for FRAME.
If FRAME has focus and there exists more than one frame, puts
- an FOCUS_IN_EVENT into BUFP.
+ a FOCUS_IN_EVENT into BUFP.
Returns number of events inserted into BUFP. */
static int
{
x_new_focus_frame (dpyinfo, frame);
dpyinfo->x_focus_event_frame = frame;
-
+
/* Don't stop displaying the initial startup message
for a switch-frame event we don't need. */
if (numchars > 0
else if (type == FocusOut)
{
frame->output_data.x->focus_state &= ~state;
-
+
if (dpyinfo->x_focus_event_frame == frame)
{
dpyinfo->x_focus_event_frame = 0;
{
struct frame *frame;
int nr_events = 0;
-
+
frame = x_top_window_to_frame (dpyinfo, event->xany.window);
if (! frame) return nr_events;
-
+
switch (event->type)
{
case EnterNotify:
EMACS_UINT mod_hyper = hyper_modifier;
EMACS_UINT mod_super = super_modifier;
Lisp_Object tem;
-
+
tem = Fget (Vx_alt_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_alt = XUINT (tem);
tem = Fget (Vx_meta_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_hyper = XUINT (tem);
tem = Fget (Vx_super_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_super = XUINT (tem);
-
+
return ( ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
| ((state & ControlMask) ? ctrl_modifier : 0)
EMACS_UINT mod_alt = alt_modifier;
EMACS_UINT mod_hyper = hyper_modifier;
EMACS_UINT mod_super = super_modifier;
-
+
Lisp_Object tem;
-
+
tem = Fget (Vx_alt_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_alt = XUINT (tem);
tem = Fget (Vx_meta_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_hyper = XUINT (tem);
tem = Fget (Vx_super_keysym, Qmodifier_value);
if (! EQ (tem, Qnil)) mod_super = XUINT (tem);
-
-
+
+
return ( ((state & mod_alt) ? dpyinfo->alt_mod_mask : 0)
| ((state & mod_super) ? dpyinfo->super_mod_mask : 0)
| ((state & mod_hyper) ? dpyinfo->hyper_mod_mask : 0)
else if (!buffer_only_p || BUFFERP (glyph->object))
break;
}
-
+
x0 += glyph->pixel_width;
++glyph;
}
display area of W, so the width of bitmap areas and scroll bars
must be subtracted to get a position relative to the start of the
mode line. */
-
+
static void
note_mode_line_or_margin_highlight (w, x, y, portion)
struct window *w;
if (STRINGP (string))
{
pos = make_number (charpos);
-
+
/* If we're on a string with `help-echo' text property, arrange
for the help to be displayed. This is done by setting the
global variable help_echo to the help string. */
if (KEYMAPP (map))
cursor = f->output_data.x->nontext_cursor;
}
-
+
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
}
note_mode_line_or_margin_highlight (w, x, y, portion);
return;
}
-
+
if (portion == 2)
cursor = f->output_data.x->horizontal_drag_cursor;
else
if (!NILP (mouse_face))
overlay = overlay_vec[i];
}
-
+
/* If we're actually highlighting the same overlay as
before, there's no need to do that again. */
if (!NILP (overlay)
&& EQ (overlay, dpyinfo->mouse_face_overlay))
goto check_help_echo;
-
+
dpyinfo->mouse_face_overlay = overlay;
/* Clear the display of the old active region, if any. */
&dpyinfo->mouse_face_beg_row,
&dpyinfo->mouse_face_beg_x,
&dpyinfo->mouse_face_beg_y, Qnil);
-
+
dpyinfo->mouse_face_past_end
= !fast_find_position (w, XFASTINT (after),
&dpyinfo->mouse_face_end_col,
after
= Fnext_single_property_change (position, Qmouse_face,
object, end);
-
+
/* Record this as the current active region. */
fast_find_position (w, XFASTINT (before),
&dpyinfo->mouse_face_beg_col,
{
Lisp_Object b, e;
int ignore;
-
+
b = Fprevious_single_property_change (make_number (pos + 1),
Qmouse_face,
object, Qnil);
the text ``under'' it might have. */
struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
int start = MATRIX_ROW_START_CHARPOS (r);
-
+
pos = string_buffer_position (w, object, start);
if (pos > 0)
mouse_face = get_char_property_and_overlay (make_number (pos),
&dpyinfo->mouse_face_beg_x,
&dpyinfo->mouse_face_beg_y,
object);
-
+
dpyinfo->mouse_face_past_end
= !fast_find_position (w, XFASTINT (after),
&dpyinfo->mouse_face_end_col,
{
Lisp_Object object = glyph->object;
int charpos = glyph->charpos;
-
+
/* Try text properties. */
if (STRINGP (object)
&& charpos >= 0
&& charpos < ZV)
help = Fget_text_property (make_number (charpos), Qhelp_echo,
object);
-
+
if (!NILP (help))
{
help_echo = help;
}
}
}
-
+
BEGV = obegv;
ZV = ozv;
current_buffer = obuf;
}
set_cursor:
-
+
if (cursor != None)
XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
}
|| *hpos < dpyinfo->mouse_face_end_col
|| dpyinfo->mouse_face_past_end))
return 0;
-
+
return 1;
}
Lisp_Object enabled_p;
int x = button_event->x;
int y = button_event->y;
-
+
/* If not on the highlighted tool-bar item, return. */
frame_to_window_pixel_xy (w, &x, &y);
if (x_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx) != 0)
enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
if (NILP (enabled_p))
return;
-
+
if (button_event->type == ButtonPress)
{
/* Show item in pressed state. */
goto set_help_echo;
clear_mouse_face (dpyinfo);
-
+
/* Mouse is down, but on different tool-bar item? */
mouse_down_p = (dpyinfo->grabbed
&& f == last_mouse_frame
dpyinfo->mouse_face_image_state = DRAW_NORMAL_TEXT;
draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
-
+
/* If tool-bar item is not enabled, don't highlight it. */
enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
if (!NILP (enabled_p))
row = MATRIX_ROW (w->current_matrix, vpos);
for (i = x = 0; i < hpos; ++i)
x += row->glyphs[TEXT_AREA][i].pixel_width;
-
+
/* Record this as the current active region. */
dpyinfo->mouse_face_beg_col = hpos;
dpyinfo->mouse_face_beg_row = vpos;
dpyinfo->mouse_face_beg_x = x;
dpyinfo->mouse_face_beg_y = row->y;
dpyinfo->mouse_face_past_end = 0;
-
+
dpyinfo->mouse_face_end_col = hpos + 1;
dpyinfo->mouse_face_end_row = vpos;
dpyinfo->mouse_face_end_x = x + glyph->pixel_width;
dpyinfo->mouse_face_end_y = row->y;
dpyinfo->mouse_face_window = window;
dpyinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
-
+
/* Display it as active. */
show_mouse_face (dpyinfo, draw);
dpyinfo->mouse_face_image_state = draw;
}
-
+
set_help_echo:
-
+
/* Set help_echo to a help string to display for this tool-bar item.
XTread_socket does the rest. */
help_echo_object = help_echo_window = Qnil;
#if 0 /* This is a version of fast_find_position that's more correct
in the presence of hscrolling, for example. I didn't install
it right away because the problem fixed is minor, it failed
- in 20.x as well, and I think it's too risky to install
+ in 20.x as well, and I think it's too risky to install
so near the release of 21.1. 2001-09-25 gerd. */
static int
*x = row->x;
*y = row->y;
*vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
-
+
glyph = row->glyphs[TEXT_AREA];
end = glyph + row->used[TEXT_AREA];
-
+
/* Skip over glyphs not having an object at the start of the row.
These are special glyphs like truncation marks on terminal
frames. */
if (row->y + row->height >= yb)
break;
-
+
++row;
++row_vpos;
}
-
+
/* Find the right column within BEST_ROW. */
lastcol = 0;
current_x = best_row->x;
*x += best_glyph->pixel_width;
++*hpos;
}
-
+
*y = best_row->y;
*vpos = best_row - w->current_matrix->rows;
}
first = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_beg_row);
last = MATRIX_ROW (w->current_matrix, dpyinfo->mouse_face_end_row);
-
+
for (row = first; row <= last && row->enabled_p; ++row)
{
int start_hpos, end_hpos, start_x;
if (end_hpos > start_hpos)
{
- x_draw_glyphs (w, start_x, row, TEXT_AREA,
+ x_draw_glyphs (w, start_x, row, TEXT_AREA,
start_hpos, end_hpos, draw, 0);
row->mouse_face_p
struct x_display_info *dpyinfo;
{
int cleared = 0;
-
+
if (!NILP (dpyinfo->mouse_face_window))
{
show_mouse_face (dpyinfo, DRAW_NORMAL_TEXT);
struct glyph_row *end = r + w->current_matrix->nrows - 1;
frame_to_window_pixel_xy (w, &x, &y);
-
+
for (; !found && r < end && r->enabled_p; ++r)
if (r->y >= y)
{
struct glyph *g = r->glyphs[TEXT_AREA];
struct glyph *end = g + r->used[TEXT_AREA];
int gx;
-
+
for (gx = r->x; !found && g < end; gx += g->pixel_width, ++g)
if (gx >= x)
{
int width, height, gx, gy;
XRectangle rect;
-
+
if (glyph_rect (f1, win_x, win_y, &rect))
last_mouse_glyph = rect;
else
height = FRAME_SMALLEST_FONT_HEIGHT (f1);
gx = win_x;
gy = win_y;
-
+
/* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
round down even for negative values. */
if (gx < 0)
gy -= height - 1;
gx = (gx + width - 1) / width * width;
gy = (gy + height - 1) / height * height;
-
+
last_mouse_glyph.width = width;
last_mouse_glyph.height = height;
last_mouse_glyph.x = gx;
Window window;
{
Lisp_Object tail;
-
+
for (tail = Vframe_list;
XGCTYPE (tail) == Lisp_Cons;
tail = XCDR (tail))
{
Lisp_Object frame = XCAR (tail);
Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
-
+
if (menu_bar && xlwmenu_window_p (menu_bar, window))
return menu_bar;
}
{
int scroll_bar_p;
char *end_action;
-
+
#ifdef USE_MOTIF
scroll_bar_p = XmIsScrollBar (widget);
end_action = "Release";
&& WINDOWP (window_being_scrolled))
{
struct window *w;
-
+
x_send_scroll_bar_event (window_being_scrolled,
scroll_bar_end_scroll, 0, 0);
w = XWINDOW (window_being_scrolled);
int i;
BLOCK_INPUT;
-
+
/* Construct a ClientMessage event to send to the frame. */
ev->type = ClientMessage;
ev->message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_Scrollbar;
int new_size = max (10, 2 * scroll_bar_windows_size);
size_t nbytes = new_size * sizeof *scroll_bar_windows;
size_t old_nbytes = scroll_bar_windows_size * sizeof *scroll_bar_windows;
-
+
scroll_bar_windows = (struct window **) xrealloc (scroll_bar_windows,
nbytes);
bzero (&scroll_bar_windows[i], nbytes - old_nbytes);
Lisp_Object window;
struct frame *f;
struct window *w;
-
+
w = scroll_bar_windows[ev->data.l[0]];
scroll_bar_windows[ev->data.l[0]] = NULL;
XSETWINDOW (window, w);
f = XFRAME (w->frame);
-
+
ievent->kind = SCROLL_BAR_CLICK_EVENT;
ievent->frame_or_window = window;
ievent->arg = Qnil;
bar->dragging = Qnil;
part = scroll_bar_to_top;
break;
-
+
case XmCR_TO_BOTTOM:
bar->dragging = Qnil;
part = scroll_bar_to_bottom;
bar->dragging = make_number (cs->value);
}
break;
-
+
case XmCR_VALUE_CHANGED:
break;
};
XtSetArg (av[ac], XmNforeground, pixel);
++ac;
}
-
+
pixel = f->output_data.x->scroll_bar_background_pixel;
if (pixel != -1)
{
XtSetArg (av[ac], XmNbackground, pixel);
++ac;
}
-
+
widget = XmCreateScrollBar (f->output_data.x->edit_widget,
scroll_bar_name, av, ac);
(XtPointer) bar);
XtAddCallback (widget, XmNtoTopCallback, xm_scroll_callback,
(XtPointer) bar);
-
+
/* Realize the widget. Only after that is the X window created. */
XtRealizeWidget (widget);
And I'm wondering why it hasn't an arrow cursor by default. */
XDefineCursor (XtDisplay (widget), XtWindow (widget),
f->output_data.x->nontext_cursor);
-
+
#else /* !USE_MOTIF i.e. use Xaw */
-
+
/* Set resources. Create the widget. The background of the
Xaw3d scroll bar widget is a little bit light for my taste.
We don't alter it here to let users change it according
XtSetArg (av[ac], XtNorientation, XtorientVertical); ++ac;
/* For smoother scrolling with Xaw3d -sm */
/* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
-
+
pixel = f->output_data.x->scroll_bar_foreground_pixel;
if (pixel != -1)
{
XtSetArg (av[ac], XtNforeground, pixel);
++ac;
}
-
+
pixel = f->output_data.x->scroll_bar_background_pixel;
if (pixel != -1)
{
XtVaSetValues (widget, XtNcursorName, "top_left_arrow", NULL);
}
}
-
+
/* Define callbacks. */
XtAddCallback (widget, XtNjumpProc, xaw_jump_callback, (XtPointer) bar);
XtAddCallback (widget, XtNscrollProc, xaw_scroll_callback,
(XtPointer) bar);
-
+
/* Realize the widget. Only after that is the X window created. */
XtRealizeWidget (widget);
-
+
#endif /* !USE_MOTIF */
/* Install an action hook that lets us detect when the user
finishes interacting with a scroll bar. */
if (action_hook_id == 0)
action_hook_id = XtAppAddActionHook (Xt_app_con, xt_action_hook, 0);
-
+
/* Remember X window and widget in the scroll bar vector. */
SET_SCROLL_BAR_X_WIDGET (bar, widget);
xwindow = XtWindow (widget);
value = top * XM_SB_RANGE;
value = min (value, XM_SB_MAX - size);
value = max (value, XM_SB_MIN);
-
+
XmScrollBarSetValues (widget, value, size, 0, 0, False);
}
#else /* !USE_MOTIF i.e. use Xaw */
#ifdef HAVE_XAW3D
ScrollbarWidget sb = (ScrollbarWidget) widget;
int scroll_mode = 0;
-
+
/* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
if (xaw3d_arrow_scroll)
{
/* Try to make the scrolling a tad smoother. */
if (!xaw3d_pick_top)
shown = min (shown, old_shown);
-
+
XawScrollbarSetThumb (widget, top, shown);
-
+
#ifdef HAVE_XAW3D
if (xaw3d_arrow_scroll && scroll_mode == 2)
sb->scrollbar.scroll_mode = scroll_mode;
/************************************************************************
Scroll bars, general
************************************************************************/
-
+
/* Create a scroll bar and return the scroll bar vector for it. W is
the Emacs window on which to create the scroll bar. TOP, LEFT,
WIDTH and HEIGHT are the pixel coordinates and dimensions of the
a.background_pixel = f->output_data.x->scroll_bar_background_pixel;
if (a.background_pixel == -1)
a.background_pixel = f->output_data.x->background_pixel;
-
+
a.event_mask = (ButtonPressMask | ButtonReleaseMask
| ButtonMotionMask | PointerMotionHintMask
| ExposureMask);
/* Draw BAR's handle in the proper position.
-
+
If the handle is already drawn from START to END, don't bother
redrawing it, unless REBUILD is non-zero; in that case, always
redraw it. (REBUILD is handy for drawing the handle after expose
#else
XDestroyWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
#endif
-
+
/* Disassociate this scroll bar from its window. */
XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
/* Compute the left edge of the scroll bar. */
#ifdef USE_TOOLKIT_SCROLL_BARS
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
- sb_left = left + width - sb_width - (width - sb_width) / 2;
+ sb_left = left + width - sb_width - (width - sb_width) / 2;
else
sb_left = left + (width - sb_width) / 2;
#else
if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
- sb_left = left + width - sb_width;
+ sb_left = left + width - sb_width;
else
sb_left = left;
#endif
-
+
/* Does the scroll bar exist yet? */
if (NILP (w->vertical_scroll_bar))
{
left, top, width, height, False);
UNBLOCK_INPUT;
}
-
+
bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
}
else
{
/* It may just need to be moved and resized. */
unsigned int mask = 0;
-
+
bar = XSCROLL_BAR (w->vertical_scroll_bar);
BLOCK_INPUT;
mask |= CWY;
if (sb_width != XINT (bar->width))
mask |= CWWidth;
- if (height != XINT (bar->height))
+ if (height != XINT (bar->height))
mask |= CWHeight;
-
+
#ifdef USE_TOOLKIT_SCROLL_BARS
/* Since toolkit scroll bars are smaller than the space reserved
max (height, 1), 0);
#else /* not USE_TOOLKIT_SCROLL_BARS */
-
+
/* Clear areas not covered by the scroll bar because of
VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
if (VERTICAL_SCROLL_BAR_WIDTH_TRIM)
left, top, rest, height, False);
}
}
-
+
/* Move/size the scroll bar window. */
if (mask)
{
XWindowChanges wc;
-
+
wc.x = sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM;
wc.y = top;
wc.width = sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2;
XConfigureWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar),
mask, &wc);
}
-
+
#endif /* not USE_TOOLKIT_SCROLL_BARS */
/* Remember new settings. */
XSETINT (bar->top, top);
XSETINT (bar->width, sb_width);
XSETINT (bar->height, height);
-
+
UNBLOCK_INPUT;
}
0, 0,
XINT (bar->width) - 1 - width_trim - width_trim,
XINT (bar->height) - 1);
-
+
UNBLOCK_INPUT;
#endif /* not USE_TOOLKIT_SCROLL_BARS */
emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
emacs_event->code = event->xbutton.button - Button1;
emacs_event->modifiers
- = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
+ = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
(XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))),
event->xbutton.state)
| (event->type == ButtonRelease
abort (); /* Don't think this happens. */
++handling_signal;
-
+
/* Find the display we are supposed to read input for.
It's the one communicating on descriptor SD. */
for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
below are temporally close (on a fast machine), the call
below can generate additional FocusIn events which confuse
Emacs. */
-
+
/* Since we set WM_TAKE_FOCUS, we must call
XSetInputFocus explicitly. But not if f is null,
since that might be an event for a deleted frame. */
if there is an error. */
XSync (d, False);
x_uncatch_errors (d, count);
- }
+ }
/* Not certain about handling scroll bars here */
#endif /* 0 */
}
tip_window = 0;
redo_mouse_highlight ();
}
-
+
f = x_top_window_to_frame (dpyinfo, event.xunmap.window);
if (f) /* F may no longer exist if
the frame was deleted. */
/* The tooltip has been drawn already. Avoid
the SET_FRAME_GARBAGED below. */
goto OTHER;
-
+
/* We use x_top_window_to_frame because map events can
come for sub-windows and they don't mean that the
frame is visible. */
else
c = STRING_CHAR_AND_LENGTH (copy_bufptr + i,
nbytes - i, len);
-
+
bufp->kind = (SINGLE_BYTE_CHAR_P (c)
? ASCII_KEYSTROKE_EVENT
: MULTIBYTE_CHAR_KEYSTROKE_EVENT);
{
bufp += n, count += n, numchars -= n;
}
-
+
f = x_any_window_to_frame (dpyinfo, event.xcrossing.window);
#if 0
previous_help_echo = help_echo;
help_echo = help_echo_object = help_echo_window = Qnil;
help_echo_pos = -1;
-
+
if (dpyinfo->grabbed && last_mouse_frame
&& FRAME_LIVE_P (last_mouse_frame))
f = last_mouse_frame;
help_echo_pos);
bufp += n, count += n, numchars -= n;
}
-
+
goto OTHER;
}
int columns = PIXEL_TO_CHAR_WIDTH (f, event.xconfigure.width);
if (dont_resize)
goto OTHER;
-
+
/* In the toolkit version, change_frame_size
is called by the code that handles resizing
of the EmacsFrame widget. */
by the rest of Emacs, we put it here. */
struct input_event emacs_event;
int tool_bar_p = 0;
-
+
emacs_event.kind = NO_EVENT;
bzero (&compose_status, sizeof (compose_status));
the ButtonPress. */
if (f != 0)
f->mouse_moved = 0;
-
+
if (!tool_bar_p)
last_tool_bar_item = -1;
}
case CirculateNotify:
goto OTHER;
-
+
case CirculateRequest:
goto OTHER;
the buffer and window end because update_text_area
doesn't draw that row. (Except when it does, but
that's handled in update_text_area.) */
-
+
if (((y0 >= cy0 && y0 < cy1) || (y1 > cy0 && y1 < cy1))
&& w->current_matrix->rows[w->phys_cursor.vpos].displays_text_p)
w->phys_cursor_on_p = 0;
&& !x_stretch_cursor_p)
wd = min (CANON_X_UNIT (f), wd);
w->phys_cursor_width = wd;
-
+
/* The foreground of cursor_gc is typically the same as the normal
background color, which can cause the cursor box to be invisible. */
xgcv.foreground = f->output_data.x->cursor_pixel;
{
struct frame *f = XFRAME (w->frame);
struct glyph *cursor_glyph;
-
+
/* If cursor is out of bounds, don't draw garbage. This can happen
in mini-buffer windows when switching between echo area glyphs
and mini-buffer. */
else
xgcv.background = xgcv.foreground = f->output_data.x->cursor_pixel;
xgcv.graphics_exposures = 0;
-
+
if (gc)
XChangeGC (dpy, gc, mask, &xgcv);
else
gc = XCreateGC (dpy, window, mask, &xgcv);
FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc = gc;
}
-
+
if (width < 0)
width = FRAME_CURSOR_WIDTH (f);
width = min (cursor_glyph->pixel_width, width);
-
+
w->phys_cursor_width = width;
x_clip_to_row (w, row, gc, 0);
-
+
if (kind == BAR_CURSOR)
XFillRectangle (dpy, window, gc,
WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
{
int on_p = w->phys_cursor_on_p;
int x1;
-
+
x1 = x_draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
hl, 0);
screen. */
if (w->phys_cursor_type == NO_CURSOR)
goto mark_cursor_off;
-
+
/* VPOS >= active_glyphs->nrows means that window has been resized.
Don't bother to erase the cursor. */
if (vpos >= active_glyphs->nrows)
cursor_row = MATRIX_ROW (active_glyphs, vpos);
if (!cursor_row->enabled_p)
goto mark_cursor_off;
-
+
/* If row is completely invisible, don't attempt to delete a cursor which
isn't there. This can happen if cursor is at top of a window, and
we switch to a buffer with a header line in that window. */
if (cursor_row->visible_height <= 0)
goto mark_cursor_off;
-
+
/* This can happen when the new row is shorter than the old one.
In this case, either x_draw_glyphs or clear_end_of_line
should have cleared the cursor. Note that we wouldn't be
cursor glyph at hand. */
if (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])
goto mark_cursor_off;
-
+
/* If the cursor is in the mouse face area, redisplay that when
we clear the cursor. */
if (! NILP (dpyinfo->mouse_face_window)
goto mark_cursor_off;
x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
-
+
x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
x,
WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
cursor_row->visible_height,
False);
}
-
+
/* Erase the cursor by redrawing the character underneath it. */
if (mouse_face_here_p)
hl = DRAW_MOUSE_FACE;
{
struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
int in_mouse_face = 0;
-
+
if (WINDOWP (dpyinfo->mouse_face_window)
&& XWINDOW (dpyinfo->mouse_face_window) == w)
{
current_glyphs = w->current_matrix;
glyph_row = MATRIX_ROW (current_glyphs, vpos);
glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
-
- /* If cursor row is not enabled, we don't really know where to
+
+ /* If cursor row is not enabled, we don't really know where to
display the cursor. */
if (!glyph_row->enabled_p)
{
{
w->phys_cursor_ascent = glyph_row->ascent;
w->phys_cursor_height = glyph_row->height;
-
+
/* Set phys_cursor_.* before x_draw_.* is called because some
of them may need the information. */
w->phys_cursor.x = x;
default:
abort ();
}
-
+
#ifdef HAVE_X_I18N
if (w == XWINDOW (f->selected_window))
if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMPreeditPosition))
\f
/* Handle SIGPIPE, which can happen when the connection to a server
simply goes away. SIGPIPE is handled by x_connection_signal.
- Don't need to do anything, because the write which caused the
+ Don't need to do anything, because the write which caused the
SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
which will do the appropriate cleanup for us. */
-
+
static SIGTYPE
x_connection_signal (signalnum) /* If we don't have an argument, */
int signalnum; /* some compilers complain in signal calls. */
struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
Lisp_Object frame, tail;
int count;
-
+
error_msg = (char *) alloca (strlen (error_message) + 1);
strcpy (error_msg, error_message);
handling_signal = 0;
-
+
/* Prevent being called recursively because of an error condition
below. Otherwise, we might end up with printing ``can't find per
display information'' in the recursive call instead of printing
the original message here. */
count = x_catch_errors (dpy);
-
+
/* We have to close the display to inform Xt that it doesn't
exist anymore. If we don't, Xt will continue to wait for
events from the display. As a consequence, a sequence of
Closing the display is reported to lead to a bus error on
OpenWindows in certain situations. I suspect that is a bug
in OpenWindows. I don't know how to cicumvent it here. */
-
+
#ifdef USE_X_TOOLKIT
/* If DPYINFO is null, this means we didn't open the display
in the first place, so don't try to close it. */
x_delete_display (dpyinfo);
x_uncatch_errors (dpy, count);
-
+
if (x_display_list == 0)
{
fprintf (stderr, "%s\n", error_msg);
&& (FRAME_XIC_STYLE (f) & (XIMPreeditPosition | XIMStatusArea)))
xic_set_xfontset (f, SDATA (fontset_ascii (fontset)));
#endif
-
+
return build_string (fontsetname);
}
{
struct x_display_info *dpyinfo = (struct x_display_info *) client_data;
Lisp_Object frame, tail;
-
+
BLOCK_INPUT;
-
+
/* No need to call XDestroyIC.. */
FOR_EACH_FRAME (tail, frame)
{
}
}
}
-
+
/* No need to call XCloseIM. */
dpyinfo->xim = NULL;
XFree (dpyinfo->xim_styles);
#ifdef HAVE_X11R6
XIMCallback destroy;
#endif
-
+
/* Get supported styles and XIM values. */
XGetIMValues (xim, XNQueryInputStyle, &dpyinfo->xim_styles, NULL);
-
+
#ifdef HAVE_X11R6
destroy.callback = xim_destroy_callback;
destroy.client_data = (XPointer)dpyinfo;
XSetIMValues (xim, XNDestroyCallback, &destroy, NULL);
#endif
}
-
+
#else /* not USE_XIM */
dpyinfo->xim = NULL;
#endif /* not USE_XIM */
/* We don't support multiple XIM connections. */
if (dpyinfo->xim)
return;
-
+
xim_open_dpy (dpyinfo, xim_inst->resource_name);
/* Create XIC for the existing frames on the same display, as long
FOR_EACH_FRAME (tail, frame)
{
struct frame *f = XFRAME (frame);
-
+
if (FRAME_X_DISPLAY_INFO (f) == xim_inst->dpyinfo)
if (FRAME_XIC (f) == NULL)
{
}
}
}
-
+
UNBLOCK_INPUT;
}
}
#ifdef HAVE_X11R6_XIM
struct xim_inst_t *xim_inst;
int len;
-
+
dpyinfo->xim = NULL;
xim_inst = (struct xim_inst_t *) xmalloc (sizeof (struct xim_inst_t));
xim_inst->dpyinfo = dpyinfo;
dpyinfo->xim = NULL;
xim_open_dpy (dpyinfo, resource_name);
#endif /* not HAVE_X11R6_XIM */
-
+
#else /* not USE_XIM */
dpyinfo->xim = NULL;
#endif /* not USE_XIM */
It's not obvious where the initial small difference comes from.
2000-12-01, gerd. */
-
+
XtVaGetValues (f->output_data.x->column_widget, XtNheight, &height, NULL);
#endif
- height
+ f->output_data.x->top_pos);
}
-
+
/* The left_pos and top_pos
are now relative to the top and left screen edges,
so the flags should correspond. */
if (f->output_data.x->want_fullscreen & FULLSCREEN_BOTH)
{
int width, height, ign;
-
+
x_real_positions (f, &f->output_data.x->left_pos,
&f->output_data.x->top_pos);
x_fullscreen_adjust (f, &width, &height, &ign, &ign);
-
+
/* We do not need to move the window, it shall be taken care of
when setting WM manager hints.
If the frame is visible already, the position is checked by
/* Wait for the change of frame size to occur */
f->output_data.x->want_fullscreen |= FULLSCREEN_WAIT;
-
+
}
}
}
expect_top = 0;
if (f->output_data.x->want_fullscreen & FULLSCREEN_WIDTH)
expect_left = 0;
-
+
if (expect_top != f->output_data.x->top_pos
|| expect_left != f->output_data.x->left_pos)
x_set_offset (f, expect_left, expect_top, 1);
*top_pos = f->output_data.x->top_pos;
*left_pos = f->output_data.x->left_pos;
-
+
if (f->output_data.x->want_fullscreen & FULLSCREEN_HEIGHT)
{
int ph;
-
+
ph = FRAME_X_DISPLAY_INFO (f)->height;
newheight = PIXEL_TO_CHAR_HEIGHT (f, ph);
ph = CHAR_TO_PIXEL_HEIGHT (f, newheight)
if (f->output_data.x->want_fullscreen & FULLSCREEN_WIDTH)
{
int pw;
-
+
pw = FRAME_X_DISPLAY_INFO (f)->width;
newwidth = PIXEL_TO_CHAR_WIDTH (f, pw);
pw = CHAR_TO_PIXEL_WIDTH (f, newwidth)
BLOCK_INPUT;
#ifdef USE_X_TOOLKIT
-
+
if (f->output_data.x->widget != NULL)
{
/* The x and y position of the widget is clobbered by the
}
else
x_set_window_size_1 (f, change_gravity, cols, rows);
-
+
#else /* not USE_X_TOOLKIT */
-
+
x_set_window_size_1 (f, change_gravity, cols, rows);
-
+
#endif /* not USE_X_TOOLKIT */
/* If cursor was outside the new size, mark it as off. */
mark_window_cursors_off (XWINDOW (f->root_window));
/* Clear out any recollection of where the mouse highlighting was,
- since it might be in a place that's outside the new frame size.
+ since it might be in a place that's outside the new frame size.
Actually checking whether it is outside is a pain in the neck,
so don't try--just let the highlighting be done afresh with new size. */
cancel_mouse_face (f);
Drawable rootw;
int x, y;
unsigned int width, height, border, depth;
-
+
BLOCK_INPUT;
/* On some window managers (such as FVWM) moving an existing
FreeBSD, Linux and Solaris. It turns out that, for some
unknown reason, the call to XtMapWidget is completely ignored.
Mapping the widget a second time works. */
-
+
if (!FRAME_VISIBLE_P (f) && --retry_count > 0)
goto retry;
}
if (FRAME_FACE_CACHE (f))
free_frame_faces (f);
-
+
x_free_gcs (f);
XFlush (FRAME_X_DISPLAY (f));
}
xfree (f->output_data.x);
f->output_data.x = NULL;
-
+
if (f == dpyinfo->x_focus_frame)
dpyinfo->x_focus_frame = 0;
if (f == dpyinfo->x_focus_event_frame)
}
#else /* not USE_X_TOOLKIT */
-
+
f->output_data.x->wm_hints.flags |= IconPixmapHint;
XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
int width = 0;
char *p = names[i];
int average_width = -1, dashes = 0;
-
+
/* Count the number of dashes in NAMES[I]. If there are
14 dashes, and the field value following 12th dash
(AVERAGE_WIDTH) is 0, this is a auto-scaled font which
else if (dashes == 12) /* AVERAGE_WIDTH field */
average_width = atoi (p);
}
-
+
if (allow_scalable_fonts_p
|| dashes < 14 || average_width != 0)
{
}
}
}
-
+
if (!try_XLoadQueryFont)
{
BLOCK_INPUT;
}
return newlist;
-}
+}
#if GLYPH_DEBUG
xassert (font != NULL);
for (i = 0; i < dpyinfo->n_fonts; i++)
- if (dpyinfo->font_table[i].name
+ if (dpyinfo->font_table[i].name
&& font == dpyinfo->font_table[i].font)
break;
XFontStruct *font;
int old_width = dpyinfo->smallest_char_width;
int old_height = dpyinfo->smallest_font_height;
-
+
dpyinfo->smallest_font_height = 100000;
dpyinfo->smallest_char_width = 100000;
-
+
for (i = 0; i < dpyinfo->n_fonts; ++i)
if (dpyinfo->font_table[i].name)
{
struct font_info *fontp = dpyinfo->font_table + i;
int w, h;
-
+
font = (XFontStruct *) fontp->font;
xassert (font != (XFontStruct *) ~0);
x_font_min_bounds (font, &w, &h);
-
+
dpyinfo->smallest_font_height = min (dpyinfo->smallest_font_height, h);
dpyinfo->smallest_char_width = min (dpyinfo->smallest_char_width, w);
}
XFree (name);
}
-
+
if (full_name != 0)
fontp->full_name = full_name;
else
>= 0)))
break;
}
-
+
if (! NILP (list))
{
struct ccl_program *ccl
dpyinfo->next = x_display_list;
x_display_list = dpyinfo;
- /* Put it on x_display_name_list as well, to keep them parallel. */
+ /* Put it on x_display_name_list as well, to keep them parallel. */
x_display_name_list = Fcons (Fcons (display_name, Qnil),
x_display_name_list);
dpyinfo->name_list_element = XCAR (x_display_name_list);
else
dpyinfo->cmap = XCreateColormap (dpyinfo->display, dpyinfo->root_window,
dpyinfo->visual, AllocNone);
-
+
{
int screen_number = XScreenNumberOfScreen (dpyinfo->screen);
double pixels = DisplayHeight (dpyinfo->display, screen_number);
mm = DisplayWidthMM (dpyinfo->display, screen_number);
dpyinfo->resx = pixels * 25.4 / mm;
}
-
+
dpyinfo->Xatom_wm_protocols
= XInternAtom (dpyinfo->display, "WM_PROTOCOLS", False);
dpyinfo->Xatom_wm_take_focus
/* Ghostscript support. */
dpyinfo->Xatom_PAGE = XInternAtom (dpyinfo->display, "PAGE", False);
dpyinfo->Xatom_DONE = XInternAtom (dpyinfo->display, "DONE", False);
-
+
dpyinfo->Xatom_Scrollbar = XInternAtom (dpyinfo->display, "SCROLLBAR",
False);
null_bits[0] = 0x00;
dpyinfo->null_pixel
- = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
+ = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
null_bits, 1, 1, (long) 0, (long) 0,
1);
}
#ifdef HAVE_X_I18N
xim_initialize (dpyinfo, resource_name);
#endif
-
+
#ifdef subprocesses
/* This is only needed for distinguishing keyboard and process input. */
if (connection != 0)
XrmValue d, fr, to;
Font font;
int count;
-
+
d.addr = (XPointer)&dpy;
d.size = sizeof (Display *);
fr.addr = XtDefaultFont;
|| !strcmp (SDATA (value), "on")))
XSynchronize (dpyinfo->display, True);
}
-
+
UNBLOCK_INPUT;
return dpyinfo;
if (dpyinfo->xim)
xim_close_dpy (dpyinfo);
#endif
-
+
xfree (dpyinfo->font_table);
xfree (dpyinfo->x_id_name);
xfree (dpyinfo->color_cells);
x_noop_count = 0;
last_tool_bar_item = -1;
any_help_event_p = 0;
-
+
/* Try to use interrupt input; if we can't, then start polling. */
Fset_input_mode (Qt, Qnil, Qt, Qnil);
XtToolkitInitialize ();
Xt_app_con = XtCreateApplicationContext ();
-
+
/* Register a converter from strings to pixels, which uses
Emacs' color allocation infrastructure. */
XtAppSetTypeConverter (Xt_app_con,
start_atimer (ATIMER_CONTINUOUS, interval, x_process_timeouts, 0);
}
#endif
-
+
#ifdef USE_TOOLKIT_SCROLL_BARS
xaw3d_arrow_scroll = False;
xaw3d_pick_top = True;
staticpro (&last_mouse_motion_frame);
last_mouse_motion_frame = Qnil;
-
+
Qmodifier_value = intern ("modifier-value");
Qalt = intern ("alt");
Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
Qsuper = intern ("super");
Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
-
+
DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym,
doc: /* Which keys Emacs uses for the alt modifier.
This should be one of the symbols `alt', `hyper', `meta', `super'.
For example, `alt' means use the Alt_L and Alt_R keysyms. The default
is nil, which is the same as `alt'. */);
Vx_alt_keysym = Qnil;
-
+
DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym,
doc: /* Which keys Emacs uses for the hyper modifier.
This should be one of the symbols `alt', `hyper', `meta', `super'.
For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
default is nil, which is the same as `hyper'. */);
Vx_hyper_keysym = Qnil;
-
+
DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym,
doc: /* Which keys Emacs uses for the meta modifier.
This should be one of the symbols `alt', `hyper', `meta', `super'.
For example, `meta' means use the Meta_L and Meta_R keysyms. The
default is nil, which is the same as `meta'. */);
Vx_meta_keysym = Qnil;
-
+
DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym,
doc: /* Which keys Emacs uses for the super modifier.
This should be one of the symbols `alt', `hyper', `meta', `super'.
HCoop / bpt / emacs.git / commitdiff