diff options
| -rw-r--r-- | src/w32term.h | 589 |
1 files changed, 589 insertions, 0 deletions
diff --git a/src/w32term.h b/src/w32term.h new file mode 100644 index 00000000000..80347a08870 --- /dev/null +++ b/src/w32term.h @@ -0,0 +1,589 @@ +/* Definitions and headers for communication with Win32 GUI. + Copyright (C) 1995 Free Software Foundation, Inc. + +This file is part of GNU Emacs. + +GNU Emacs is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Emacs is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Emacs; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Added by Kevin Gallo */ + +#include <win32.h> + +/* The class of this X application. */ +#define EMACS_CLASS "Emacs" + +#define BLACK_PIX_DEFAULT(f) RGB(0,0,0) +#define WHITE_PIX_DEFAULT(f) RGB(255,255,255) + +#define FONT_WIDTH(f) ((f)->tm.tmMaxCharWidth) +#define FONT_HEIGHT(f) ((f)->tm.tmHeight) +#define FONT_BASE(f) ((f)->tm.tmAscent) + +#define CHECK_WIN32_FRAME(f, frame) \ + if (NILP (frame)) \ + f = selected_frame; \ + else \ + { \ + CHECK_LIVE_FRAME (frame, 0); \ + f = XFRAME (frame); \ + } \ + if (! FRAME_WIN32_P (f)) + +/* Indicates whether we are in the readsocket call and the message we + are processing in the current loop */ + +extern MSG CurMsg; +extern BOOL bUseDflt; + +extern struct frame *x_window_to_frame (); + +enum text_cursor_kinds { + filled_box_cursor, hollow_box_cursor, bar_cursor +}; + +/* This data type is used for the font_table field + of struct win32_display_info. */ + +struct font_info +{ + XFontStruct *font; + char *name; +}; + +/* Structure recording bitmaps and reference count. + If REFCOUNT is 0 then this record is free to be reused. */ + +struct win32_bitmap_record +{ + Pixmap pixmap; + char *file; + HINSTANCE hinst; /* Used to load the file */ + int refcount; + /* Record some info about this pixmap. */ + int height, width, depth; +}; + +/* For each display (currently only one on win32), we have a structure that + records information about it. */ + +struct win32_display_info +{ + /* Chain of all win32_display_info structures. */ + struct win32_display_info *next; + /* This is a cons cell of the form (NAME . FONT-LIST-CACHE). + The same cons cell also appears in x_display_name_list. */ + Lisp_Object name_list_element; + /* Number of frames that are on this display. */ + int reference_count; + /* Number of planes on this screen. */ + int n_planes; + /* Number of bits per pixel on this screen. */ + int n_cbits; + /* Dimensions of this screen. */ + int height, width; + int height_in,width_in; + /* Mask of things that cause the mouse to be grabbed. */ + int grabbed; + /* The root window of this screen. */ + Window root_window; + /* The cursor to use for vertical scroll bars. */ + Cursor vertical_scroll_bar_cursor; + + /* A table of all the fonts we have already loaded. */ + struct font_info *font_table; + + /* The current capacity of x_font_table. */ + int font_table_size; + + /* These variables describe the range of text currently shown + in its mouse-face, together with the window they apply to. + As long as the mouse stays within this range, we need not + redraw anything on its account. */ + int mouse_face_beg_row, mouse_face_beg_col; + int mouse_face_end_row, mouse_face_end_col; + int mouse_face_past_end; + Lisp_Object mouse_face_window; + int mouse_face_face_id; + + /* 1 if a mouse motion event came and we didn't handle it right away because + gc was in progress. */ + int mouse_face_deferred_gc; + + /* FRAME and X, Y position of mouse when last checked for + highlighting. X and Y can be negative or out of range for the frame. */ + struct frame *mouse_face_mouse_frame; + int mouse_face_mouse_x, mouse_face_mouse_y; + + /* Nonzero means defer mouse-motion highlighting. */ + int mouse_face_defer; + + char *win32_id_name; + + /* The number of fonts actually stored in win32_font_table. + font_table[n] is used and valid iff 0 <= n < n_fonts. + 0 <= n_fonts <= font_table_size. */ + int n_fonts; + + /* Pointer to bitmap records. */ + struct win32_bitmap_record *bitmaps; + + /* Allocated size of bitmaps field. */ + int bitmaps_size; + + /* Last used bitmap index. */ + int bitmaps_last; + + /* The frame (if any) which has the window that has keyboard focus. + Zero if none. This is examined by Ffocus_frame in w32fns.c. Note + that a mere EnterNotify event can set this; if you need to know the + last frame specified in a FocusIn or FocusOut event, use + win32_focus_event_frame. */ + struct frame *win32_focus_frame; + + /* The last frame mentioned in a FocusIn or FocusOut event. This is + separate from win32_focus_frame, because whether or not LeaveNotify + events cause us to lose focus depends on whether or not we have + received a FocusIn event for it. */ + struct frame *win32_focus_event_frame; + + /* The frame which currently has the visual highlight, and should get + keyboard input (other sorts of input have the frame encoded in the + event). It points to the focus frame's selected window's + frame. It differs from win32_focus_frame when we're using a global + minibuffer. */ + struct frame *win32_highlight_frame; +}; + +/* This is a chain of structures for all the displays currently in use. */ +extern struct win32_display_info one_win32_display_info; + +/* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE), + one for each element of win32_display_list and in the same order. + NAME is the name of the frame. + FONT-LIST-CACHE records previous values returned by x-list-fonts. */ +extern Lisp_Object win32_display_name_list; + +extern struct win32_display_info *x_display_info_for_display (); +extern struct win32_display_info *x_display_info_for_name (); + +extern struct win32_display_info *win32_term_init (); + +/* Each Win32 frame object points to its own struct win32_display object + in the output_data.win32 field. The win32_display structure contains all + the information that is specific to Win32 windows. */ + +struct win32_output +{ + /* Position of the Win32 window (x and y offsets in root window). */ + int left_pos; + int top_pos; + + /* Border width of the Win32 window as known by the window system. */ + int border_width; + + /* Size of the Win32 window in pixels. */ + int pixel_height, pixel_width; + + /* Height of a line, in pixels. */ + int line_height; + + /* Width of the internal border. This is a line of background color + just inside the window's border. When the frame is selected, + a highlighting is displayed inside the internal border. */ + int internal_border_width; + + /* The window used for this frame. + May be zero while the frame object is being created + and the window has not yet been created. */ + Window window_desc; + + /* The window that is the parent of this window. + Usually this is a window that was made by the window manager, + but it can be the root window, and it can be explicitly specified + (see the explicit_parent field, below). */ + Window parent_desc; + + XFontStruct *font; + + /* Pixel values used for various purposes. + border_pixel may be -1 meaning use a gray tile. */ + unsigned long background_pixel; + unsigned long foreground_pixel; + unsigned long cursor_pixel; + unsigned long border_pixel; + unsigned long mouse_pixel; + unsigned long cursor_foreground_pixel; + + /* Descriptor for the cursor in use for this window. */ + Cursor text_cursor; + Cursor nontext_cursor; + Cursor modeline_cursor; + Cursor cross_cursor; + + /* Flag to set when the window needs to be completely repainted. */ + int needs_exposure; + + /* What kind of text cursor is drawn in this window right now? + (If there is no cursor (phys_cursor_x < 0), then this means nothing.) */ + enum text_cursor_kinds current_cursor; + + /* What kind of text cursor should we draw in the future? + This should always be filled_box_cursor or bar_cursor. */ + enum text_cursor_kinds desired_cursor; + + /* Width of bar cursor (if we are using that). */ + int cursor_width; + + DWORD dwStyle; + + /* The size of the extra width currently allotted for vertical + scroll bars, in pixels. */ + int vertical_scroll_bar_extra; + + /* Table of parameter faces for this frame. Any resources (pixel + values, fonts) referred to here have been allocated explicitly + for this face, and should be freed if we change the face. */ + struct face **param_faces; + int n_param_faces; + + /* Table of computed faces for this frame. These are the faces + whose indexes go into the upper bits of a glyph, computed by + combining the parameter faces specified by overlays, text + properties, and what have you. The resources mentioned here + are all shared with parameter faces. */ + struct face **computed_faces; + int n_computed_faces; /* How many are valid */ + int size_computed_faces; /* How many are allocated */ + + /* This is the gravity value for the specified window position. */ + int win_gravity; + + /* The geometry flags for this window. */ + int size_hint_flags; + + /* This is the Emacs structure for the display this frame is on. */ + /* struct win32_display_info *display_info; */ + + /* Nonzero means our parent is another application's window + and was explicitly specified. */ + char explicit_parent; + + /* Nonzero means tried already to make this frame visible. */ + char asked_for_visible; +}; + +/* Get at the computed faces of an X window frame. */ +#define FRAME_PARAM_FACES(f) ((f)->output_data.win32->param_faces) +#define FRAME_N_PARAM_FACES(f) ((f)->output_data.win32->n_param_faces) +#define FRAME_DEFAULT_PARAM_FACE(f) (FRAME_PARAM_FACES (f)[0]) +#define FRAME_MODE_LINE_PARAM_FACE(f) (FRAME_PARAM_FACES (f)[1]) + +#define FRAME_COMPUTED_FACES(f) ((f)->output_data.win32->computed_faces) +#define FRAME_N_COMPUTED_FACES(f) ((f)->output_data.win32->n_computed_faces) +#define FRAME_SIZE_COMPUTED_FACES(f) ((f)->output_data.win32->size_computed_faces) +#define FRAME_DEFAULT_FACE(f) ((f)->output_data.win32->computed_faces[0]) +#define FRAME_MODE_LINE_FACE(f) ((f)->output_data.win32->computed_faces[1]) + +/* Return the window associated with the frame F. */ +#define FRAME_WIN32_WINDOW(f) ((f)->output_data.win32->window_desc) + +#define FRAME_FOREGROUND_PIXEL(f) ((f)->output_data.win32->foreground_pixel) +#define FRAME_BACKGROUND_PIXEL(f) ((f)->output_data.win32->background_pixel) +#define FRAME_FONT(f) ((f)->output_data.win32->font) +#define FRAME_INTERNAL_BORDER_WIDTH(f) ((f)->output_data.win32->internal_border_width) + +/* This gives the win32_display_info structure for the display F is on. */ +#define FRAME_WIN32_DISPLAY_INFO(f) (&one_win32_display_info) + +/* These two really ought to be called FRAME_PIXEL_{WIDTH,HEIGHT}. */ +#define PIXEL_WIDTH(f) ((f)->output_data.win32->pixel_width) +#define PIXEL_HEIGHT(f) ((f)->output_data.win32->pixel_height) +#define FRAME_LINE_HEIGHT(f) ((f)->output_data.win32->line_height) + +#define FRAME_DESIRED_CURSOR(f) ((f)->output_data.win32->desired_cursor) + + +/* Win32-specific scroll bar stuff. */ + +/* We represent scroll bars as lisp vectors. This allows us to place + references to them in windows without worrying about whether we'll + end up with windows referring to dead scroll bars; the garbage + collector will free it when its time comes. + + We use struct scroll_bar as a template for accessing fields of the + vector. */ + +struct scroll_bar { + + /* These fields are shared by all vectors. */ + EMACS_INT size_from_Lisp_Vector_struct; + struct Lisp_Vector *next_from_Lisp_Vector_struct; + + /* The window we're a scroll bar for. */ + Lisp_Object window; + + /* The next and previous in the chain of scroll bars in this frame. */ + Lisp_Object next, prev; + + /* The window representing this scroll bar. Since this is a full + 32-bit quantity, we store it split into two 32-bit values. */ + Lisp_Object win32_window_low, win32_window_high; + + /* The position and size of the scroll bar in pixels, relative to the + frame. */ + Lisp_Object top, left, width, height; + + /* The starting and ending positions of the handle, relative to the + handle area (i.e. zero is the top position, not + SCROLL_BAR_TOP_BORDER). If they're equal, that means the handle + hasn't been drawn yet. + + These are not actually the locations where the beginning and end + are drawn; in order to keep handles from becoming invisible when + editing large files, we establish a minimum height by always + drawing handle bottoms VERTICAL_SCROLL_BAR_MIN_HANDLE pixels below + where they would be normally; the bottom and top are in a + different co-ordinate system. */ + Lisp_Object start, end; + + /* If the scroll bar handle is currently being dragged by the user, + this is the number of pixels from the top of the handle to the + place where the user grabbed it. If the handle isn't currently + being dragged, this is Qnil. */ + Lisp_Object dragging; +}; + +/* The number of elements a vector holding a struct scroll_bar needs. */ +#define SCROLL_BAR_VEC_SIZE \ + ((sizeof (struct scroll_bar) \ + - sizeof (EMACS_INT) - sizeof (struct Lisp_Vector *)) \ + / sizeof (Lisp_Object)) + +/* Turning a lisp vector value into a pointer to a struct scroll_bar. */ +#define XSCROLL_BAR(vec) ((struct scroll_bar *) XVECTOR (vec)) + + +/* Building a 32-bit C integer from two 16-bit lisp integers. */ +#define SCROLL_BAR_PACK(low, high) (XINT (high) << 16 | XINT (low)) + +/* Setting two lisp integers to the low and high words of a 32-bit C int. */ +#define SCROLL_BAR_UNPACK(low, high, int32) \ + (XSETINT ((low), (int32) & 0xffff), \ + XSETINT ((high), ((int32) >> 16) & 0xffff)) + + +/* Extract the window id of the scroll bar from a struct scroll_bar. */ +#define SCROLL_BAR_WIN32_WINDOW(ptr) \ + ((Window) SCROLL_BAR_PACK ((ptr)->win32_window_low, (ptr)->win32_window_high)) + +/* Store a window id in a struct scroll_bar. */ +#define SET_SCROLL_BAR_WIN32_WINDOW(ptr, id) \ + (SCROLL_BAR_UNPACK ((ptr)->win32_window_low, (ptr)->win32_window_high, (int) id)) + + +/* Return the outside pixel height for a vertical scroll bar HEIGHT + rows high on frame F. */ +#define VERTICAL_SCROLL_BAR_PIXEL_HEIGHT(f, height) \ + ((height) * (f)->output_data.win32->line_height) + +/* Return the inside width of a vertical scroll bar, given the outside + width. */ +#define VERTICAL_SCROLL_BAR_INSIDE_WIDTH(width) \ + ((width) - VERTICAL_SCROLL_BAR_LEFT_BORDER - VERTICAL_SCROLL_BAR_RIGHT_BORDER) + +/* Return the length of the rectangle within which the top of the + handle must stay. This isn't equivalent to the inside height, + because the scroll bar handle has a minimum height. + + This is the real range of motion for the scroll bar, so when we're + scaling buffer positions to scroll bar positions, we use this, not + VERTICAL_SCROLL_BAR_INSIDE_HEIGHT. */ +#define VERTICAL_SCROLL_BAR_TOP_RANGE(height) \ + (VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (height) - VERTICAL_SCROLL_BAR_MIN_HANDLE) + +/* Return the inside height of vertical scroll bar, given the outside + height. See VERTICAL_SCROLL_BAR_TOP_RANGE too. */ +#define VERTICAL_SCROLL_BAR_INSIDE_HEIGHT(height) \ + ((height) - VERTICAL_SCROLL_BAR_TOP_BORDER - VERTICAL_SCROLL_BAR_BOTTOM_BORDER) + + +/* Border widths for scroll bars. + + Scroll bar windows don't have any borders; their border width is + set to zero, and we redraw borders ourselves. This makes the code + a bit cleaner, since we don't have to convert between outside width + (used when relating to the rest of the screen) and inside width + (used when sizing and drawing the scroll bar window itself). + + The handle moves up and down/back and forth in a rectangle inset + from the edges of the scroll bar. These are widths by which we + inset the handle boundaries from the scroll bar edges. */ +#define VERTICAL_SCROLL_BAR_LEFT_BORDER (0) +#define VERTICAL_SCROLL_BAR_RIGHT_BORDER (0) +#define VERTICAL_SCROLL_BAR_TOP_BORDER (0) +#define VERTICAL_SCROLL_BAR_BOTTOM_BORDER (0) + +/* Minimum lengths for scroll bar handles, in pixels. */ +#define VERTICAL_SCROLL_BAR_MIN_HANDLE (0) + + +/* Manipulating pixel sizes and character sizes. + Knowledge of which factors affect the overall size of the window should + be hidden in these macros, if that's possible. + + Return the upper/left pixel position of the character cell on frame F + at ROW/COL. */ +#define CHAR_TO_PIXEL_ROW(f, row) \ + ((f)->output_data.win32->internal_border_width \ + + (row) * (f)->output_data.win32->line_height) +#define CHAR_TO_PIXEL_COL(f, col) \ + ((f)->output_data.win32->internal_border_width \ + + (col) * FONT_WIDTH ((f)->output_data.win32->font)) + +/* Return the pixel width/height of frame F if it has + WIDTH columns/HEIGHT rows. */ +#define CHAR_TO_PIXEL_WIDTH(f, width) \ + (CHAR_TO_PIXEL_COL (f, width) \ + + (f)->output_data.win32->vertical_scroll_bar_extra \ + + (f)->output_data.win32->internal_border_width) +#define CHAR_TO_PIXEL_HEIGHT(f, height) \ + (CHAR_TO_PIXEL_ROW (f, height) \ + + (f)->output_data.win32->internal_border_width) + + +/* Return the row/column (zero-based) of the character cell containing + the pixel on FRAME at ROW/COL. */ +#define PIXEL_TO_CHAR_ROW(f, row) \ + (((row) - (f)->output_data.win32->internal_border_width) \ + / (f)->output_data.win32->line_height) +#define PIXEL_TO_CHAR_COL(f, col) \ + (((col) - (f)->output_data.win32->internal_border_width) \ + / FONT_WIDTH ((f)->output_data.win32->font)) + +/* How many columns/rows of text can we fit in WIDTH/HEIGHT pixels on + frame F? */ +#define PIXEL_TO_CHAR_WIDTH(f, width) \ + (PIXEL_TO_CHAR_COL (f, ((width) \ + - (f)->output_data.win32->internal_border_width \ + - (f)->output_data.win32->vertical_scroll_bar_extra))) +#define PIXEL_TO_CHAR_HEIGHT(f, height) \ + (PIXEL_TO_CHAR_ROW (f, ((height) \ + - (f)->output_data.win32->internal_border_width))) + +/* Interface to the face code functions. */ + +/* Create the first two computed faces for a frame -- the ones that + have GC's. */ +extern void init_frame_faces (/* FRAME_PTR */); + +/* Free the resources for the faces associated with a frame. */ +extern void free_frame_faces (/* FRAME_PTR */); + +/* Given a computed face, find or make an equivalent display face + in face_vector, and return a pointer to it. */ +extern struct face *intern_face (/* FRAME_PTR, struct face * */); + +/* Given a frame and a face name, return the face's ID number, or + zero if it isn't a recognized face name. */ +extern int face_name_id_number (/* FRAME_PTR, Lisp_Object */); + +/* Return non-zero if FONT1 and FONT2 have the same size bounding box. + We assume that they're both character-cell fonts. */ +extern int same_size_fonts (/* XFontStruct *, XFontStruct * */); + +/* Recompute the GC's for the default and modeline faces. + We call this after changing frame parameters on which those GC's + depend. */ +extern void recompute_basic_faces (/* FRAME_PTR */); + +/* Return the face ID associated with a buffer position POS. Store + into *ENDPTR the next position at which a different face is + needed. This does not take account of glyphs that specify their + own face codes. F is the frame in use for display, and W is a + window displaying the current buffer. + + REGION_BEG, REGION_END delimit the region, so it can be highlighted. */ +extern int compute_char_face (/* FRAME_PTR frame, + struct window *w, + int pos, + int region_beg, int region_end, + int *endptr */); +/* Return the face ID to use to display a special glyph which selects + FACE_CODE as the face ID, assuming that ordinarily the face would + be BASIC_FACE. F is the frame. */ +extern int compute_glyph_face (/* FRAME_PTR, int */); + +extern void win32_fill_rect (); +extern void win32_clear_window (); + +#define win32_fill_area(f,hdc,pix,x,y,nx,ny) \ +{ \ + RECT rect; \ + rect.left = x; \ + rect.top = y; \ + rect.right = x + nx; \ + rect.bottom = y + ny; \ + win32_fill_rect (f,hdc,pix,&rect); \ +} + +#define win32_clear_rect(f,hdc,lprect) \ +win32_fill_rect (f,hdc,f->output_data.win32->background_pixel,lprect) + +#define win32_clear_area(f,hdc,x,y,nx,ny) \ +win32_fill_area (f,hdc,f->output_data.win32->background_pixel,x,y,nx,ny) + +extern XFontStruct *win32_load_font (); +extern void win32_unload_font (); + +extern HDC map_mode(); + +#define my_get_dc(hwnd) (map_mode (GetDC (hwnd))) + +#define WM_EMACS_START (WM_USER + 1) +#define WM_EMACS_KILL (WM_EMACS_START + 0x00) +#define WM_EMACS_CREATEWINDOW (WM_EMACS_START + 0x01) +#define WM_EMACS_DONE (WM_EMACS_START + 0x02) +#define WM_EMACS_CREATESCROLLBAR (WM_EMACS_START + 0x03) +#define WM_EMACS_DESTROYWINDOW (WM_EMACS_START + 0x04) +#define WM_EMACS_END (WM_EMACS_START + 0x10) + +#define WND_X_UNITS_INDEX (0) +#define WND_Y_UNITS_INDEX (4) +#define WND_BACKGROUND_INDEX (8) + +#define WND_LAST_INDEX (16) +#define WND_EXTRA_BYTES (WND_LAST_INDEX) + +extern DWORD dwWinThreadId; +extern HANDLE hWinThread; +extern DWORD dwMainThreadId; +extern HANDLE hMainThread; + +typedef struct Win32Msg { + MSG msg; + DWORD dwModifiers; + RECT rect; +} Win32Msg; + +extern void init_crit (); +extern void enter_crit (); +extern void leave_crit (); +extern void delete_crit (); + +extern BOOL get_next_msg (); +extern BOOL post_msg (); +extern void wait_for_sync (); + +extern BOOL parse_button (); |