Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

1557 lines (1340 sloc) 38.482 kB
/* vi:set ts=8 sts=4 sw=4:
*
* VIM - Vi IMproved by Bram Moolenaar
* GUI support by Robert Webb
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
* See README.txt for an overview of the Vim source code.
*/
/*
* gui_w16.c
*
* GUI support for Microsoft Windows 3.1x
*
* George V. Reilly <george@reilly.org> wrote the original Win32 GUI.
* Robert Webb reworked it to use the existing GUI stuff and added menu,
* scrollbars, etc.
*
* Vince Negri then butchered the code to get it compiling for
* 16-bit windows.
*
*/
/*
* Include the common stuff for MS-Windows GUI.
*/
#include "gui_w48.c"
#include "guiw16rc.h"
/* Undocumented Windows Message - not even defined in some SDK headers */
#define WM_EXITSIZEMOVE 0x0232
#ifdef FEAT_TOOLBAR
# define CMD_TB_BASE (99)
# include <vimtbar.h>
#endif
#ifdef PROTO
# define WINAPI
#endif
#define HANDLE_WM_DROPFILES(hwnd, wParam, lParam, fn) \
((fn)((hwnd), (HDROP)(wParam)), 0L)
/* Local variables: */
#ifdef FEAT_MENU
static UINT s_menu_id = 100;
#endif
#define VIM_NAME "vim"
#define VIM_CLASS "Vim"
#define DLG_ALLOC_SIZE 16 * 1024
/*
* stuff for dialogs, menus, tearoffs etc.
*/
#if defined(FEAT_GUI_DIALOG) || defined(PROTO)
static BOOL CALLBACK dialog_callback(HWND, UINT, WPARAM, LPARAM);
static LPWORD
add_dialog_element(
LPWORD p,
DWORD lStyle,
WORD x,
WORD y,
WORD w,
WORD h,
WORD Id,
BYTE clss,
const char *caption);
static int dialog_default_button = -1;
#endif
static void get_dialog_font_metrics(void);
#ifdef FEAT_TOOLBAR
static void initialise_toolbar(void);
#endif
#ifdef FEAT_MENU
/*
* Figure out how high the menu bar is at the moment.
*/
static int
gui_mswin_get_menu_height(
int fix_window) /* If TRUE, resize window if menu height changed */
{
static int old_menu_height = -1;
int num;
int menu_height;
if (gui.menu_is_active)
num = GetMenuItemCount(s_menuBar);
else
num = 0;
if (num == 0)
menu_height = 0;
else if (gui.starting)
menu_height = GetSystemMetrics(SM_CYMENU);
else
{
RECT r1, r2;
int frameht = GetSystemMetrics(SM_CYFRAME);
int capht = GetSystemMetrics(SM_CYCAPTION);
/* get window rect of s_hwnd
* get client rect of s_hwnd
* get cap height
* subtract from window rect, the sum of client height,
* (if not maximized)frame thickness, and caption height.
*/
GetWindowRect(s_hwnd, &r1);
GetClientRect(s_hwnd, &r2);
menu_height = r1.bottom - r1.top - (r2.bottom-r2.top +
2 * frameht * (!IsZoomed(s_hwnd)) + capht);
}
if (fix_window && menu_height != old_menu_height)
{
old_menu_height = menu_height;
gui_set_shellsize(FALSE, FALSE, RESIZE_VERT);
}
return menu_height;
}
#endif /*FEAT_MENU*/
/*
* Even though we have _DuringSizing() which makes the rubber band a valid
* size, we need this for when the user maximises the window.
* TODO: Doesn't seem to adjust the width though for some reason.
*/
static BOOL
_OnWindowPosChanging(
HWND hwnd,
LPWINDOWPOS lpwpos)
{
if (!IsIconic(hwnd) && !(lpwpos->flags & SWP_NOSIZE))
{
gui_mswin_get_valid_dimensions(lpwpos->cx, lpwpos->cy,
&lpwpos->cx, &lpwpos->cy);
}
return 0;
}
static LRESULT CALLBACK
_WndProc(
HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
/*
TRACE("WndProc: hwnd = %08x, msg = %x, wParam = %x, lParam = %x\n",
hwnd, uMsg, wParam, lParam);
*/
HandleMouseHide(uMsg, lParam);
s_uMsg = uMsg;
s_wParam = wParam;
s_lParam = lParam;
switch (uMsg)
{
HANDLE_MSG(hwnd, WM_DEADCHAR, _OnDeadChar);
HANDLE_MSG(hwnd, WM_SYSDEADCHAR, _OnDeadChar);
/* HANDLE_MSG(hwnd, WM_ACTIVATE, _OnActivate); */
HANDLE_MSG(hwnd, WM_CHAR, _OnChar);
HANDLE_MSG(hwnd, WM_CLOSE, _OnClose);
/* HANDLE_MSG(hwnd, WM_COMMAND, _OnCommand); */
HANDLE_MSG(hwnd, WM_DESTROY, _OnDestroy);
HANDLE_MSG(hwnd, WM_DROPFILES, _OnDropFiles);
HANDLE_MSG(hwnd, WM_HSCROLL, _OnScroll);
HANDLE_MSG(hwnd, WM_KILLFOCUS, _OnKillFocus);
#ifdef FEAT_MENU
HANDLE_MSG(hwnd, WM_COMMAND, _OnMenu);
#endif
/* HANDLE_MSG(hwnd, WM_MOVE, _OnMove); */
/* HANDLE_MSG(hwnd, WM_NCACTIVATE, _OnNCActivate); */
HANDLE_MSG(hwnd, WM_SETFOCUS, _OnSetFocus);
HANDLE_MSG(hwnd, WM_SIZE, _OnSize);
/* HANDLE_MSG(hwnd, WM_SYSCOMMAND, _OnSysCommand); */
/* HANDLE_MSG(hwnd, WM_SYSKEYDOWN, _OnAltKey); */
HANDLE_MSG(hwnd, WM_VSCROLL, _OnScroll);
HANDLE_MSG(hwnd, WM_WINDOWPOSCHANGING, _OnWindowPosChanging);
HANDLE_MSG(hwnd, WM_ACTIVATEAPP, _OnActivateApp);
case WM_QUERYENDSESSION: /* System wants to go down. */
gui_shell_closed(); /* Will exit when no changed buffers. */
return FALSE; /* Do NOT allow system to go down. */
case WM_ENDSESSION:
if (wParam) /* system only really goes down when wParam is TRUE */
_OnEndSession();
break;
case WM_SYSCHAR:
/*
* if 'winaltkeys' is "no", or it's "menu" and it's not a menu
* shortcut key, handle like a typed ALT key, otherwise call Windows
* ALT key handling.
*/
#ifdef FEAT_MENU
if ( !gui.menu_is_active
|| p_wak[0] == 'n'
|| (p_wak[0] == 'm' && !gui_is_menu_shortcut((int)wParam))
)
#endif
return HANDLE_WM_SYSCHAR((hwnd), (wParam), (lParam), (_OnSysChar));
#ifdef FEAT_MENU
else
return MyWindowProc(hwnd, uMsg, wParam, lParam);
#endif
case WM_SYSKEYUP:
#ifdef FEAT_MENU
/* Only when menu is active, ALT key is used for that. */
if (gui.menu_is_active)
{
return MyWindowProc(hwnd, uMsg, wParam, lParam);
}
else
#endif
return 0;
#if defined(MENUHINTS) && defined(FEAT_MENU)
case WM_MENUSELECT:
if (((UINT) LOWORD(lParam)
& (0xffff ^ (MF_MOUSESELECT + MF_BITMAP + MF_POPUP)))
== MF_HILITE
&& (State & CMDLINE) == 0)
{
UINT idButton;
int idx;
vimmenu_T *pMenu;
idButton = (UINT)LOWORD(wParam);
pMenu = gui_mswin_find_menu(root_menu, idButton);
if (pMenu)
{
idx = MENU_INDEX_TIP;
msg_clr_cmdline();
if (pMenu->strings[idx])
msg(pMenu->strings[idx]);
else
msg("");
setcursor();
out_flush();
}
}
break;
#endif
case WM_NCHITTEST:
{
LRESULT result;
int x, y;
int xPos = GET_X_LPARAM(lParam);
result = MyWindowProc(hwnd, uMsg, wParam, lParam);
if (result == HTCLIENT)
{
gui_mch_get_winpos(&x, &y);
xPos -= x;
if (xPos < 48) /*<VN> TODO should use system metric?*/
return HTBOTTOMLEFT;
else
return HTBOTTOMRIGHT;
}
else
return result;
}
/* break; */
default:
#ifdef MSWIN_FIND_REPLACE
if (uMsg == s_findrep_msg && s_findrep_msg != 0)
{
_OnFindRepl();
}
#endif
return MyWindowProc(hwnd, uMsg, wParam, lParam);
}
return 1;
}
/*
* End of call-back routines
*/
/*
* Parse the GUI related command-line arguments. Any arguments used are
* deleted from argv, and *argc is decremented accordingly. This is called
* when vim is started, whether or not the GUI has been started.
*/
void
gui_mch_prepare(int *argc, char **argv)
{
/* No special args for win16 GUI at the moment. */
}
/*
* Initialise the GUI. Create all the windows, set up all the call-backs
* etc.
*/
int
gui_mch_init(void)
{
const char szVimWndClass[] = VIM_CLASS;
const char szTextAreaClass[] = "VimTextArea";
WNDCLASS wndclass;
#ifdef WIN16_3DLOOK
Ctl3dRegister(s_hinst);
Ctl3dAutoSubclass(s_hinst);
#endif
/* Display any pending error messages */
display_errors();
gui.scrollbar_width = GetSystemMetrics(SM_CXVSCROLL);
gui.scrollbar_height = GetSystemMetrics(SM_CYHSCROLL);
#ifdef FEAT_MENU
gui.menu_height = 0; /* Windows takes care of this */
#endif
gui.border_width = 0;
gui.currBgColor = INVALCOLOR;
s_brush = CreateSolidBrush(GetSysColor(COLOR_BTNFACE));
if (GetClassInfo(s_hinst, szVimWndClass, &wndclass) == 0) {
wndclass.style = 0;
wndclass.lpfnWndProc = _WndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = s_hinst;
wndclass.hIcon = LoadIcon(wndclass.hInstance, MAKEINTRESOURCE(IDR_VIM));
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = s_brush;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = szVimWndClass;
if ((
#ifdef GLOBAL_IME
atom =
#endif
RegisterClass(&wndclass)) == 0)
return FAIL;
}
s_hwnd = CreateWindow(
szVimWndClass, "Vim MSWindows GUI",
WS_OVERLAPPEDWINDOW,
gui_win_x == -1 ? CW_USEDEFAULT : gui_win_x,
gui_win_y == -1 ? CW_USEDEFAULT : gui_win_y,
100, /* Any value will do */
100, /* Any value will do */
NULL, NULL,
s_hinst, NULL);
if (s_hwnd == NULL)
return FAIL;
#ifdef GLOBAL_IME
global_ime_init(atom, s_hwnd);
#endif
/* Create the text area window */
if (GetClassInfo(s_hinst, szTextAreaClass, &wndclass) == 0) {
wndclass.style = CS_OWNDC;
wndclass.lpfnWndProc = _TextAreaWndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hInstance = s_hinst;
wndclass.hIcon = NULL;
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hbrBackground = NULL;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = szTextAreaClass;
if (RegisterClass(&wndclass) == 0)
return FAIL;
}
s_textArea = CreateWindow(
szTextAreaClass, "Vim text area",
WS_CHILD | WS_VISIBLE, 0, 0,
100, /* Any value will do for now */
100, /* Any value will do for now */
s_hwnd, NULL,
s_hinst, NULL);
if (s_textArea == NULL)
return FAIL;
#ifdef FEAT_MENU
s_menuBar = CreateMenu();
#endif
s_hdc = GetDC(s_textArea);
#ifdef MSWIN16_FASTTEXT
SetBkMode(s_hdc, OPAQUE);
#endif
DragAcceptFiles(s_hwnd, TRUE);
/* Do we need to bother with this? */
/* m_fMouseAvail = GetSystemMetrics(SM_MOUSEPRESENT); */
/* Get background/foreground colors from the system */
gui_mch_def_colors();
/* Get the colors from the "Normal" group (set in syntax.c or in a vimrc
* file) */
set_normal_colors();
/*
* Check that none of the colors are the same as the background color.
* Then store the current values as the defaults.
*/
gui_check_colors();
gui.def_norm_pixel = gui.norm_pixel;
gui.def_back_pixel = gui.back_pixel;
/* Get the colors for the highlight groups (gui_check_colors() might have
* changed them) */
highlight_gui_started();
/*
* Start out by adding the configured border width into the border offset
*/
gui.border_offset = gui.border_width;
/*
* compute a couple of metrics used for the dialogs
*/
get_dialog_font_metrics();
#ifdef FEAT_TOOLBAR
/*
* Create the toolbar
*/
initialise_toolbar();
#endif
#ifdef MSWIN_FIND_REPLACE
/*
* Initialise the dialog box stuff
*/
s_findrep_msg = RegisterWindowMessage(FINDMSGSTRING);
/* Initialise the struct */
s_findrep_struct.lStructSize = sizeof(s_findrep_struct);
s_findrep_struct.lpstrFindWhat = alloc(MSWIN_FR_BUFSIZE);
s_findrep_struct.lpstrFindWhat[0] = NUL;
s_findrep_struct.lpstrReplaceWith = alloc(MSWIN_FR_BUFSIZE);
s_findrep_struct.lpstrReplaceWith[0] = NUL;
s_findrep_struct.wFindWhatLen = MSWIN_FR_BUFSIZE;
s_findrep_struct.wReplaceWithLen = MSWIN_FR_BUFSIZE;
#endif
return OK;
}
/*
* Set the size of the window to the given width and height in pixels.
*/
void
gui_mch_set_shellsize(int width, int height,
int min_width, int min_height, int base_width, int base_height,
int direction)
{
RECT workarea_rect;
int win_width, win_height;
int win_xpos, win_ypos;
WINDOWPLACEMENT wndpl;
/* try to keep window completely on screen */
/* get size of the screen work area - use SM_CYFULLSCREEN
* instead of SM_CYSCREEN so that we don't overlap the
* taskbar if someone fires us up on Win95/NT */
workarea_rect.left = 0;
workarea_rect.top = 0;
workarea_rect.right = GetSystemMetrics(SM_CXSCREEN);
workarea_rect.bottom = GetSystemMetrics(SM_CYFULLSCREEN);
/* get current posision of our window */
wndpl.length = sizeof(WINDOWPLACEMENT);
GetWindowPlacement(s_hwnd, &wndpl);
if (wndpl.showCmd == SW_SHOWNORMAL)
{
win_xpos = wndpl.rcNormalPosition.left;
win_ypos = wndpl.rcNormalPosition.top;
}
else
{
win_xpos = workarea_rect.left;
win_ypos = workarea_rect.top;
}
/* compute the size of the outside of the window */
win_width = width + GetSystemMetrics(SM_CXFRAME) * 2;
win_height = height + GetSystemMetrics(SM_CYFRAME) * 2
+ GetSystemMetrics(SM_CYCAPTION)
#ifdef FEAT_MENU
+ gui_mswin_get_menu_height(FALSE)
#endif
;
/* if the window is going off the screen, move it on to the screen */
if ((direction & RESIZE_HOR) && win_xpos + win_width > workarea_rect.right)
win_xpos = workarea_rect.right - win_width;
if ((direction & RESIZE_HOR) && win_xpos < workarea_rect.left)
win_xpos = workarea_rect.left;
if ((direction & RESIZE_VERT)
&& win_ypos + win_height > workarea_rect.bottom)
win_ypos = workarea_rect.bottom - win_height;
if ((direction & RESIZE_VERT) && win_ypos < workarea_rect.top)
win_ypos = workarea_rect.top;
/* set window position */
SetWindowPos(s_hwnd, NULL, win_xpos, win_ypos, win_width, win_height,
SWP_NOZORDER | SWP_NOACTIVATE);
#ifdef FEAT_MENU
/* Menu may wrap differently now */
gui_mswin_get_menu_height(!gui.starting);
#endif
}
void
gui_mch_set_scrollbar_thumb(
scrollbar_T *sb,
long val,
long size,
long max)
{
sb->scroll_shift = 0;
while (max > 32767)
{
max = (max + 1) >> 1;
val >>= 1;
size >>= 1;
++sb->scroll_shift;
}
if (sb->scroll_shift > 0)
++size;
SetScrollRange(sb->id, SB_CTL, 0, (int) max, FALSE);
SetScrollPos(sb->id, SB_CTL, (int) val, TRUE);
}
/*
* Set the current text font.
*/
void
gui_mch_set_font(GuiFont font)
{
gui.currFont = font;
SelectFont(s_hdc, gui.currFont);
}
/*
* Set the current text foreground color.
*/
void
gui_mch_set_fg_color(guicolor_T color)
{
gui.currFgColor = color;
SetTextColor(s_hdc, gui.currFgColor);
}
/*
* Set the current text background color.
*/
void
gui_mch_set_bg_color(guicolor_T color)
{
if (gui.currBgColor == color)
return;
gui.currBgColor = color;
SetBkColor(s_hdc, gui.currBgColor);
}
/*
* Set the current text special color.
*/
void
gui_mch_set_sp_color(guicolor_T color)
{
/* TODO */
}
void
gui_mch_draw_string(
int row,
int col,
char_u *text,
int len,
int flags)
{
#ifndef MSWIN16_FASTTEXT
static int *padding = NULL;
static int pad_size = 0;
int i;
#endif
HPEN hpen, old_pen;
int y;
#ifndef MSWIN16_FASTTEXT
/*
* Italic and bold text seems to have an extra row of pixels at the bottom
* (below where the bottom of the character should be). If we draw the
* characters with a solid background, the top row of pixels in the
* character below will be overwritten. We can fix this by filling in the
* background ourselves, to the correct character proportions, and then
* writing the character in transparent mode. Still have a problem when
* the character is "_", which gets written on to the character below.
* New fix: set gui.char_ascent to -1. This shifts all characters up one
* pixel in their slots, which fixes the problem with the bottom row of
* pixels. We still need this code because otherwise the top row of pixels
* becomes a problem. - webb.
*/
HBRUSH hbr;
RECT rc;
if (!(flags & DRAW_TRANSP))
{
/*
* Clear background first.
* Note: FillRect() excludes right and bottom of rectangle.
*/
rc.left = FILL_X(col);
rc.top = FILL_Y(row);
#ifdef FEAT_MBYTE
if (has_mbyte)
{
int cell_len = 0;
/* Compute the length in display cells. */
for (n = 0; n < len; n += MB_BYTE2LEN(text[n]))
cell_len += (*mb_ptr2cells)(text + n);
rc.right = FILL_X(col + cell_len);
}
else
#endif
rc.right = FILL_X(col + len);
rc.bottom = FILL_Y(row + 1);
hbr = CreateSolidBrush(gui.currBgColor);
FillRect(s_hdc, &rc, hbr);
DeleteBrush(hbr);
SetBkMode(s_hdc, TRANSPARENT);
/*
* When drawing block cursor, prevent inverted character spilling
* over character cell (can happen with bold/italic)
*/
if (flags & DRAW_CURSOR)
{
pcliprect = &rc;
foptions = ETO_CLIPPED;
}
}
#else
/*
* Alternative: write the characters in opaque mode, since we have blocked
* bold or italic fonts.
*/
/* The OPAQUE mode and backcolour have already been set */
#endif
/* The forecolor and font have already been set */
#ifndef MSWIN16_FASTTEXT
if (pad_size != Columns || padding == NULL || padding[0] != gui.char_width)
{
vim_free(padding);
pad_size = Columns;
padding = (int *)alloc(pad_size * sizeof(int));
if (padding != NULL)
for (i = 0; i < pad_size; i++)
padding[i] = gui.char_width;
}
#endif
/*
* We have to provide the padding argument because italic and bold versions
* of fixed-width fonts are often one pixel or so wider than their normal
* versions.
* No check for DRAW_BOLD, Windows will have done it already.
*/
#ifndef MSWIN16_FASTTEXT
ExtTextOut(s_hdc, TEXT_X(col), TEXT_Y(row), 0, NULL,
(char *)text, len, padding);
#else
TextOut(s_hdc, TEXT_X(col), TEXT_Y(row), (char *)text, len);
#endif
if (flags & DRAW_UNDERL)
{
hpen = CreatePen(PS_SOLID, 1, gui.currFgColor);
old_pen = SelectObject(s_hdc, hpen);
/* When p_linespace is 0, overwrite the bottom row of pixels.
* Otherwise put the line just below the character. */
y = FILL_Y(row + 1) - 1;
#ifndef MSWIN16_FASTTEXT
if (p_linespace > 1)
y -= p_linespace - 1;
#endif
MoveToEx(s_hdc, FILL_X(col), y, NULL);
/* Note: LineTo() excludes the last pixel in the line. */
LineTo(s_hdc, FILL_X(col + len), y);
DeleteObject(SelectObject(s_hdc, old_pen));
}
}
/*
* Output routines.
*/
/* Flush any output to the screen */
void
gui_mch_flush(void)
{
/* Is anything needed here? */
}
static void
clear_rect(RECT *rcp)
{
/* Use trick for fast rect clear */
gui_mch_set_bg_color(gui.back_pixel);
ExtTextOut(s_hdc, 0, 0, ETO_CLIPPED | ETO_OPAQUE, rcp, NULL, 0, NULL);
}
void
gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
{
*screen_w = GetSystemMetrics(SM_CXFULLSCREEN)
- GetSystemMetrics(SM_CXFRAME) * 2;
/* FIXME: dirty trick: Because the gui_get_base_height() doesn't include
* the menubar for MSwin, we subtract it from the screen height, so that
* the window size can be made to fit on the screen. */
*screen_h = GetSystemMetrics(SM_CYFULLSCREEN)
- GetSystemMetrics(SM_CYFRAME) * 2
#ifdef FEAT_MENU
- gui_mswin_get_menu_height(FALSE)
#endif
;
}
#if defined(FEAT_MENU) || defined(PROTO)
/*
* Add a sub menu to the menu bar.
*/
void
gui_mch_add_menu(
vimmenu_T *menu,
int pos)
{
vimmenu_T *parent = menu->parent;
menu->submenu_id = CreatePopupMenu();
menu->id = s_menu_id++;
if (menu_is_menubar(menu->name))
{
InsertMenu((parent == NULL) ? s_menuBar : parent->submenu_id,
(UINT)pos, MF_POPUP | MF_STRING | MF_BYPOSITION,
(UINT)menu->submenu_id, menu->name);
}
/* Fix window size if menu may have wrapped */
if (parent == NULL)
gui_mswin_get_menu_height(!gui.starting);
}
void
gui_mch_show_popupmenu(vimmenu_T *menu)
{
POINT mp;
(void)GetCursorPos((LPPOINT)&mp);
gui_mch_show_popupmenu_at(menu, (int)mp.x, (int)mp.y);
}
void
gui_make_popup(char_u *path_name, int mouse_pos)
{
vimmenu_T *menu = gui_find_menu(path_name);
if (menu != NULL)
{
/* Find the position of the current cursor */
DWORD temp_p;
POINT p;
temp_p = GetDCOrg(s_hdc);
p.x = LOWORD(temp_p);
p.y = HIWORD(temp_p);
if (mouse_pos)
{
int mx, my;
gui_mch_getmouse(&mx, &my);
p.x += mx;
p.y += my;
}
else if (curwin != NULL)
{
p.x += TEXT_X(W_WINCOL(curwin) + curwin->w_wcol + 1);
p.y += TEXT_Y(W_WINROW(curwin) + curwin->w_wrow + 1);
}
msg_scroll = FALSE;
gui_mch_show_popupmenu_at(menu, (int)p.x, (int)p.y);
}
}
/*
* Add a menu item to a menu
*/
void
gui_mch_add_menu_item(
vimmenu_T *menu,
int idx)
{
vimmenu_T *parent = menu->parent;
menu->id = s_menu_id++;
menu->submenu_id = NULL;
#ifdef FEAT_TOOLBAR
if (menu_is_toolbar(parent->name))
{
TBBUTTON newtb;
vim_memset(&newtb, 0, sizeof(newtb));
if (menu_is_separator(menu->name))
{
newtb.iBitmap = 0;
newtb.fsStyle = TBSTYLE_SEP;
}
else
{
if (menu->iconidx >= TOOLBAR_BITMAP_COUNT)
newtb.iBitmap = -1;
else
newtb.iBitmap = menu->iconidx;
newtb.fsStyle = TBSTYLE_BUTTON;
}
newtb.idCommand = menu->id;
newtb.fsState = TBSTATE_ENABLED;
SendMessage(s_toolbarhwnd, TB_INSERTBUTTON, (WPARAM)idx,
(LPARAM)&newtb);
menu->submenu_id = (HMENU)-1;
}
else
#endif
{
InsertMenu(parent->submenu_id, (UINT)idx,
(menu_is_separator(menu->name) ? MF_SEPARATOR : MF_STRING)
| MF_BYPOSITION,
(UINT)menu->id, menu->name);
}
}
/*
* Destroy the machine specific menu widget.
*/
void
gui_mch_destroy_menu(vimmenu_T *menu)
{
UINT i, j;
char pants[80]; /*<VN> hack*/
#ifdef FEAT_TOOLBAR
/*
* is this a toolbar button?
*/
if (menu->submenu_id == (HMENU)-1)
{
int iButton;
iButton = SendMessage(s_toolbarhwnd, TB_COMMANDTOINDEX, (WPARAM)menu->id, 0);
SendMessage(s_toolbarhwnd, TB_DELETEBUTTON, (WPARAM)iButton, 0);
}
else
#endif
{
/*
* negri: horrible API bug when running 16-bit programs under Win9x or
* NT means that we can't use MF_BYCOMMAND for menu items which have
* submenus, including the top-level headings. We have to find the menu
* item and use MF_BYPOSITION instead. :-p
*/
if (menu->parent != NULL
&& menu_is_popup(menu->parent->dname)
&& menu->parent->submenu_id != NULL)
RemoveMenu(menu->parent->submenu_id, menu->id, MF_BYCOMMAND);
else if (menu->submenu_id == NULL)
RemoveMenu(s_menuBar, menu->id, MF_BYCOMMAND);
else if (menu->parent != NULL)
{
i = GetMenuItemCount(menu->parent->submenu_id);
for (j = 0; j < i; ++j)
{
GetMenuString(menu->parent->submenu_id, j,
pants, 80, MF_BYPOSITION);
if (strcmp(pants, menu->name) == 0)
{
RemoveMenu(menu->parent->submenu_id, j, MF_BYPOSITION);
break;
}
}
}
else
{
i = GetMenuItemCount(s_menuBar);
for (j = 0; j < i; ++j)
{
GetMenuString(s_menuBar, j, pants, 80, MF_BYPOSITION);
if (strcmp(pants, menu->name) == 0)
{
RemoveMenu(s_menuBar, j, MF_BYPOSITION);
break;
}
}
}
if (menu->submenu_id != NULL)
DestroyMenu(menu->submenu_id);
}
DrawMenuBar(s_hwnd);
}
/*
* Make a menu either grey or not grey.
*/
void
gui_mch_menu_grey(
vimmenu_T *menu,
int grey)
{
#ifdef FEAT_TOOLBAR
/*
* is this a toolbar button?
*/
if (menu->submenu_id == (HMENU)-1)
{
SendMessage(s_toolbarhwnd, TB_ENABLEBUTTON,
(WPARAM)menu->id, (LPARAM) MAKELONG((grey ? FALSE : TRUE), 0) );
}
else
#endif
if (grey)
EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_GRAYED);
else
EnableMenuItem(s_menuBar, menu->id, MF_BYCOMMAND | MF_ENABLED);
}
#endif /*FEAT_MENU*/
/* define some macros used to make the dialogue creation more readable */
#define add_string(s) strcpy((LPSTR)p, s); (LPSTR)p += (strlen((LPSTR)p) + 1)
#define add_word(x) *p++ = (x)
#define add_byte(x) *((LPSTR)p)++ = (x)
#define add_long(x) *((LPDWORD)p)++ = (x)
#if defined(FEAT_GUI_DIALOG) || defined(PROTO)
/*
* stuff for dialogs
*/
/*
* The callback routine used by all the dialogs. Very simple. First,
* acknowledges the INITDIALOG message so that Windows knows to do standard
* dialog stuff (Return = default, Esc = cancel....) Second, if a button is
* pressed, return that button's ID - IDCANCEL (2), which is the button's
* number.
*/
static BOOL CALLBACK
dialog_callback(
HWND hwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
if (message == WM_INITDIALOG)
{
CenterWindow(hwnd, GetWindow(hwnd, GW_OWNER));
/* Set focus to the dialog. Set the default button, if specified. */
(void)SetFocus(hwnd);
if (dialog_default_button > IDCANCEL)
(void)SetFocus(GetDlgItem(hwnd, dialog_default_button));
// if (dialog_default_button > 0)
// (void)SetFocus(GetDlgItem(hwnd, dialog_default_button + IDCANCEL));
return FALSE;
}
if (message == WM_COMMAND)
{
int button = LOWORD(wParam);
/* Don't end the dialog if something was selected that was
* not a button.
*/
if (button >= DLG_NONBUTTON_CONTROL)
return TRUE;
/* If the edit box exists, copy the string. */
if (s_textfield != NULL)
GetDlgItemText(hwnd, DLG_NONBUTTON_CONTROL + 2,
s_textfield, IOSIZE);
/*
* Need to check for IDOK because if the user just hits Return to
* accept the default value, some reason this is what we get.
*/
if (button == IDOK)
EndDialog(hwnd, dialog_default_button);
else
EndDialog(hwnd, button - IDCANCEL);
return TRUE;
}
if ((message == WM_SYSCOMMAND) && (wParam == SC_CLOSE))
{
EndDialog(hwnd, 0);
return TRUE;
}
return FALSE;
}
/*
* Create a dialog dynamically from the parameter strings.
* type = type of dialog (question, alert, etc.)
* title = dialog title. may be NULL for default title.
* message = text to display. Dialog sizes to accommodate it.
* buttons = '\n' separated list of button captions, default first.
* dfltbutton = number of default button.
*
* This routine returns 1 if the first button is pressed,
* 2 for the second, etc.
*
* 0 indicates Esc was pressed.
* -1 for unexpected error
*
* If stubbing out this fn, return 1.
*/
static const char_u dlg_icons[] = /* must match names in resource file */
{
IDR_VIM,
IDR_VIM_ERROR,
IDR_VIM_ALERT,
IDR_VIM_INFO,
IDR_VIM_QUESTION
};
int
gui_mch_dialog(
int type,
char_u *title,
char_u *message,
char_u *buttons,
int dfltbutton,
char_u *textfield)
{
FARPROC dp;
LPWORD p, pnumitems;
int numButtons;
int *buttonWidths, *buttonPositions;
int buttonYpos;
int nchar, i;
DWORD lStyle;
int dlgwidth = 0;
int dlgheight;
int editboxheight;
int horizWidth;
int msgheight;
char_u *pstart;
char_u *pend;
char_u *tbuffer;
RECT rect;
HWND hwnd;
HDC hdc;
HFONT oldFont;
TEXTMETRIC fontInfo;
int fontHeight;
int textWidth, minButtonWidth, messageWidth;
int maxDialogWidth;
int vertical;
int dlgPaddingX;
int dlgPaddingY;
HGLOBAL hglbDlgTemp;
#ifndef NO_CONSOLE
/* Don't output anything in silent mode ("ex -s") */
if (silent_mode)
return dfltbutton; /* return default option */
#endif
/* If there is no window yet, open it. */
if (s_hwnd == NULL && gui_mch_init() == FAIL)
return dfltbutton;
if ((type < 0) || (type > VIM_LAST_TYPE))
type = 0;
/* allocate some memory for dialog template */
/* TODO should compute this really*/
hglbDlgTemp = GlobalAlloc(GHND, DLG_ALLOC_SIZE);
if (hglbDlgTemp == NULL)
return -1;
p = (LPWORD) GlobalLock(hglbDlgTemp);
if (p == NULL)
return -1;
/*
* make a copy of 'buttons' to fiddle with it. complier grizzles because
* vim_strsave() doesn't take a const arg (why not?), so cast away the
* const.
*/
tbuffer = vim_strsave(buttons);
if (tbuffer == NULL)
return -1;
--dfltbutton; /* Change from one-based to zero-based */
/* Count buttons */
numButtons = 1;
for (i = 0; tbuffer[i] != '\0'; i++)
{
if (tbuffer[i] == DLG_BUTTON_SEP)
numButtons++;
}
if (dfltbutton >= numButtons)
dfltbutton = 0;
/* Allocate array to hold the width of each button */
buttonWidths = (int *) lalloc(numButtons * sizeof(int), TRUE);
if (buttonWidths == NULL)
return -1;
/* Allocate array to hold the X position of each button */
buttonPositions = (int *) lalloc(numButtons * sizeof(int), TRUE);
if (buttonPositions == NULL)
return -1;
/*
* Calculate how big the dialog must be.
*/
hwnd = GetDesktopWindow();
hdc = GetWindowDC(hwnd);
oldFont = SelectFont(hdc, GetStockObject(SYSTEM_FONT));
dlgPaddingX = DLG_OLD_STYLE_PADDING_X;
dlgPaddingY = DLG_OLD_STYLE_PADDING_Y;
GetTextMetrics(hdc, &fontInfo);
fontHeight = fontInfo.tmHeight;
/* Minimum width for horizontal button */
minButtonWidth = GetTextWidth(hdc, "Cancel", 6);
/* Maximum width of a dialog, if possible */
GetWindowRect(s_hwnd, &rect);
maxDialogWidth = rect.right - rect.left
- GetSystemMetrics(SM_CXFRAME) * 2;
if (maxDialogWidth < DLG_MIN_MAX_WIDTH)
maxDialogWidth = DLG_MIN_MAX_WIDTH;
/* Set dlgwidth to width of message */
pstart = message;
messageWidth = 0;
msgheight = 0;
do
{
pend = vim_strchr(pstart, DLG_BUTTON_SEP);
if (pend == NULL)
pend = pstart + STRLEN(pstart); /* Last line of message. */
msgheight += fontHeight;
textWidth = GetTextWidth(hdc, pstart, pend - pstart);
if (textWidth > messageWidth)
messageWidth = textWidth;
pstart = pend + 1;
} while (*pend != NUL);
dlgwidth = messageWidth;
/* Add width of icon to dlgwidth, and some space */
dlgwidth += DLG_ICON_WIDTH + 3 * dlgPaddingX;
if (msgheight < DLG_ICON_HEIGHT)
msgheight = DLG_ICON_HEIGHT;
/*
* Check button names. A long one will make the dialog wider.
*/
vertical = (vim_strchr(p_go, GO_VERTICAL) != NULL);
if (!vertical)
{
// Place buttons horizontally if they fit.
horizWidth = dlgPaddingX;
pstart = tbuffer;
i = 0;
do
{
pend = vim_strchr(pstart, DLG_BUTTON_SEP);
if (pend == NULL)
pend = pstart + STRLEN(pstart); // Last button name.
textWidth = GetTextWidth(hdc, pstart, pend - pstart);
if (textWidth < minButtonWidth)
textWidth = minButtonWidth;
textWidth += dlgPaddingX; /* Padding within button */
buttonWidths[i] = textWidth;
buttonPositions[i++] = horizWidth;
horizWidth += textWidth + dlgPaddingX; /* Pad between buttons */
pstart = pend + 1;
} while (*pend != NUL);
if (horizWidth > maxDialogWidth)
vertical = TRUE; // Too wide to fit on the screen.
else if (horizWidth > dlgwidth)
dlgwidth = horizWidth;
}
if (vertical)
{
// Stack buttons vertically.
pstart = tbuffer;
do
{
pend = vim_strchr(pstart, DLG_BUTTON_SEP);
if (pend == NULL)
pend = pstart + STRLEN(pstart); // Last button name.
textWidth = GetTextWidth(hdc, pstart, pend - pstart);
textWidth += dlgPaddingX; /* Padding within button */
textWidth += DLG_VERT_PADDING_X * 2; /* Padding around button */
if (textWidth > dlgwidth)
dlgwidth = textWidth;
pstart = pend + 1;
} while (*pend != NUL);
}
if (dlgwidth < DLG_MIN_WIDTH)
dlgwidth = DLG_MIN_WIDTH; /* Don't allow a really thin dialog!*/
/* start to fill in the dlgtemplate information. addressing by WORDs */
lStyle = DS_MODALFRAME | WS_CAPTION | WS_VISIBLE ;
add_long(lStyle);
pnumitems = p; /*save where the number of items must be stored*/
add_byte(0); // NumberOfItems(will change later)
add_word(10); // x
add_word(10); // y
add_word(PixelToDialogX(dlgwidth));
// Dialog height.
if (vertical)
dlgheight = msgheight + 2 * dlgPaddingY +
DLG_VERT_PADDING_Y + 2 * fontHeight * numButtons;
else
dlgheight = msgheight + 3 * dlgPaddingY + 2 * fontHeight;
// Dialog needs to be taller if contains an edit box.
editboxheight = fontHeight + dlgPaddingY + 4 * DLG_VERT_PADDING_Y;
if (textfield != NULL)
dlgheight += editboxheight;
add_word(PixelToDialogY(dlgheight));
add_byte(0); //menu
add_byte(0); //class
/* copy the title of the dialog */
add_string(title ? title : ("Vim"VIM_VERSION_MEDIUM));
buttonYpos = msgheight + 2 * dlgPaddingY;
if (textfield != NULL)
buttonYpos += editboxheight;
pstart = tbuffer; //dflt_text
horizWidth = (dlgwidth - horizWidth) / 2; /* Now it's X offset */
for (i = 0; i < numButtons; i++)
{
/* get end of this button. */
for ( pend = pstart;
*pend && (*pend != DLG_BUTTON_SEP);
pend++)
;
if (*pend)
*pend = '\0';
/*
* NOTE:
* setting the BS_DEFPUSHBUTTON style doesn't work because Windows sets
* the focus to the first tab-able button and in so doing makes that
* the default!! Grrr. Workaround: Make the default button the only
* one with WS_TABSTOP style. Means user can't tab between buttons, but
* he/she can use arrow keys.
*
* NOTE (Thore): Setting BS_DEFPUSHBUTTON works fine when it's the
* first one, so I changed the correct button to be this style. This
* is necessary because when an edit box is added, we need a button to
* be default. The edit box will be the default control, and when the
* user presses enter from the edit box we want the default button to
* be pressed.
*/
if (vertical)
{
p = add_dialog_element(p,
((i == dfltbutton || dfltbutton < 0) && textfield != NULL
? BS_DEFPUSHBUTTON : BS_PUSHBUTTON) | WS_TABSTOP,
PixelToDialogX(DLG_VERT_PADDING_X),
PixelToDialogY(buttonYpos /* TBK */
+ 2 * fontHeight * i),
PixelToDialogX(dlgwidth - 2 * DLG_VERT_PADDING_X),
(WORD)(PixelToDialogY(2 * fontHeight) - 1),
(WORD)(IDCANCEL + 1 + i), (BYTE)0x80, pstart);
}
else
{
p = add_dialog_element(p,
((i == dfltbutton || dfltbutton < 0) && textfield != NULL
? BS_DEFPUSHBUTTON : BS_PUSHBUTTON) | WS_TABSTOP,
PixelToDialogX(horizWidth + buttonPositions[i]),
PixelToDialogY(buttonYpos), /* TBK */
PixelToDialogX(buttonWidths[i]),
(WORD)(PixelToDialogY(2 * fontHeight) - 1),
(WORD)(IDCANCEL + 1 + i), (BYTE)0x80, pstart);
}
pstart = pend + 1; /*next button*/
}
*pnumitems += numButtons;
/* Vim icon */
p = add_dialog_element(p, SS_ICON,
PixelToDialogX(dlgPaddingX),
PixelToDialogY(dlgPaddingY),
PixelToDialogX(DLG_ICON_WIDTH),
PixelToDialogY(DLG_ICON_HEIGHT),
DLG_NONBUTTON_CONTROL + 0, (BYTE)0x82,
&dlg_icons[type]);
/* Dialog message */
p = add_dialog_element(p, SS_LEFT,
PixelToDialogX(2 * dlgPaddingX + DLG_ICON_WIDTH),
PixelToDialogY(dlgPaddingY),
(WORD)(PixelToDialogX(messageWidth) + 1),
PixelToDialogY(msgheight),
DLG_NONBUTTON_CONTROL + 1, (BYTE)0x82, message);
/* Edit box */
if (textfield != NULL)
{
p = add_dialog_element(p, ES_LEFT | ES_AUTOHSCROLL | WS_TABSTOP | WS_BORDER,
PixelToDialogX(2 * dlgPaddingX),
PixelToDialogY(2 * dlgPaddingY + msgheight),
PixelToDialogX(dlgwidth - 4 * dlgPaddingX),
PixelToDialogY(fontHeight + dlgPaddingY),
DLG_NONBUTTON_CONTROL + 2, (BYTE)0x81, textfield);
*pnumitems += 1;
}
*pnumitems += 2;
SelectFont(hdc, oldFont);
ReleaseDC(hwnd, hdc);
dp = MakeProcInstance((FARPROC)dialog_callback, s_hinst);
/* Let the dialog_callback() function know which button to make default
* If we have an edit box, make that the default. We also need to tell
* dialog_callback() if this dialog contains an edit box or not. We do
* this by setting s_textfield if it does.
*/
if (textfield != NULL)
{
dialog_default_button = DLG_NONBUTTON_CONTROL + 2;
s_textfield = textfield;
}
else
{
dialog_default_button = IDCANCEL + 1 + dfltbutton;
s_textfield = NULL;
}
/*show the dialog box modally and get a return value*/
nchar = DialogBoxIndirect(
s_hinst,
(HGLOBAL) hglbDlgTemp,
s_hwnd,
(DLGPROC)dp);
FreeProcInstance( dp );
GlobalUnlock(hglbDlgTemp);
GlobalFree(hglbDlgTemp);
vim_free(tbuffer);
vim_free(buttonWidths);
vim_free(buttonPositions);
return nchar;
}
/*
* Put a simple element (basic class) onto a dialog template in memory.
* return a pointer to where the next item should be added.
*
* parameters:
* lStyle = additional style flags
* x,y = x & y positions IN DIALOG UNITS
* w,h = width and height IN DIALOG UNITS
* Id = ID used in messages
* clss = class ID, e.g 0x80 for a button, 0x82 for a static
* caption = usually text or resource name
*
* TODO: use the length information noted here to enable the dialog creation
* routines to work out more exactly how much memory they need to alloc.
*/
static LPWORD
add_dialog_element(
LPWORD p,
DWORD lStyle,
WORD x,
WORD y,
WORD w,
WORD h,
WORD Id,
BYTE clss,
const char *caption)
{
lStyle = lStyle | WS_VISIBLE | WS_CHILD;
add_word(x);
add_word(y);
add_word(w);
add_word(h);
add_word(Id);
add_long(lStyle);
add_byte(clss);
if (((lStyle & SS_ICON) != 0) && (clss == 0x82))
{
/* Use resource ID */
add_byte(0xff);
add_byte(*caption);
}
else
add_string(caption);
add_byte(0); //# of extra bytes following
return p;
}
#undef add_byte
#undef add_string
#undef add_long
#undef add_word
#endif /* FEAT_GUI_DIALOG */
static void
get_dialog_font_metrics(void)
{
DWORD dlgFontSize;
dlgFontSize = GetDialogBaseUnits(); /* fall back to big old system*/
s_dlgfntwidth = LOWORD(dlgFontSize);
s_dlgfntheight = HIWORD(dlgFontSize);
}
#if defined(FEAT_TOOLBAR) || defined(PROTO)
#include "gui_w3~1.h"
/*
* Create the toolbar, initially unpopulated.
* (just like the menu, there are no defaults, it's all
* set up through menu.vim)
*/
static void
initialise_toolbar(void)
{
s_toolbarhwnd = CreateToolbar(
s_hwnd,
WS_CHILD | WS_VISIBLE,
CMD_TB_BASE, /*<vn>*/
31, //number of images in initial bitmap
s_hinst,
IDR_TOOLBAR1, // id of initial bitmap
NULL,
0 // initial number of buttons
);
gui_mch_show_toolbar(vim_strchr(p_go, GO_TOOLBAR) != NULL);
}
#endif
#if defined(FEAT_OLE) || defined(FEAT_EVAL) || defined(PROTO)
/*
* Make the GUI window come to the foreground.
*/
void
gui_mch_set_foreground(void)
{
if (IsIconic(s_hwnd))
SendMessage(s_hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
SetActiveWindow(s_hwnd);
}
#endif
Jump to Line
Something went wrong with that request. Please try again.