mirror/emacs
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2024-11-22 07:09:54 +00:00
Code Issues Releases Activity
309d0a7186
emacs/oldXMenu/Internal.c
Stefan Kangas a6cab228d4 ; Fix typos
2024-07-18 11:46:50 +02:00

1024 lines
27 KiB
C
Raw Blame History

/* Copyright Massachusetts Institute of Technology 1985 */
/*
Copyright 1985, 1986, 1987 by the Massachusetts Institute of Technology
Permission to use, copy, modify, and distribute this
software and its documentation for any purpose and without
fee is hereby granted, provided that the above copyright
notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting
documentation, and that the name of M.I.T. not be used in
advertising or publicity pertaining to distribution of the
software without specific, written prior permission.
M.I.T. makes no representations about the suitability of
this software for any purpose. It is provided "as is"
without express or implied warranty.
*/
/*
Copyright (C) 1993, 1996, 2001-2024 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>. */
/*
* XMenu: MIT Project Athena, X Window system menu package
*
* XMenuInternal.c - XMenu internal (not user visible) routines.
*
* Author: Tony Della Fera, DEC
* November, 1985
*
*/
#include "XMenuInt.h"
/*
* Internal Window creation queue sizes.
*/
#define S_QUE_SIZE 300
#define P_QUE_SIZE 20
/*
* XMWinQue - Internal window creation queue datatype.
*/
typedef struct _xmwinquedef {
int sq_size;
XMSelect *sq[S_QUE_SIZE];
XMSelect **sq_ptr;
int pq_size;
XMPane *pq[P_QUE_SIZE];
XMPane **pq_ptr;
} XMWinQue;
/*
* _XMWinQue - Internal static window creation queue.
*/
static Bool _XMWinQueIsInit = False;
static XMWinQue _XMWinQue;
/*
* _XMErrorCode - Global XMenu error code.
*/
int _XMErrorCode = XME_NO_ERROR;
/*
* _XMErrorList - Global XMenu error code description strings.
*/
char const *const
_XMErrorList[XME_CODE_COUNT] = {
"No error", /* XME_NO_ERROR */
"Menu not initialized", /* XME_NOT_INIT */
"Argument out of bounds", /* XME_ARG_BOUNDS */
"Pane not found", /* XME_P_NOT_FOUND */
"Selection not found", /* XME_S_NOT_FOUND */
"Invalid menu style parameter", /* XME_STYLE_PARAM */
"Unable to grab mouse", /* XME_GRAB_MOUSE */
"Unable to interpret locator", /* XME_INTERP_LOC */
"Unable to calloc memory", /* XME_CALLOC */
"Unable to create XAssocTable", /* XME_CREATE_ASSOC */
"Unable to store bitmap", /* XME_STORE_BITMAP */
"Unable to make tile pixmaps", /* XME_MAKE_TILES */
"Unable to make pixmap", /* XME_MAKE_PIXMAP */
"Unable to create cursor", /* XME_CREATE_CURSOR */
"Unable to open font", /* XME_OPEN_FONT */
"Unable to create windows", /* XME_CREATE_WINDOW */
"Unable to create transparencies", /* XME_CREATE_TRANSP */
};
/*
* _XMEventHandler - Internal event handler variable.
*/
int (*_XMEventHandler)(XEvent*) = NULL;
/*
* _XMWinQueInit - Internal routine to initialize the window
* queue.
*/
void
_XMWinQueInit(void)
{
/*
* If the queue is not initialized initialize it.
*/
if (!_XMWinQueIsInit) {
/*
* Blank the queue structure.
*/
register int i;
for (i = 0; i < S_QUE_SIZE; i++)
_XMWinQue.sq[i] = 0;
for (i = 0; i < P_QUE_SIZE; i++)
_XMWinQue.pq[i] = 0;
_XMWinQue.sq_size = _XMWinQue.pq_size = 0;
/*
* Initialize the next free location pointers.
*/
_XMWinQue.sq_ptr = _XMWinQue.sq;
_XMWinQue.pq_ptr = _XMWinQue.pq;
}
}
/*
* _XMWinQueAddPane - Internal routine to add a pane to the pane
* window queue.
*/
int
_XMWinQueAddPane(register Display *display, register XMenu *menu, register XMPane *p_ptr)
/* Menu being manipulated. */
/* XMPane being queued. */
{
/*
* If the queue is currently full then flush it.
*/
if (_XMWinQue.pq_size == P_QUE_SIZE) {
if (_XMWinQueFlush(display, menu, 0, 0) == _FAILURE) return(_FAILURE);
}
/*
* Insert the new XMPane pointer and increment the queue pointer
* and the queue size.
*/
*_XMWinQue.pq_ptr = p_ptr;
_XMWinQue.pq_ptr++;
_XMWinQue.pq_size++;
/*
* All went well, return successfully.
*/
_XMErrorCode = XME_NO_ERROR;
return(_SUCCESS);
}
/*
* _XMWinQueAddSelection - Internal routine to add a selection to
* the selection window queue.
*/
int
_XMWinQueAddSelection(register Display *display, register XMenu *menu, register XMSelect *s_ptr)
/* Menu being manipulated. */
/* XMSelection being queued. */
{
/*
* If this entry will overflow the queue then flush it.
*/
if (_XMWinQue.sq_size == S_QUE_SIZE) {
if (_XMWinQueFlush(display, menu, 0, 0) == _FAILURE) return(_FAILURE);
}
/*
* Insert the new XMSelect pointer and increment the queue pointer
* and the queue size.
*/
*_XMWinQue.sq_ptr = s_ptr;
_XMWinQue.sq_ptr++;
_XMWinQue.sq_size++;
/*
* All went well, return successfully.
*/
_XMErrorCode = XME_NO_ERROR;
return(_SUCCESS);
}
/*
* _XMWinQueFlush - Internal routine to flush the pane and
* selection window queues.
*/
int
_XMWinQueFlush(register Display *display, register XMenu *menu, register XMPane *pane, XMSelect *sel)
/* Menu being manipulated. */
/* Current pane. */
{
register int pq_index; /* Pane queue index. */
register int sq_index; /* Selection queue index. */
register XMPane *p_ptr; /* XMPane pointer. */
register XMSelect *s_ptr; /* XMSelect pointer. */
unsigned long valuemask; /* Which attributes to set. */
XSetWindowAttributes attributes_buf; /* Attributes to be set. */
XSetWindowAttributes *attributes = &attributes_buf;
/*
* If the pane window queue is not empty...
*/
if (_XMWinQue.pq_size > 0) {
/*
* set up attributes for pane window to be created.
*/
valuemask = (CWBackPixmap | CWBorderPixel | CWOverrideRedirect);
attributes->border_pixel = menu->p_bdr_color;
attributes->background_pixmap = menu->inact_pixmap;
attributes->override_redirect = True;
/*
* Create all the pending panes in order, so that the
* current pane will be on top, with the others
* stacked appropriately under it.
*/
for (pq_index = _XMWinQue.pq_size - 1;
pq_index >= 0;
pq_index--)
{
p_ptr = _XMWinQue.pq[pq_index]; /* Retrieve next pane. */
if (p_ptr == pane) break;
p_ptr->window = XCreateWindow(display,
menu->parent,
p_ptr->window_x,
p_ptr->window_y,
p_ptr->window_w,
p_ptr->window_h,
menu->p_bdr_width,
CopyFromParent,
InputOutput,
CopyFromParent,
valuemask,
attributes);
XMakeAssoc(display, menu->assoc_tab, p_ptr->window, p_ptr);
XSelectInput(display, p_ptr->window, menu->p_events);
}
for (pq_index = 0;
pq_index < _XMWinQue.pq_size;
pq_index++)
{
p_ptr = _XMWinQue.pq[pq_index]; /* Retrieve next pane. */
p_ptr->window = XCreateWindow(display,
menu->parent,
p_ptr->window_x,
p_ptr->window_y,
p_ptr->window_w,
p_ptr->window_h,
menu->p_bdr_width,
CopyFromParent,
InputOutput,
CopyFromParent,
valuemask,
attributes);
XMakeAssoc(display, menu->assoc_tab, p_ptr->window, p_ptr);
XSelectInput(display, p_ptr->window, menu->p_events);
if (p_ptr == pane) break;
}
/*
* Reset the pane queue pointer and size.
*/
_XMWinQue.pq_size = 0;
_XMWinQue.pq_ptr = _XMWinQue.pq;
}
/*
* If the selection window queue is not empty...
*/
if (_XMWinQue.sq_size > 0) {
for (sq_index = 0; sq_index < _XMWinQue.sq_size; sq_index++) {
/*
* Retrieve the XMSelect pointer.
*/
s_ptr = _XMWinQue.sq[sq_index];
s_ptr->window = XCreateWindow(display,
s_ptr->parent_p->window,
s_ptr->window_x,
s_ptr->window_y,
s_ptr->window_w,
s_ptr->window_h,
0, /* border width*/
CopyFromParent,
InputOnly,
CopyFromParent,
0,
attributes);
/*
* Insert the new window id and its
* associated XMSelect structure into the
* association table.
*/
XMakeAssoc(display, menu->assoc_tab, s_ptr->window, s_ptr);
XSelectInput(display, s_ptr->window, menu->s_events);
}
/*
* Reset the selection queue pointer and size.
*/
_XMWinQue.sq_size = 0;
_XMWinQue.sq_ptr = _XMWinQue.sq;
}
/*
* Flush X's internal queues.
*/
XFlush(display);
/*
* All went well, return successfully.
*/
_XMErrorCode = XME_NO_ERROR;
return(_SUCCESS);
}
/*
* _XMGetPanePtr - Given a menu pointer and a pane index number, return
* a pane pointer that points to the indexed pane.
*/
XMPane *
_XMGetPanePtr(register XMenu *menu, register int p_num)
/* Menu to find the pane in. */
/* Index number of pane to find. */
{
register XMPane *p_ptr; /* Pane pointer to be returned. */
register int i; /* Loop counter. */
/*
* Is the pane number out of range?
*/
if ((p_num < 0) || (p_num > (menu->p_count - 1))) {
_XMErrorCode = XME_P_NOT_FOUND;
return(NULL);
}
/*
* Find the right pane.
*/
p_ptr = menu->p_list->next;
for (i = 0; i < p_num; i++) p_ptr = p_ptr->next;
/*
* Return successfully.
*/
_XMErrorCode = XME_NO_ERROR;
return(p_ptr);
}
/*
* _XMGetSelectionPtr - Given pane pointer and a selection index number,
* return a selection pointer that points to the
* indexed selection.
*/
XMSelect *
_XMGetSelectionPtr(register XMPane *p_ptr, register int s_num)
/* Pane to find the selection in. */
/* Index number of the selection to find. */
{
register XMSelect *s_ptr; /* Selection pointer to be returned. */
register int i; /* Loop counter. */
/*
* Is the selection number out of range?
*/
if ((s_num < 0) || (s_num > (p_ptr->s_count - 1))) {
_XMErrorCode = XME_S_NOT_FOUND;
return(NULL);
}
/*
* Find the right selection.
*/
s_ptr = p_ptr->s_list->next;
for (i = 0; i < s_num; i++) s_ptr = s_ptr->next;
/*
* Return successfully.
*/
_XMErrorCode = XME_NO_ERROR;
return(s_ptr);
}
/*
* _XMRecomputeGlobals - Internal subroutine to recompute menu wide
* global values.
*/
void
_XMRecomputeGlobals(register Display *display, register XMenu *menu)
/*X11 display variable. */
/* Menu object to compute from. */
{
register XMPane *p_ptr; /* Pane pointer. */
register XMSelect *s_ptr; /* Selection pointer. */
register int max_p_label = 0; /* Maximum pane label width. */
register int max_s_label = 0; /* Maximum selection label width. */
register int s_count = 0; /* Maximum selection count. */
int p_s_pad; /* Pane <-> selection padding. */
int p_s_diff; /* Pane <-> selection separation. */
int p_height; /* Pane window height. */
int p_width; /* Pane window width. */
int s_width; /* Selection window width. */
int screen; /* DefaultScreen holder. */
/*
* For each pane...
*/
for (
p_ptr = menu->p_list->next;
p_ptr != menu->p_list;
p_ptr = p_ptr->next
){
/*
* Recompute maximum pane label width.
*/
max_p_label = max(max_p_label, p_ptr->label_width);
/*
* Recompute maximum selection count.
*/
s_count = max(s_count, p_ptr->s_count);
/*
* For each selection in the current pane...
*/
for (
s_ptr = p_ptr->s_list->next;
s_ptr != p_ptr->s_list;
s_ptr = s_ptr->next
){
/*
* Recompute maximum selection label width.
*/
max_s_label = max(max_s_label, s_ptr->label_width);
}
}
/*
* Recompute pane height.
*/
p_height = (menu->flag_height << 1) + (menu->s_y_off * s_count);
/*
* Recompute horizontal padding between the pane window and the
* selection windows.
*/
p_s_pad = menu->p_x_off << 1;
/*
* Recompute pane and selection window widths.
* This is done by first computing the window sizes from the maximum
* label widths. If the spacing between the selection window and the
* containing pane window is less than the pane selection padding value
* (twice the pane X offset) then change the size of the pane to be
* the size of the selection window plus the padding. If, however the
* spacing between the selection window and the containing pane window
* is more than the pane selection padding value increase the size of
* the selection to its maximum possible value (the pane width minus
* the pane selection padding value).
*/
p_width = max_p_label + p_s_pad;
s_width = max_s_label + (menu->s_fnt_pad << 1) + (menu->s_bdr_width << 1);
p_s_diff = p_width - s_width;
if (p_s_diff < p_s_pad) {
p_width = s_width + p_s_pad;
}
else if (p_s_diff > p_s_pad) {
s_width = p_width - p_s_pad;
}
/*
* Reset menu wide global values.
*/
menu->s_count = s_count;
menu->p_height = p_height;
menu->p_width = p_width;
menu->s_width = s_width;
/*
* Ensure that the origin of the menu is placed so that
* None of the panes or selections are off the screen.
*/
screen = DefaultScreen(display);
if (menu->x_pos + menu->width > DisplayWidth(display, screen))
menu->x_pos = DisplayWidth(display, screen) - menu->width;
else if (menu->x_pos < 0) menu->x_pos = 0;
if(menu->y_pos + menu->height > DisplayHeight(display, screen))
menu->y_pos = DisplayHeight(display, screen) - menu->height;
else if (menu->y_pos < 0) menu->y_pos = 0;
}
/*
* _XMRecomputePane - Internal subroutine to recompute pane
* window dependencies.
*/
int
_XMRecomputePane(register Display *display, register XMenu *menu, register XMPane *p_ptr, register int p_num)
/* Standard X display variable. */
/* Menu object being recomputed. */
/* Pane pointer. */
/* Pane sequence number. */
{
register int window_x; /* Recomputed window X coordinate. */
register int window_y; /* Recomputed window Y coordinate. */
unsigned long change_mask; /* Value mask to reconfigure window. */
register Bool config_p = False; /* Reconfigure pane window? */
/*
* Update the pane serial number.
*/
p_ptr->serial = p_num;
/*
* Recompute window X and Y coordinates.
*/
switch (menu->menu_style) {
case LEFT:
window_x = menu->p_x_off * ((menu->p_count - 1) - p_num);
window_y = menu->p_y_off * ((menu->p_count - 1) - p_num);
break;
case RIGHT:
window_x = menu->p_x_off * p_num;
window_y = menu->p_y_off * ((menu->p_count - 1) - p_num);
break;
case CENTER:
window_x = 0;
window_y = menu->p_y_off * ((menu->p_count - 1) - p_num);
break;
default:
/* Error! Invalid style parameter. */
_XMErrorCode = XME_STYLE_PARAM;
return(_FAILURE);
}
window_x += menu->x_pos;
window_y += menu->y_pos;
/*
* If the newly compute pane coordinates differ from the
* current coordinates, reset the current coordinates and
* reconfigure the pane.
*/
if (
(window_x != p_ptr->window_x) ||
(window_y != p_ptr->window_y)
){
/*
* Reset the coordinates and schedule
* the pane for reconfiguration.
*/
p_ptr->window_x = window_x;
p_ptr->window_y = window_y;
config_p = True;
}
/*
* If the local pane width and height differs from the
* menu pane width and height, reset the local values.
*/
if (
(p_ptr->window_w != menu->p_width) ||
(p_ptr->window_h != menu->p_height)
){
/*
* Reset window width and height and schedule
* the pane for reconfiguration.
*/
p_ptr->window_w = menu->p_width;
p_ptr->window_h = menu->p_height;
config_p = True;
}
/*
* If we need to reconfigure the pane window do it now.
*/
if (config_p == True) {
/*
* If the pane window has already been created then
* reconfigure the existing window, otherwise queue
* it for creation with the new configuration.
*/
if (p_ptr->window) {
XWindowChanges changes;
change_mask = (CWX | CWY | CWWidth | CWHeight);
changes.x = p_ptr->window_x;
changes.y = p_ptr->window_y;
changes.width = p_ptr->window_w;
changes.height = p_ptr->window_h;
XConfigureWindow(
display,
p_ptr->window,
change_mask,
&changes
);
}
else {
if (_XMWinQueAddPane(display, menu, p_ptr) == _FAILURE) {
return(_FAILURE);
}
}
}
/*
* Recompute label X position.
*/
switch (menu->p_style) {
case LEFT:
p_ptr->label_x = menu->p_x_off + menu->p_fnt_pad;
break;
case RIGHT:
p_ptr->label_x = menu->p_width -
(p_ptr->label_width + menu->p_x_off + menu->p_fnt_pad);
break;
case CENTER:
p_ptr->label_x = (menu->p_width - p_ptr->label_width) >> 1;
break;
default:
/* Error! Invalid style parameter. */
_XMErrorCode = XME_STYLE_PARAM;
return(_FAILURE);
}
/*
* Recompute label Y positions.
*/
p_ptr->label_uy = menu->p_fnt_pad + menu->p_fnt_info->max_bounds.ascent;
p_ptr->label_ly = (menu->p_height - menu->p_fnt_pad - menu->p_fnt_info->max_bounds.descent);
/*
* All went well, return successfully.
*/
_XMErrorCode = XME_NO_ERROR;
return(_SUCCESS);
}
/*
* _XMRecomputeSelection - Internal subroutine to recompute
* selection window dependencies.
*/
int
_XMRecomputeSelection(register Display *display, register XMenu *menu, register XMSelect *s_ptr, register int s_num)
/* Menu object being recomputed. */
/* Selection pointer. */
/* Selection sequence number. */
{
register Bool config_s = False; /* Reconfigure selection window? */
unsigned long change_mask; /* Value mask for XConfigureWindow. */
/*
* If the selection serial numbers are out of order, begin
* resequencing selections. Recompute selection window coordinates
* and serial number.
*
* When selections are created they are given a serial number of
* -1, this causes this routine to give a new selection
* its initial coordinates and serial number.
*/
if (s_ptr->serial != s_num) {
/*
* Fix the sequence number.
*/
s_ptr->serial = s_num;
/*
* Recompute window X and Y coordinates.
*/
s_ptr->window_x = menu->s_x_off;
s_ptr->window_y = menu->flag_height + (menu->s_y_off * s_num);
/*
* We must reconfigure the window.
*/
config_s = True;
}
/*
* If the local selection width and height differs from the
* menu selection width and height, reset the local values.
*/
if (
(s_ptr->window_w != menu->s_width) ||
(s_ptr->window_h != menu->s_height)
){
/*
* We must reconfigure the window.
*/
config_s = True;
/*
* Reset window width and height.
*/
s_ptr->window_w = menu->s_width;
s_ptr->window_h = menu->s_height;
}
/*
* If we need to reconfigure the selection window do it now.
*/
if (config_s == True) {
/*
* If the selection window has already been created then
* reconfigure the existing window, otherwise queue it
* for creation with the new configuration.
*/
if (s_ptr->window) {
XWindowChanges changes;
change_mask = (CWX | CWY | CWWidth | CWHeight);
changes.x = s_ptr->window_x;
changes.y = s_ptr->window_y;
changes.width = s_ptr->window_w;
changes.height = s_ptr->window_h;
XConfigureWindow(
display,
s_ptr->window,
change_mask,
&changes
);
}
else {
if (_XMWinQueAddSelection(display, menu, s_ptr) == _FAILURE) {
return(_FAILURE);
}
}
}
/*
* Recompute label X position.
*/
switch (menu->s_style) {
case LEFT:
s_ptr->label_x = menu->s_bdr_width + menu->s_fnt_pad + s_ptr->window_x;
break;
case RIGHT:
s_ptr->label_x = s_ptr->window_x + menu->s_width -
(s_ptr->label_width + menu->s_bdr_width + menu->s_fnt_pad);
break;
case CENTER:
s_ptr->label_x = s_ptr->window_x + ((menu->s_width - s_ptr->label_width) >> 1);
break;
default:
/* Error! Invalid style parameter. */
_XMErrorCode = XME_STYLE_PARAM;
return(_FAILURE);
}
/*
* Recompute label Y position.
*/
s_ptr->label_y = s_ptr->window_y + menu->s_fnt_info->max_bounds.ascent + menu->s_fnt_pad + menu->s_bdr_width;
/*
* All went well, return successfully.
*/
_XMErrorCode = XME_NO_ERROR;
return(_SUCCESS);
}
/*
* _XMTransToOrigin - Internal subroutine to translate the point at
* the center of the current pane and selection to the
* menu origin.
*
* WARNING! ****** Be certain that all menu dependencies have been
* recomputed before calling this routine or
* unpredictable results will follow.
*/
void
_XMTransToOrigin(Display *display, register XMenu *menu, register XMPane *p_ptr, register XMSelect *s_ptr, int x_pos, int y_pos, int *orig_x, int *orig_y)
/* Not used. Included for consistency. */
/* Menu being computed against. */
/* Current pane pointer. */
/* Current selection pointer. */
/* X coordinate of point to translate. */
/* Y coordinate of point to translate. */
/* Return value X coord. of the menu origin. */
/* Return value Y coord. of the menu origin. */
{
register int l_orig_x; /* Local X coordinate of the menu origin. */
register int l_orig_y; /* Local Y coordinate of the menu origin. */
/*
* Translate the menu origin such that the cursor hot point will be in the
* center of the desired current selection and pane.
* If the current selection pointer is NULL then assume that the hot point
* will be in the center of the current pane flag.
*/
if (s_ptr == NULL) {
/*
* Translate from the center of the pane flag to the upper left
* of the current pane window.
*/
l_orig_x = x_pos - (menu->p_width >> 1) - menu->p_bdr_width;
l_orig_y = y_pos - (menu->flag_height >> 1) - menu->p_bdr_width;
}
else {
/*
* First translate from the center of the current selection
* to the upper left of the current selection window.
*/
l_orig_x = x_pos - (menu->s_width >> 1);
l_orig_y = y_pos - (menu->s_height >> 1);
/*
* Then translate to the upper left of the current pane window.
*/
l_orig_x -= (s_ptr->window_x + menu->p_bdr_width);
l_orig_y -= (s_ptr->window_y + menu->p_bdr_width);
}
/*
* Finally translate to the upper left of the menu.
*/
l_orig_x -= (p_ptr->window_x - menu->x_pos);
l_orig_y -= (p_ptr->window_y - menu->y_pos);
/*
* Set the return values.
*/
*orig_x = l_orig_x;
*orig_y = l_orig_y;
}
/*
* _XMRefreshPane - Internal subroutine to completely refresh
* the contents of a pane.
*/
void
_XMRefreshPane(register Display *display, register XMenu *menu, register XMPane *pane)
{
register XMSelect *s_list = pane->s_list;
register XMSelect *s_ptr;
/*
* First clear the pane.
*/
XClearWindow(display, pane->window);
if (!pane->activated) {
XFillRectangle(display,
pane->window,
menu->inverse_select_GC,
pane->label_x - menu->p_fnt_pad,
pane->label_uy - menu->p_fnt_info->max_bounds.ascent - menu->p_fnt_pad,
pane->label_width + (menu->p_fnt_pad << 1),
menu->flag_height);
XFillRectangle(display,
pane->window,
menu->inverse_select_GC,
pane->label_x - menu->p_fnt_pad,
pane->label_ly - menu->p_fnt_info->max_bounds.ascent - menu->p_fnt_pad,
pane->label_width + (menu->p_fnt_pad << 1),
menu->flag_height);
}
if (!pane->active) {
XDrawString(display,
pane->window,
menu->inact_GC,
pane->label_x, pane->label_uy,
pane->label, pane->label_length);
XDrawString(display,
pane->window,
menu->inact_GC,
pane->label_x, pane->label_ly,
pane->label, pane->label_length);
}
else {
XDrawString(display,
pane->window,
menu->pane_GC,
pane->label_x, pane->label_uy,
pane->label, pane->label_length);
XDrawString(display,
pane->window,
menu->pane_GC,
pane->label_x, pane->label_ly,
pane->label, pane->label_length);
/*
* Finally refresh each selection if the pane is activated.
*/
if (pane->activated) {
for (s_ptr = s_list->next; s_ptr != s_list; s_ptr = s_ptr->next)
_XMRefreshSelection(display, menu, s_ptr);
}
}
}
/*
* _XMRefreshSelection - Internal subroutine that refreshes
* a single selection window.
*/
void
_XMRefreshSelection(register Display *display, register XMenu *menu, register XMSelect *sel)
{
register int width = sel->window_w;
register int height = sel->window_h;
register int bdr_width = menu->s_bdr_width;
if (sel->type == SEPARATOR) {
XDrawLine(display,
sel->parent_p->window,
menu->normal_select_GC,
sel->window_x,
sel->window_y + height / 2,
sel->window_x + width,
sel->window_y + height / 2);
}
else if (sel->activated) {
if (menu->menu_mode == INVERT) {
XFillRectangle(display,
sel->parent_p->window,
menu->normal_select_GC,
sel->window_x, sel->window_y,
width, height);
XDrawString(display,
sel->parent_p->window,
menu->inverse_select_GC,
sel->label_x,
sel->label_y,
sel->label, sel->label_length);
}
else {
/*
* Using BOX mode.
* Since most drawing routines with arbitrary width lines
* are slow compared to raster-ops let's use a raster-op to
* draw the boxes.
*/
XDrawRectangle(display,
sel->parent_p->window,
menu->normal_select_GC,
sel->window_x + (bdr_width >> 1),
sel->window_y + (bdr_width >> 1 ),
width - bdr_width,
height - bdr_width);
XDrawString(display,
sel->parent_p->window,
menu->normal_select_GC,
sel->label_x,
sel->label_y,
sel->label, sel->label_length);
}
}
else {
XClearArea(display,
sel->parent_p->window,
sel->window_x, sel->window_y,
width, height,
False);
if (sel->active) {
XDrawString(display,
sel->parent_p->window,
menu->normal_select_GC,
sel->label_x,
sel->label_y,
sel->label, sel->label_length);
}
else {
XDrawString(display,
sel->parent_p->window,
menu->inact_GC,
sel->label_x,
sel->label_y,
sel->label, sel->label_length);
}
}
}
Reference in New Issue View Git Blame Copy Permalink