diff --git a/ANNOUNCE b/ANNOUNCE index 2b89c81973..0ede2e6db8 100644 --- a/ANNOUNCE +++ b/ANNOUNCE @@ -1,13 +1,13 @@ -This is release 970509 of Wine, the MS Windows emulator. This is still a +This is release 970525 of Wine, the MS Windows emulator. This is still a developer's only release. There are many bugs and many unimplemented API features. Most applications still do not work correctly. Patches should be submitted to "julliard@lrc.epfl.ch". Please don't forget to include a ChangeLog entry. -WHAT'S NEW with Wine-970509: (see ChangeLog for details) - - Better local heap implementation. - - Improvements to -managed mode. +WHAT'S NEW with Wine-970525: (see ChangeLog for details) + - Many fixes to multimedia code. + - Better menus. - Lots of bug fixes. See the README file in the distribution for installation instructions. @@ -16,11 +16,10 @@ Because of lags created by using mirror, this message may reach you before the release is available at the ftp sites. The sources will be available from the following locations: - ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/development/Wine-970509.tar.gz - ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/development/Wine-970509.tar.gz - ftp://ftp.infomagic.com/pub/mirrors/linux/wine/development/Wine-970509.tar.gz - ftp://aris.com/pub/linux/ALPHA/Wine/development/Wine-970509.tar.gz - ftp://ftp.progsoc.uts.edu.au/pub/Wine/development/Wine-970509.tar.gz + ftp://sunsite.unc.edu/pub/Linux/ALPHA/wine/development/Wine-970525.tar.gz + ftp://tsx-11.mit.edu/pub/linux/ALPHA/Wine/development/Wine-970525.tar.gz + ftp://ftp.infomagic.com/pub/mirrors/linux/wine/development/Wine-970525.tar.gz + ftp://ftp.progsoc.uts.edu.au/pub/Wine/development/Wine-970525.tar.gz It should also be available from any site that mirrors tsx-11 or sunsite. diff --git a/BUGS b/BUGS index 79ef93503a..1252d8a865 100644 --- a/BUGS +++ b/BUGS @@ -40,8 +40,6 @@ Miscellaneous: * 32-bit Freecell segfaults when started from the Progman (looks like a problem with cards.dll). - * Word 6.0 often segfaults when system menu is double-clicked. - * Edit controls are prone to show blank space when, in fact, there is a text there. diff --git a/ChangeLog b/ChangeLog index 45d2aef41f..ebe3a6efe7 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,57 @@ +---------------------------------------------------------------------- +Tue May 20 19:20:23 1997 Pablo Saratxaga + + * [resources/sysres_Es.rc] + Updated CHOOSE_FONT, CHOOSE_COLOR, EDITMENU for Spanish. + +Mon May 19 22:06:04 1997 Michiel van Loon + + * [multimedia/mcistring.c] + Corrected bug for device!element command. + + * [multimedia/mmaux.c] + Replaced printf and fprintf calls by dprintf_mmaux. + + * [multimedia/audio.c] + Corrected debugmessage in wodGetVolume. + Include code for MCI_CUE command. + + * [multimedia/mmsystem.c] + Added the MCIERR_SEQ error messages. + + * [if1632/mmsystem.spec] [multimedia/audio.c] [multimedia/mmsystem.c] + Changed call structure of waveInOpen and waveOutOpen. + + * [multimedia/mmsystem.c] [multimedia/audio.c] [multimedia/midi.c] + [multimedia/mmaux.c] [multimedia/mcicda.c] [multimedia/mcianim.c] + [multimedia/mcistring.c] [include/mmsystem.h] + Changed the deviceID scheme. + + * [include/queue.h] [include/win16drv.h] [msdos/dpmi.c] + [windows/user.c] [windows/driver.c] [graphic/wing.c] + [graphics/x11drv/bitmap.c] [misc/wsprintf.c] [misc/crtdll.c] + Removed compiler warnings. + +Mon May 19 01:32:24 1997 Alex Korobka + + * [controls/menu.c] [windows/win.c] [windows/graphics.c] + Popup menu shade, new system menu implementation, + ModifyMenu() fixes, better check mark painting. + + * [windows/mdi.c] + MDI client fix for Win32. + +Sat May 17 12:02:11 1997 Albrecht Kleine + + * [objects/metafile.c] + Added handling of META_DIBBITBLT, META_SETTEXTJUSTIFICATION + plus bugfix in META_EXTTEXTOUT (start_of_text etc.) + +Thu May 15 22:52:00 1997 Jimen Ching + + * [loader/ne_image.c] + Make sure dgroup is valid by checking pModule->flags consistently. + ---------------------------------------------------------------------- Tue May 6 19:12:20 1997 Alexandre Julliard diff --git a/Makefile.in b/Makefile.in index afb9eddf8f..039c74142c 100644 --- a/Makefile.in +++ b/Makefile.in @@ -122,7 +122,7 @@ install_libwine.a: dummy $(INSTALL_DATA) libwine.a $(libdir) libwine.so.1.0: $(COMMONSUBDIRS) $(LIBSUBDIRS) dummy - $(CC) -shared -Wl,-soname,libwine.so.1 -o$@ $(COMMONOBJS) $(LIBOBJS) $(LDOPTIONS) $(X_LIBS) $(XPM_LIB) $(XLIB) $(LDLIBS) + $(CC) -shared -Wl,-soname,libwine.so -o$@ $(COMMONOBJS) $(LIBOBJS) $(LDOPTIONS) $(X_LIBS) $(XPM_LIB) $(XLIB) $(LDLIBS) install_libwine.so.1.0: dummy $(INSTALL_DATA) libwine.so.1.0 $(libdir) diff --git a/controls/button.c b/controls/button.c index 72e289348c..07cc5e1a17 100644 --- a/controls/button.c +++ b/controls/button.c @@ -413,7 +413,7 @@ static void CB_Paint( WND *wndPtr, HDC32 hDC, WORD action ) else if (infoPtr->state & BUTTON_3STATE) y += 2 * checkBoxHeight; GRAPH_DrawBitmap( hDC, hbitmapCheckBoxes, rbox.left, rbox.top + delta, - x, y, checkBoxWidth, checkBoxHeight ); + x, y, checkBoxWidth, checkBoxHeight, FALSE ); if( textlen && action != ODA_SELECT ) { if (wndPtr->dwStyle & WS_DISABLED) diff --git a/controls/desktop.c b/controls/desktop.c index 2466ea7b67..6708fb7a2d 100644 --- a/controls/desktop.c +++ b/controls/desktop.c @@ -108,7 +108,7 @@ static LRESULT DESKTOP_DoEraseBkgnd( HWND32 hwnd, HDC32 hdc, GRAPH_DrawBitmap( hdc, infoPtr->hbitmapWallPaper, x, y, 0, 0, infoPtr->bitmapSize.cx, - infoPtr->bitmapSize.cy ); + infoPtr->bitmapSize.cy, FALSE ); } else { @@ -116,8 +116,9 @@ static LRESULT DESKTOP_DoEraseBkgnd( HWND32 hwnd, HDC32 hdc, y = (rect.top + rect.bottom - infoPtr->bitmapSize.cy) / 2; if (x < 0) x = 0; if (y < 0) y = 0; - GRAPH_DrawBitmap( hdc, infoPtr->hbitmapWallPaper, x, y, 0, 0, - infoPtr->bitmapSize.cx, infoPtr->bitmapSize.cy ); + GRAPH_DrawBitmap( hdc, infoPtr->hbitmapWallPaper, + x, y, 0, 0, infoPtr->bitmapSize.cx, + infoPtr->bitmapSize.cy, FALSE ); } } diff --git a/controls/listbox.c b/controls/listbox.c index 8a7f1d9171..48b181f393 100644 --- a/controls/listbox.c +++ b/controls/listbox.c @@ -724,6 +724,7 @@ static INT32 LISTBOX_FindString( WND *wnd, LB_DESCR *descr, INT32 start, item = descr->items + start + 1; if (HAS_STRINGS(descr)) { + if (!str) return LB_ERR; if (exact) { for (i = start + 1; i < descr->nb_items; i++, item++) @@ -1915,6 +1916,11 @@ static LRESULT LISTBOX_HandleKeyDown( WND *wnd, LB_DESCR *descr, WPARAM32 wParam !descr->items[descr->focus_item].selected, (descr->style & LBS_NOTIFY) != 0 ); } + else if (descr->selected_item == -1) + { + LISTBOX_SetSelection( wnd, descr, descr->focus_item, TRUE, + (descr->style & LBS_NOTIFY) != 0 ); + } break; } if (caret >= 0) diff --git a/controls/menu.c b/controls/menu.c index f266e8f8ad..4c7c82f7b5 100644 --- a/controls/menu.c +++ b/controls/menu.c @@ -11,11 +11,14 @@ * This is probably not the meaning this style has in MS-Windows. */ +#include #include #include #include #include #include "windows.h" +#include "bitmap.h" +#include "gdi.h" #include "syscolor.h" #include "sysmetrics.h" #include "task.h" @@ -32,6 +35,17 @@ #include "stddebug.h" #include "debug.h" +/* internal popup menu window messages */ + +#define MM_SETMENUHANDLE (WM_USER + 0) +#define MM_GETMENUHANDLE (WM_USER + 1) + +typedef struct +{ + HBITMAP32 hCheckBit; + HBITMAP32 hUnCheckBit; +} CBITMAPS, *PCBITMAPS; + /* Menu item structure */ typedef struct { @@ -39,8 +53,7 @@ typedef struct UINT32 item_id; /* Item or popup id */ RECT32 rect; /* Item area (relative to menu window) */ UINT32 xTab; /* X position of text after Tab */ - HBITMAP32 hCheckBit; /* Bitmap for checked item */ - HBITMAP32 hUnCheckBit; /* Bitmap for unchecked item */ + PCBITMAPS pCB; /* checkmark bitmaps */ LPSTR text; /* Item text or bitmap handle */ } MENUITEM; @@ -58,17 +71,34 @@ typedef struct UINT32 FocusedItem; /* Currently focused item */ } POPUPMENU, *LPPOPUPMENU; +/* internal flags for menu tracking */ + +#define TF_ENDMENU 0x0001 +#define TF_SUSPENDPOPUP 0x0002 +#define TF_SKIPREMOVE 0x0004 + +typedef struct +{ + UINT32 trackFlags; + HMENU32 hCurrentMenu; /* current submenu (can be equal to hTopMenu)*/ + HMENU32 hTopMenu; /* initial menu */ + HWND32 hOwnerWnd; /* where notifications are sent */ + POINT32 pt; +} MTRACKER; + #define MENU_MAGIC 0x554d /* 'MU' */ #define ITEM_PREV -1 #define ITEM_NEXT 1 - /* Dimension of the menu bitmaps */ -static WORD check_bitmap_width = 0, check_bitmap_height = 0; -static WORD arrow_bitmap_width = 0, arrow_bitmap_height = 0; + /* Internal MENU_TrackMenu() flags */ +#define TPM_INTERNAL 0xF0000000 +#define TPM_ENTERIDLEEX 0x80000000 /* set owner window for WM_ENTERIDLE */ +#define TPM_BUTTONDOWN 0x40000000 /* menu was clicked before tracking */ - /* Flag set by EndMenu() to force an exit from menu tracking */ -static BOOL32 fEndMenuCalled = FALSE; + /* popup menu shade thickness */ +#define POPUP_XSHADE 4 +#define POPUP_YSHADE 4 /* Space between 2 menu bar items */ #define MENU_BAR_ITEMS_SPACE 16 @@ -79,46 +109,93 @@ static BOOL32 fEndMenuCalled = FALSE; /* Height of a separator item */ #define SEPARATOR_HEIGHT 5 - /* Values for menu->FocusedItem */ - /* (other values give the position of the focused item) */ + /* (other menu->FocusedItem values give the position of the focused item) */ #define NO_SELECTED_ITEM 0xffff -#define SYSMENU_SELECTED 0xfffe /* Only valid on menu-bars */ #define IS_STRING_ITEM(flags) \ (!((flags) & (MF_BITMAP | MF_OWNERDRAW | MF_SEPARATOR))) +#define IS_SYSTEM_MENU(menu) \ + (!((menu)->wFlags & MF_POPUP) && (menu)->wFlags & MF_SYSMENU) +#define IS_SYSTEM_POPUP(menu) \ + ((menu)->wFlags & MF_POPUP && (menu)->wFlags & MF_SYSMENU) + + /* Dimension of the menu bitmaps */ +static WORD check_bitmap_width = 0, check_bitmap_height = 0; +static WORD arrow_bitmap_width = 0, arrow_bitmap_height = 0; static HBITMAP32 hStdCheck = 0; static HBITMAP32 hStdMnArrow = 0; -static HMENU32 MENU_DefSysMenu = 0; /* Default system menu */ +static HBRUSH32 hShadeBrush = 0; +static HMENU32 MENU_DefSysPopup = 0; /* Default system menu popup */ +/* Use global popup window because there's no way 2 menus can + * be tracked at the same time. */ -/* we _can_ use global popup window because there's no way 2 menues can - * be tracked at the same time. - */ - -static WND* pTopPWnd = 0; +static WND* pTopPopupWnd = 0; static UINT32 uSubPWndLevel = 0; + /* Flag set by EndMenu() to force an exit from menu tracking */ +static BOOL32 fEndMenu = FALSE; + + +/*********************************************************************** + * MENU_CopySysPopup + * + * Return the default system menu. + */ +static HMENU32 MENU_CopySysPopup(void) +{ + HMENU32 hMenu = LoadMenuIndirect32A(SYSRES_GetResPtr(SYSRES_MENU_SYSMENU)); + + if( hMenu ) + { + POPUPMENU* menu = (POPUPMENU *) USER_HEAP_LIN_ADDR(hMenu); + menu->wFlags |= MF_SYSMENU | MF_POPUP; + return hMenu; + } + else fprintf( stderr, "Unable to load default system menu\n" ); + return FALSE; +} + /********************************************************************** - * MENU_CopySysMenu + * MENU_GetSysMenu * - * Load a copy of the system menu. + * Create a copy of the system menu. System menu in Windows is + * a special menu-bar with the single entry - system menu popup. + * This popup is presented to the outside world as a "system menu". + * However, the real system menu handle is sometimes seen in the + * WM_MENUSELECT paramemters (and Word 6 likes it this way). */ -static HMENU32 MENU_CopySysMenu(void) +HMENU32 MENU_GetSysMenu( HWND32 hWnd, HMENU32 hPopupMenu ) { HMENU32 hMenu; - POPUPMENU *menu; - if (!(hMenu = LoadMenuIndirect32A( SYSRES_GetResPtr(SYSRES_MENU_SYSMENU)))) + if ((hMenu = CreateMenu32())) { - dprintf_menu(stddeb,"No SYSMENU\n"); - return 0; + POPUPMENU *menu = (POPUPMENU*) USER_HEAP_LIN_ADDR(hMenu); + menu->wFlags = MF_SYSMENU; + menu->hWnd = hWnd; + + if (hPopupMenu == (HMENU32)(-1)) + hPopupMenu = MENU_CopySysPopup(); + else if( !hPopupMenu ) hPopupMenu = MENU_DefSysPopup; + + if (hPopupMenu) + { + InsertMenu32A( hMenu, -1, MF_SYSMENU | MF_POPUP | MF_BYPOSITION, hPopupMenu, NULL ); + + menu->items[0].item_flags = MF_SYSMENU | MF_POPUP; + menu = (POPUPMENU*) USER_HEAP_LIN_ADDR(hPopupMenu); + menu->wFlags |= MF_SYSMENU; + + dprintf_menu(stddeb,"GetSysMenu hMenu=%04x (%04x)\n", hMenu, hPopupMenu ); + return hMenu; + } + DestroyMenu32( hMenu ); } - menu = (POPUPMENU*) USER_HEAP_LIN_ADDR(hMenu); - menu->wFlags |= MF_SYSMENU | MF_POPUP; - dprintf_menu(stddeb,"CopySysMenu hMenu=%04x !\n", hMenu); - return hMenu; + fprintf(stderr, "failed to load system menu!\n"); + return 0; } @@ -129,79 +206,40 @@ static HMENU32 MENU_CopySysMenu(void) */ BOOL32 MENU_Init() { - BITMAP32 bm; + /* Load menu bitmaps */ - /* Load bitmaps */ - - if (!(hStdCheck = LoadBitmap32A( 0, (LPSTR)MAKEINTRESOURCE(OBM_CHECK) ))) - return FALSE; - GetObject32A( hStdCheck, sizeof(bm), &bm ); - check_bitmap_width = bm.bmWidth; - check_bitmap_height = bm.bmHeight; - if (!(hStdMnArrow = LoadBitmap32A(0,(LPSTR)MAKEINTRESOURCE(OBM_MNARROW)))) - return FALSE; - GetObject32A( hStdMnArrow, sizeof(bm), &bm ); - arrow_bitmap_width = bm.bmWidth; - arrow_bitmap_height = bm.bmHeight; - - if (!(MENU_DefSysMenu = MENU_CopySysMenu())) + if ((hStdCheck = LoadBitmap32A( 0, (LPSTR)MAKEINTRESOURCE(OBM_CHECK) ))) { - fprintf( stderr, "Unable to create default system menu\n" ); - return FALSE; + BITMAP32 bm; + + GetObject32A( hStdCheck, sizeof(bm), &bm ); + check_bitmap_width = bm.bmWidth; + check_bitmap_height = bm.bmHeight; + + if ((hStdMnArrow = LoadBitmap32A(0,(LPSTR)MAKEINTRESOURCE(OBM_MNARROW)))) + { + HBITMAP32 hBitmap; + static unsigned char shade_bits[16] = { 0x55, 0, 0xAA, 0, + 0x55, 0, 0xAA, 0, + 0x55, 0, 0xAA, 0, + 0x55, 0, 0xAA, 0 }; + GetObject32A( hStdMnArrow, sizeof(bm), &bm ); + arrow_bitmap_width = bm.bmWidth; + arrow_bitmap_height = bm.bmHeight; + + if((hBitmap = CreateBitmap32( 8, 8, 1, 1, shade_bits))) + { + if((hShadeBrush = CreatePatternBrush32( hBitmap ))) + { + DeleteObject32( hBitmap ); + if((MENU_DefSysPopup = MENU_CopySysPopup())) return TRUE; + } + } + } } - return TRUE; + return FALSE; /* failure */ } - -/*********************************************************************** - * MENU_GetDefSysMenu - * - * Return the default system menu. - */ -HMENU32 MENU_GetDefSysMenu(void) -{ - return MENU_DefSysMenu; -} - - -/*********************************************************************** - * MENU_HasSysMenu - * - * Check whether the window owning the menu bar has a system menu. - */ -static BOOL32 MENU_HasSysMenu( POPUPMENU *menu ) -{ - WND *wndPtr; - - if (menu->wFlags & MF_POPUP) return FALSE; - if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return FALSE; - return (wndPtr->dwStyle & WS_SYSMENU) != 0; -} - - -/*********************************************************************** - * MENU_IsInSysMenu - * - * Check whether the point (in screen coords) is in the system menu - * of the window owning the given menu. - */ -static BOOL32 MENU_IsInSysMenu( POPUPMENU *menu, POINT32 pt ) -{ - WND *wndPtr; - - if (menu->wFlags & MF_POPUP) return FALSE; - if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return FALSE; - if (!(wndPtr->dwStyle & WS_SYSMENU)) return FALSE; - if ((pt.x < wndPtr->rectClient.left) || - (pt.x >= wndPtr->rectClient.left+SYSMETRICS_CXSIZE+SYSMETRICS_CXBORDER)) - return FALSE; - if ((pt.y >= wndPtr->rectClient.top - menu->Height) || - (pt.y < wndPtr->rectClient.top - menu->Height - - SYSMETRICS_CYSIZE - SYSMETRICS_CYBORDER)) return FALSE; - return TRUE; -} - - /*********************************************************************** * MENU_InitSysMenuPopup * @@ -268,27 +306,43 @@ static MENUITEM *MENU_FindItem( HMENU32 *hmenu, UINT32 *nPos, UINT32 wFlags ) return NULL; } +/*********************************************************************** + * MENU_FreeItemData + */ +static void MENU_FreeItemData( MENUITEM* item ) +{ + /* delete text */ + + if (IS_STRING_ITEM(item->item_flags) && item->text) + HeapFree( SystemHeap, 0, item->text ); + + /* delete checkmark stuff */ + + if (item->pCB) HeapFree( SystemHeap, 0, item->pCB ); +} /*********************************************************************** * MENU_FindItemByCoords * - * Find the item at the specified coordinates (screen coords). + * Find the item at the specified coordinates (screen coords). Does + * not work for child windows and therefore should not be called for + * an arbitrary system menu. */ -static MENUITEM *MENU_FindItemByCoords( POPUPMENU *menu, INT32 x, INT32 y, - UINT32 *pos ) +static MENUITEM *MENU_FindItemByCoords( POPUPMENU *menu, + POINT32 pt, UINT32 *pos ) { MENUITEM *item; WND *wndPtr; UINT32 i; if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return NULL; - x -= wndPtr->rectWindow.left; - y -= wndPtr->rectWindow.top; + pt.x -= wndPtr->rectWindow.left; + pt.y -= wndPtr->rectWindow.top; item = menu->items; for (i = 0; i < menu->nItems; i++, item++) { - if ((x >= item->rect.left) && (x < item->rect.right) && - (y >= item->rect.top) && (y < item->rect.bottom)) + if ((pt.x >= item->rect.left) && (pt.x < item->rect.right) && + (pt.y >= item->rect.top) && (pt.y < item->rect.bottom)) { if (pos) *pos = i; return item; @@ -309,7 +363,11 @@ static UINT32 MENU_FindItemByKey( HWND32 hwndOwner, HMENU32 hmenu, { dprintf_menu(stddeb,"\tlooking for '%c' in [%04x]\n", (char)key, (UINT16)hmenu ); - if (!IsMenu32( hmenu )) hmenu = WIN_FindWndPtr(hwndOwner)->hSysMenu; + if (!IsMenu32( hmenu )) + { + WND* w = WIN_FindWndPtr(hwndOwner); + hmenu = GetSubMenu32(w->hSysMenu, 0); + } if (hmenu) { @@ -437,12 +495,13 @@ static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop, HWND32 hwndOwner ) lppop->Width = lppop->Height = 0; if (lppop->nItems == 0) return; hdc = GetDC32( 0 ); - maxX = start = 0; + start = 0; + maxX = SYSMETRICS_CXBORDER; while (start < lppop->nItems) { lpitem = &lppop->items[start]; orgX = maxX; - orgY = 0; + orgY = SYSMETRICS_CYBORDER; maxTab = maxTabWidth = 0; /* Parse items until column break or end of menu */ @@ -480,6 +539,10 @@ static void MENU_PopupMenuCalcSize( LPPOPUPMENU lppop, HWND32 hwndOwner ) /*********************************************************************** * MENU_MenuBarCalcSize * + * FIXME: Word 6 implements it's own MDI and it's 'close window' bitmap + * height is off by 1 pixel which causes lengthy window relocations when + * active document window is maximized/restored. + * * Calculate the size of the menu bar. */ static void MENU_MenuBarCalcSize( HDC32 hdc, LPRECT32 lprect, @@ -544,7 +607,6 @@ static void MENU_MenuBarCalcSize( HDC32 hdc, LPRECT32 lprect, } } - /*********************************************************************** * MENU_DrawMenuItem * @@ -555,6 +617,13 @@ static void MENU_DrawMenuItem( HWND32 hwnd, HDC32 hdc, MENUITEM *lpitem, { RECT32 rect; + if (lpitem->item_flags & MF_SYSMENU) + { + if( !IsIconic32(hwnd) ) NC_DrawSysButton( hwnd, hdc, + lpitem->item_flags & (MF_HILITE | MF_MOUSESELECT)); + return; + } + if (lpitem->item_flags & MF_OWNERDRAW) { DRAWITEMSTRUCT32 dis; @@ -622,21 +691,23 @@ static void MENU_DrawMenuItem( HWND32 hwnd, HDC32 hdc, MENUITEM *lpitem, if (!menuBar) { - /* Draw the check mark */ + INT32 y = rect.top + rect.bottom; + + /* Draw the check mark + * + * Custom checkmark bitmaps are monochrome but not always 1bpp. + * In this case we want GRAPH_DrawBitmap() to copy a plane which + * is 1 for a white pixel and 0 for a black one. + */ if (lpitem->item_flags & MF_CHECKED) - { - GRAPH_DrawBitmap(hdc, lpitem->hCheckBit ? lpitem->hCheckBit : - hStdCheck, rect.left, - (rect.top+rect.bottom-check_bitmap_height) / 2, - 0, 0, check_bitmap_width, check_bitmap_height ); - } - else if (lpitem->hUnCheckBit != 0) /* Not checked */ - { - GRAPH_DrawBitmap(hdc, lpitem->hUnCheckBit, rect.left, - (rect.top+rect.bottom-check_bitmap_height) / 2, - 0, 0, check_bitmap_width, check_bitmap_height ); - } + GRAPH_DrawBitmap( hdc, lpitem->pCB ? lpitem->pCB->hCheckBit + : hStdCheck, rect.left, (y - check_bitmap_height) / 2, + 0, 0, check_bitmap_width, check_bitmap_height, TRUE ); + else if (lpitem->pCB) + GRAPH_DrawBitmap( hdc, lpitem->pCB->hUnCheckBit, rect.left, + (y - check_bitmap_height) / 2, 0, 0, + check_bitmap_width, check_bitmap_height, TRUE ); /* Draw the popup-menu arrow */ @@ -644,8 +715,8 @@ static void MENU_DrawMenuItem( HWND32 hwnd, HDC32 hdc, MENUITEM *lpitem, { GRAPH_DrawBitmap( hdc, hStdMnArrow, rect.right-arrow_bitmap_width-1, - (rect.top+rect.bottom-arrow_bitmap_height) / 2, - 0, 0, arrow_bitmap_width, arrow_bitmap_height ); + (y - arrow_bitmap_height) / 2, 0, 0, + arrow_bitmap_width, arrow_bitmap_height, FALSE ); } rect.left += check_bitmap_width; @@ -658,7 +729,7 @@ static void MENU_DrawMenuItem( HWND32 hwnd, HDC32 hdc, MENUITEM *lpitem, { GRAPH_DrawBitmap( hdc, (HBITMAP32)lpitem->text, rect.left, rect.top, 0, 0, - rect.right-rect.left, rect.bottom-rect.top ); + rect.right-rect.left, rect.bottom-rect.top, FALSE ); return; } /* No bitmap - process text if present */ @@ -704,17 +775,54 @@ static void MENU_DrawMenuItem( HWND32 hwnd, HDC32 hdc, MENUITEM *lpitem, */ static void MENU_DrawPopupMenu( HWND32 hwnd, HDC32 hdc, HMENU32 hmenu ) { - POPUPMENU *menu; - MENUITEM *item; + HBRUSH32 hPrevBrush = 0; RECT32 rect; - UINT32 i; GetClientRect32( hwnd, &rect ); - FillRect32( hdc, &rect, sysColorObjects.hbrushMenu ); - menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); - if (!menu || !menu->nItems) return; - for (i = menu->nItems, item = menu->items; i > 0; i--, item++) - MENU_DrawMenuItem( hwnd, hdc, item, menu->Height, FALSE ); + rect.bottom -= POPUP_YSHADE * SYSMETRICS_CYBORDER; + rect.right -= POPUP_XSHADE * SYSMETRICS_CXBORDER; + + if((hPrevBrush = SelectObject32( hdc, sysColorObjects.hbrushMenu ))) + { + HPEN32 hPrevPen; + + Rectangle32( hdc, rect.left, rect.top, rect.right, rect.bottom ); + hPrevPen = SelectObject32( hdc, GetStockObject32( NULL_PEN ) ); + if( hPrevPen ) + { + INT32 ropPrev, i; + POPUPMENU *menu; + + /* draw 3-d shade */ + + SelectObject32( hdc, hShadeBrush ); + SetBkMode32( hdc, TRANSPARENT ); + ropPrev = SetROP232( hdc, R2_MASKPEN ); + + i = rect.right; /* why SetBrushOrg() doesn't? */ + PatBlt32( hdc, i & 0xfffffffe, rect.top + POPUP_YSHADE*SYSMETRICS_CYBORDER, + i%2 + POPUP_XSHADE*SYSMETRICS_CXBORDER, rect.bottom - rect.top, 0x00a000c9 ); + i = rect.bottom; + PatBlt32( hdc, rect.left + POPUP_XSHADE*SYSMETRICS_CXBORDER, i & 0xfffffffe, + rect.right - rect.left, i%2 + POPUP_YSHADE*SYSMETRICS_CYBORDER, 0x00a000c9 ); + SelectObject32( hdc, hPrevPen ); + SelectObject32( hdc, hPrevBrush ); + SetROP232( hdc, ropPrev ); + + /* draw menu items */ + + menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); + if (menu && menu->nItems) + { + MENUITEM *item; + UINT32 u; + + for (u = menu->nItems, item = menu->items; u > 0; u--, item++) + MENU_DrawMenuItem( hwnd, hdc, item, menu->Height, FALSE ); + + } + } else SelectObject32( hdc, hPrevBrush ); + } } @@ -753,34 +861,60 @@ UINT32 MENU_DrawMenuBar( HDC32 hDC, LPRECT32 lprect, HWND32 hwnd, /*********************************************************************** - * MENU_SwitchTPWndTo + * MENU_PatchResidentPopup */ -BOOL32 MENU_SwitchTPWndTo( HTASK16 hTask ) +BOOL32 MENU_PatchResidentPopup( HQUEUE16 checkQueue, WND* wndOwner ) { - /* This is supposed to be called when popup is hidden. - * AppExit() calls with hTask == 0, so we get the next to current. - */ + /* checkQueue tells us whether we have to disconnect top + * popup from the wndOwner or (if the latter is NULL) from + * the checkQueue. If checkQueue is 0 then we need to set + * popup owner to the wndOwner. + * + * This is supposed to be called when top popup is hidden. */ - TDB* task; + if( pTopPopupWnd ) + { + HTASK16 hTask = 0; - if( !pTopPWnd ) return 0; + dprintf_menu(stddeb,"patching resident popup: %04x, %08x\n", + checkQueue, (unsigned) wndOwner); + if( wndOwner ) + { + if( pTopPopupWnd->owner == wndOwner ) + { + if( checkQueue ) pTopPopupWnd->owner = NULL; + return TRUE; + } + + /* switch to the new owner */ - if( !hTask ) - { - task = (TDB*)GlobalLock16( (hTask = GetCurrentTask()) ); - if( task && task->hQueue == pTopPWnd->hmemTaskQ ) - hTask = TASK_GetNextTask(hTask); - else return 0; - } + if( wndOwner->hmemTaskQ == pTopPopupWnd->hmemTaskQ ) + return TRUE; + hTask = QUEUE_GetQueueTask( wndOwner->hmemTaskQ ); + } + else if( pTopPopupWnd->hmemTaskQ == checkQueue ) + { + /* switch to the different task */ - task = (TDB*)GlobalLock16(hTask); - if( !task ) return 0; + hTask = QUEUE_GetQueueTask( pTopPopupWnd->hmemTaskQ ); + hTask = TASK_GetNextTask( hTask ); + } - /* if this task got as far as menu tracking it must have a queue */ + if( hTask ) + { + TDB* task = (TDB*)GlobalLock16( hTask ); - pTopPWnd->hInstance = task->hInstance; - pTopPWnd->hmemTaskQ = task->hQueue; - return 1; + pTopPopupWnd->owner = wndOwner; + if( task ) + { + pTopPopupWnd->hInstance = task->hInstance; + pTopPopupWnd->hmemTaskQ = task->hQueue; + return TRUE; + } + else dprintf_menu(stddeb,"failed to patch resident popup.\n"); + } + } + return FALSE; } /*********************************************************************** @@ -792,9 +926,7 @@ static BOOL32 MENU_ShowPopup( HWND32 hwndOwner, HMENU32 hmenu, UINT32 id, INT32 x, INT32 y, INT32 xanchor, INT32 yanchor ) { POPUPMENU *menu; - WND *wndPtr = NULL; - BOOL32 skip_init = 0; - UINT32 width, height; + WND *wndOwner = NULL; if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return FALSE; if (menu->FocusedItem != NO_SELECTED_ITEM) @@ -802,82 +934,88 @@ static BOOL32 MENU_ShowPopup( HWND32 hwndOwner, HMENU32 hmenu, UINT32 id, menu->items[menu->FocusedItem].item_flags &= ~(MF_HILITE|MF_MOUSESELECT); menu->FocusedItem = NO_SELECTED_ITEM; } + SendMessage16( hwndOwner, WM_INITMENUPOPUP, (WPARAM16)hmenu, MAKELONG( id, (menu->wFlags & MF_SYSMENU) ? 1 : 0 )); - MENU_PopupMenuCalcSize( menu, hwndOwner ); - /* adjust popup menu pos so that it fits within the desktop */ - - width = menu->Width + 2*SYSMETRICS_CXBORDER; - height = menu->Height + 2*SYSMETRICS_CYBORDER; - - if( x + width > SYSMETRICS_CXSCREEN ) + if( (wndOwner = WIN_FindWndPtr( hwndOwner )) ) { - if( xanchor ) - x -= width - xanchor; - if( x + width > SYSMETRICS_CXSCREEN) - x = SYSMETRICS_CXSCREEN - width; - } - if( x < 0 ) - x = 0; + UINT32 width, height; + + MENU_PopupMenuCalcSize( menu, hwndOwner ); + + /* adjust popup menu pos so that it fits within the desktop */ + + width = menu->Width + SYSMETRICS_CXBORDER; + height = menu->Height + SYSMETRICS_CYBORDER; + + if( x + width > SYSMETRICS_CXSCREEN ) + { + if( xanchor ) + x -= width - xanchor; + if( x + width > SYSMETRICS_CXSCREEN) + x = SYSMETRICS_CXSCREEN - width; + } + if( x < 0 ) x = 0; - if( y + height > SYSMETRICS_CYSCREEN ) - { - if( yanchor ) - y -= height + yanchor; if( y + height > SYSMETRICS_CYSCREEN ) - y = SYSMETRICS_CYSCREEN - height; - } - if( y < 0 ) - y = 0; + { + if( yanchor ) + y -= height + yanchor; + if( y + height > SYSMETRICS_CYSCREEN ) + y = SYSMETRICS_CYSCREEN - height; + } + if( y < 0 ) y = 0; - wndPtr = WIN_FindWndPtr( hwndOwner ); - if (!wndPtr) return FALSE; + width += POPUP_XSHADE * SYSMETRICS_CXBORDER; /* add space for shading */ + height += POPUP_YSHADE * SYSMETRICS_CYBORDER; - if (!pTopPWnd) - { - pTopPWnd = WIN_FindWndPtr(CreateWindow32A( POPUPMENU_CLASS_ATOM, NULL, - WS_POPUP | WS_BORDER, x, y, - width, height, - hwndOwner, 0, wndPtr->hInstance, - (LPVOID)hmenu )); - if (!pTopPWnd) return FALSE; - skip_init = TRUE; - } + /* NOTE: In Windows, top menu popup is not owned. */ + if (!pTopPopupWnd) /* create top level popup menu window */ + { + assert( uSubPWndLevel == 0 ); - if( uSubPWndLevel ) - { - /* create new window for the submenu */ - HWND32 hWnd = CreateWindow32A( POPUPMENU_CLASS_ATOM, NULL, - WS_POPUP | WS_BORDER, x, y, - width, height, - menu->hWnd, 0, wndPtr->hInstance, - (LPVOID)hmenu ); - if( !hWnd ) return FALSE; - menu->hWnd = hWnd; - } - else - { - if( !skip_init ) - { - MENU_SwitchTPWndTo(GetCurrentTask()); - SendMessage16( pTopPWnd->hwndSelf, WM_USER, (WPARAM16)hmenu, 0L); - } - menu->hWnd = pTopPWnd->hwndSelf; - } + pTopPopupWnd = WIN_FindWndPtr(CreateWindow32A( POPUPMENU_CLASS_ATOM, NULL, + WS_POPUP, x, y, width, height, + hwndOwner, 0, wndOwner->hInstance, + (LPVOID)hmenu )); + if (!pTopPopupWnd) return FALSE; + menu->hWnd = pTopPopupWnd->hwndSelf; + } + else + if( uSubPWndLevel ) + { + /* create a new window for the submenu */ - uSubPWndLevel++; + menu->hWnd = CreateWindow32A( POPUPMENU_CLASS_ATOM, NULL, + WS_POPUP, x, y, width, height, + menu->hWnd, 0, wndOwner->hInstance, + (LPVOID)hmenu ); + if( !menu->hWnd ) return FALSE; + } + else /* top level popup menu window already exists */ + { + menu->hWnd = pTopPopupWnd->hwndSelf; - wndPtr = WIN_FindWndPtr( menu->hWnd ); + MENU_PatchResidentPopup( 0, wndOwner ); + SendMessage16( pTopPopupWnd->hwndSelf, MM_SETMENUHANDLE, (WPARAM16)hmenu, 0L); + + /* adjust its size */ + + SetWindowPos32( menu->hWnd, 0, x, y, width, height, + SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW); + } + + uSubPWndLevel++; /* menu level counter */ - SetWindowPos32(menu->hWnd, 0, x, y, width, height, - SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOREDRAW); /* Display the window */ - SetWindowPos32( menu->hWnd, HWND_TOP, 0, 0, 0, 0, - SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE ); - UpdateWindow32( menu->hWnd ); - return TRUE; + SetWindowPos32( menu->hWnd, HWND_TOP, 0, 0, 0, 0, + SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE ); + UpdateWindow32( menu->hWnd ); + return TRUE; + } + return FALSE; } @@ -892,10 +1030,11 @@ static void MENU_SelectItem( HWND32 hwndOwner, HMENU32 hmenu, UINT32 wIndex, lppop = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); if (!lppop->nItems) return; + if ((wIndex != NO_SELECTED_ITEM) && - (wIndex != SYSMENU_SELECTED) && (lppop->items[wIndex].item_flags & MF_SEPARATOR)) wIndex = NO_SELECTED_ITEM; + if (lppop->FocusedItem == wIndex) return; if (lppop->wFlags & MF_POPUP) hdc = GetDC32( lppop->hWnd ); else hdc = GetDCEx32( lppop->hWnd, 0, DCX_CACHE | DCX_WINDOW); @@ -903,104 +1042,83 @@ static void MENU_SelectItem( HWND32 hwndOwner, HMENU32 hmenu, UINT32 wIndex, /* Clear previous highlighted item */ if (lppop->FocusedItem != NO_SELECTED_ITEM) { - if (lppop->FocusedItem == SYSMENU_SELECTED) - NC_DrawSysButton( lppop->hWnd, hdc, FALSE ); - else - { - lppop->items[lppop->FocusedItem].item_flags &=~(MF_HILITE|MF_MOUSESELECT); - MENU_DrawMenuItem(lppop->hWnd,hdc,&lppop->items[lppop->FocusedItem], - lppop->Height, !(lppop->wFlags & MF_POPUP) ); - } + lppop->items[lppop->FocusedItem].item_flags &=~(MF_HILITE|MF_MOUSESELECT); + MENU_DrawMenuItem(lppop->hWnd,hdc,&lppop->items[lppop->FocusedItem], + lppop->Height, !(lppop->wFlags & MF_POPUP) ); } /* Highlight new item (if any) */ lppop->FocusedItem = wIndex; if (lppop->FocusedItem != NO_SELECTED_ITEM) { - if (lppop->FocusedItem == SYSMENU_SELECTED) - { - NC_DrawSysButton( lppop->hWnd, hdc, TRUE ); - if (sendMenuSelect) - SendMessage16( hwndOwner, WM_MENUSELECT, - WIN_FindWndPtr(lppop->hWnd)->hSysMenu, - MAKELONG(lppop->wFlags | MF_MOUSESELECT, hmenu)); - } - else - { - lppop->items[lppop->FocusedItem].item_flags |= MF_HILITE; - MENU_DrawMenuItem( lppop->hWnd, hdc, &lppop->items[lppop->FocusedItem], - lppop->Height, !(lppop->wFlags & MF_POPUP) ); - if (sendMenuSelect) - SendMessage16( hwndOwner, WM_MENUSELECT, - lppop->items[lppop->FocusedItem].item_id, - MAKELONG( lppop->items[lppop->FocusedItem].item_flags | MF_MOUSESELECT, hmenu)); - } + lppop->items[lppop->FocusedItem].item_flags |= MF_HILITE; + MENU_DrawMenuItem( lppop->hWnd, hdc, &lppop->items[lppop->FocusedItem], + lppop->Height, !(lppop->wFlags & MF_POPUP) ); + if (sendMenuSelect) + SendMessage16( hwndOwner, WM_MENUSELECT, + lppop->items[lppop->FocusedItem].item_id, + MAKELONG( lppop->items[lppop->FocusedItem].item_flags | MF_MOUSESELECT, hmenu)); } else if (sendMenuSelect) SendMessage16( hwndOwner, WM_MENUSELECT, hmenu, - MAKELONG( lppop->wFlags | MF_MOUSESELECT, hmenu ) ); + MAKELONG( lppop->wFlags | MF_MOUSESELECT, hmenu ) ); ReleaseDC32( lppop->hWnd, hdc ); } /*********************************************************************** - * MENU_SelectItemRel + * MENU_MoveSelection * + * Moves currently selected item according to the offset parameter. + * If there is no selection then it should select the last item if + * offset is ITEM_PREV or the first item if offset is ITEM_NEXT. */ -static void MENU_SelectItemRel( HWND32 hwndOwner, HMENU32 hmenu, INT32 offset ) +static void MENU_MoveSelection( HWND32 hwndOwner, HMENU32 hmenu, INT32 offset ) { - INT32 i, min = 0; + INT32 i; POPUPMENU *menu; menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); if (!menu->items) return; - if ((menu->FocusedItem != NO_SELECTED_ITEM) && - (menu->FocusedItem != SYSMENU_SELECTED)) + + if ( menu->FocusedItem != NO_SELECTED_ITEM ) { + if( menu->nItems == 1 ) return; else for (i = menu->FocusedItem + offset ; i >= 0 && i < menu->nItems ; i += offset) - { if (!(menu->items[i].item_flags & MF_SEPARATOR)) { MENU_SelectItem( hwndOwner, hmenu, i, TRUE ); return; } - } - - if (MENU_HasSysMenu( menu )) - { - MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE ); - return; - } } - if( offset > 0 ) { i = 0; min = -1; } - else i = menu->nItems - 1; - - for ( ; i > min && i < menu->nItems ; i += offset) - { + for ( i = (offset > 0) ? 0 : menu->nItems - 1; + i >= 0 && i < menu->nItems ; i += offset) if (!(menu->items[i].item_flags & MF_SEPARATOR)) { MENU_SelectItem( hwndOwner, hmenu, i, TRUE ); return; } - } - if (MENU_HasSysMenu( menu )) - MENU_SelectItem( hwndOwner, hmenu, SYSMENU_SELECTED, TRUE ); } /********************************************************************** * MENU_SetItemData * - * Set an item flags, id and text ptr. + * Set an item flags, id and text ptr. Called by InsertMenu() and + * ModifyMenu(). */ static BOOL32 MENU_SetItemData( MENUITEM *item, UINT32 flags, UINT32 id, LPCSTR str ) { LPSTR prevText = IS_STRING_ITEM(item->item_flags) ? item->text : NULL; + dprintf_menu(stddeb,"SetItemData: %04x [%08x] '%s' -> %04x [%08x] '%s'\n", + item->item_flags, item->item_id, item->text ? item->text : "", + flags, id, str ? str : "" ); + if (IS_STRING_ITEM(flags)) { if (!str) @@ -1025,8 +1143,20 @@ static BOOL32 MENU_SetItemData( MENUITEM *item, UINT32 flags, UINT32 id, else if (flags & MF_OWNERDRAW) item->text = (LPSTR)str; else item->text = NULL; + if (item->item_flags & MF_POPUP && item->item_id != id ) + DestroyMenu32( (HMENU32)item->item_id ); /* ModifyMenu() spec */ + + if (flags & MF_POPUP) + { + POPUPMENU* menu = (POPUPMENU *)USER_HEAP_LIN_ADDR((UINT16)id); + if( menu && menu->wMagic == MENU_MAGIC) menu->wFlags |= MF_POPUP; + else + return (item->item_id = item->item_flags = FALSE); + } + item->item_flags = flags & ~(MF_HILITE | MF_MOUSESELECT); item->item_id = id; + SetRectEmpty32( &item->rect ); if (prevText) HeapFree( SystemHeap, 0, prevText ); return TRUE; @@ -1155,14 +1285,14 @@ static HMENU32 MENU_GetSubPopup( HMENU32 hmenu ) MENUITEM *item; menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); + if (menu->FocusedItem == NO_SELECTED_ITEM) return 0; - else if (menu->FocusedItem == SYSMENU_SELECTED) - return WIN_FindWndPtr(menu->hWnd)->hSysMenu; item = &menu->items[menu->FocusedItem]; - if (!(item->item_flags & MF_POPUP) || !(item->item_flags & MF_MOUSESELECT)) - return 0; - return (HMENU32)item->item_id; + if ((item->item_flags & (MF_POPUP | MF_MOUSESELECT)) + == (MF_POPUP | MF_MOUSESELECT)) + return (HMENU32)item->item_id; + return 0; } @@ -1174,36 +1304,37 @@ static HMENU32 MENU_GetSubPopup( HMENU32 hmenu ) static void MENU_HideSubPopups( HWND32 hwndOwner, HMENU32 hmenu, BOOL32 sendMenuSelect ) { - MENUITEM *item; - POPUPMENU *menu, *submenu; - HMENU32 hsubmenu; + POPUPMENU *menu = (POPUPMENU*) USER_HEAP_LIN_ADDR( hmenu );; - if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return; - if (menu->FocusedItem == NO_SELECTED_ITEM) return; - if (menu->FocusedItem == SYSMENU_SELECTED) + if (menu && uSubPWndLevel) { - hsubmenu = WIN_FindWndPtr(menu->hWnd)->hSysMenu; - } - else - { - item = &menu->items[menu->FocusedItem]; - if (!(item->item_flags & MF_POPUP) || - !(item->item_flags & MF_MOUSESELECT)) return; - item->item_flags &= ~MF_MOUSESELECT; - hsubmenu = (HMENU32)item->item_id; - } - submenu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hsubmenu ); - MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE ); - MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect ); - if (submenu->hWnd == pTopPWnd->hwndSelf ) - { - ShowWindow32( submenu->hWnd, SW_HIDE ); - uSubPWndLevel = 0; - } - else - { - DestroyWindow32( submenu->hWnd ); - submenu->hWnd = 0; + HMENU32 hsubmenu; + POPUPMENU *submenu; + MENUITEM *item; + + if (menu->FocusedItem != NO_SELECTED_ITEM) + { + item = &menu->items[menu->FocusedItem]; + if (!(item->item_flags & MF_POPUP) || + !(item->item_flags & MF_MOUSESELECT)) return; + item->item_flags &= ~MF_MOUSESELECT; + hsubmenu = (HMENU32)item->item_id; + } else return; + + submenu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hsubmenu ); + MENU_HideSubPopups( hwndOwner, hsubmenu, FALSE ); + MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, sendMenuSelect ); + + if (submenu->hWnd == pTopPopupWnd->hwndSelf ) + { + ShowWindow32( submenu->hWnd, SW_HIDE ); + uSubPWndLevel = 0; + } + else + { + DestroyWindow32( submenu->hWnd ); + submenu->hWnd = 0; + } } } @@ -1217,86 +1348,87 @@ static void MENU_HideSubPopups( HWND32 hwndOwner, HMENU32 hmenu, static HMENU32 MENU_ShowSubPopup( HWND32 hwndOwner, HMENU32 hmenu, BOOL32 selectFirst ) { + RECT32 rect; POPUPMENU *menu; MENUITEM *item; WND *wndPtr; if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return hmenu; - if (!(wndPtr = WIN_FindWndPtr( menu->hWnd ))) return hmenu; - if (menu->FocusedItem == NO_SELECTED_ITEM) return hmenu; - if (menu->FocusedItem == SYSMENU_SELECTED) - { - MENU_InitSysMenuPopup(wndPtr->hSysMenu, wndPtr->dwStyle, - wndPtr->class->style); - MENU_ShowPopup(hwndOwner, wndPtr->hSysMenu, 0, wndPtr->rectClient.left, - wndPtr->rectClient.top - menu->Height - 2*SYSMETRICS_CYBORDER, - SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE ); - if (selectFirst) - MENU_SelectItemRel( hwndOwner, wndPtr->hSysMenu, ITEM_NEXT ); - return wndPtr->hSysMenu; - } + + if (!(wndPtr = WIN_FindWndPtr( menu->hWnd )) || + (menu->FocusedItem == NO_SELECTED_ITEM)) return hmenu; + item = &menu->items[menu->FocusedItem]; if (!(item->item_flags & MF_POPUP) || - (item->item_flags & (MF_GRAYED | MF_DISABLED))) return hmenu; + (item->item_flags & (MF_GRAYED | MF_DISABLED))) return hmenu; item->item_flags |= MF_MOUSESELECT; - if (menu->wFlags & MF_POPUP) + + if (IS_SYSTEM_MENU(menu)) { - MENU_ShowPopup( hwndOwner, (HMENU16)item->item_id, menu->FocusedItem, - wndPtr->rectWindow.left + item->rect.right-arrow_bitmap_width, - wndPtr->rectWindow.top + item->rect.top, - item->rect.left - item->rect.right + 2*arrow_bitmap_width, - item->rect.top - item->rect.bottom ); + MENU_InitSysMenuPopup((HMENU16)item->item_id, wndPtr->dwStyle, wndPtr->class->style); + + NC_GetSysPopupPos( wndPtr, &rect ); + rect.top = rect.bottom; + rect.right = SYSMETRICS_CXSIZE; rect.bottom = SYSMETRICS_CYSIZE; } else { - MENU_ShowPopup( hwndOwner, (HMENU16)item->item_id, menu->FocusedItem, - wndPtr->rectWindow.left + item->rect.left, - wndPtr->rectWindow.top + item->rect.bottom, - item->rect.right - item->rect.left, - item->rect.bottom - item->rect.top ); + if (menu->wFlags & MF_POPUP) + { + rect.left = wndPtr->rectWindow.left + item->rect.right-arrow_bitmap_width; + rect.top = wndPtr->rectWindow.top + item->rect.top; + rect.right = item->rect.left - item->rect.right + 2*arrow_bitmap_width; + rect.bottom = item->rect.top - item->rect.bottom; + } + else + { + rect.left = wndPtr->rectWindow.left + item->rect.left; + rect.top = wndPtr->rectWindow.top + item->rect.bottom; + rect.right = item->rect.right - item->rect.left; + rect.bottom = item->rect.bottom - item->rect.top; + } } + + MENU_ShowPopup( hwndOwner, (HMENU16)item->item_id, menu->FocusedItem, + rect.left, rect.top, rect.right, rect.bottom ); if (selectFirst) - MENU_SelectItemRel( hwndOwner, (HMENU32)item->item_id, ITEM_NEXT ); + MENU_MoveSelection( hwndOwner, (HMENU32)item->item_id, ITEM_NEXT ); return (HMENU32)item->item_id; } - /*********************************************************************** - * MENU_FindMenuByCoords + * MENU_PtMenu * - * Find the menu containing a given point (in screen coords). + * Walks menu chain trying to find a menu pt maps to. */ -static HMENU32 MENU_FindMenuByCoords( HMENU32 hmenu, POINT32 pt ) +static HMENU32 MENU_PtMenu( HMENU32 hMenu, POINT16 pt ) { - POPUPMENU *menu; - HWND32 hwnd; + POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hMenu ); + register UINT32 ht = menu->FocusedItem; - if (!(hwnd = WindowFromPoint32( pt ))) return 0; - while (hmenu) - { - menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); - if (menu->hWnd == hwnd) +#define HAS_POPUP(item) (((item).item_flags & (MF_POPUP | MF_MOUSESELECT)) \ + == (MF_POPUP | MF_MOUSESELECT)) + /* try subpopup first (if any) */ + ht = (ht != NO_SELECTED_ITEM && HAS_POPUP(menu->items[ht])) + ? (UINT32)MENU_PtMenu( menu->items[ht].item_id, pt ) : 0; +#undef HAS_POPUP + + if( !ht ) /* check the current window (avoiding WM_HITTEST) */ + { + ht = (UINT32)NC_HandleNCHitTest( menu->hWnd, pt ); + if( menu->wFlags & MF_POPUP ) + ht = (ht != (UINT32)HTNOWHERE && + ht != (UINT32)HTERROR) ? (UINT32)hMenu : 0; + else { - if (!(menu->wFlags & MF_POPUP)) - { - /* Make sure it's in the menu bar (or in system menu) */ - WND *wndPtr = WIN_FindWndPtr( menu->hWnd ); - if ((pt.x < wndPtr->rectClient.left) || - (pt.x >= wndPtr->rectClient.right) || - (pt.y >= wndPtr->rectClient.top)) return 0; - if (pt.y < wndPtr->rectClient.top - menu->Height) - { - if (!MENU_IsInSysMenu( menu, pt )) return 0; - } - /* else it's in the menu bar */ - } - return hmenu; - } - hmenu = MENU_GetSubPopup( hmenu ); - } - return 0; -} + WND* wndPtr = WIN_FindWndPtr(menu->hWnd); + ht = ( ht == HTSYSMENU ) ? (UINT32)(wndPtr->hSysMenu) + : ( ht == HTMENU ) ? (UINT32)(wndPtr->wIDmenu) : 0; + } + } + return (HMENU32)ht; +} /*********************************************************************** * MENU_ExecFocusedItem @@ -1304,157 +1436,177 @@ static HMENU32 MENU_FindMenuByCoords( HMENU32 hmenu, POINT32 pt ) * Execute a menu item (for instance when user pressed Enter). * Return TRUE if we can go on with menu tracking. */ -static BOOL32 MENU_ExecFocusedItem( HWND32 hwndOwner, HMENU32 hmenu, - HMENU32 *hmenuCurrent ) +static BOOL32 MENU_ExecFocusedItem( MTRACKER* pmt, HMENU32 hMenu ) { MENUITEM *item; - POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); - if (!menu || !menu->nItems || (menu->FocusedItem == NO_SELECTED_ITEM) || - (menu->FocusedItem == SYSMENU_SELECTED)) return TRUE; + POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hMenu ); + if (!menu || !menu->nItems || + (menu->FocusedItem == NO_SELECTED_ITEM)) return TRUE; + item = &menu->items[menu->FocusedItem]; if (!(item->item_flags & MF_POPUP)) { if (!(item->item_flags & (MF_GRAYED | MF_DISABLED))) { - PostMessage16( hwndOwner, (menu->wFlags & MF_SYSMENU) ? - WM_SYSCOMMAND : WM_COMMAND, item->item_id, 0 ); + if( menu->wFlags & MF_SYSMENU ) + { + PostMessage16( pmt->hOwnerWnd, WM_SYSCOMMAND, item->item_id, + MAKELPARAM((INT16)pmt->pt.x, (INT16)pmt->pt.y) ); + } + else + PostMessage16( pmt->hOwnerWnd, WM_COMMAND, + item->item_id, 0 ); return FALSE; } else return TRUE; } else { - *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, TRUE ); + pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hMenu, TRUE ); return TRUE; } } /*********************************************************************** - * MENU_ButtonDown + * MENU_SwitchTracking * - * Handle a button-down event in a menu. Point is in screen coords. - * hmenuCurrent is the top-most visible popup. - * Return TRUE if we can go on with menu tracking. + * Helper function for menu navigation routines. */ -static BOOL32 MENU_ButtonDown( HWND32 hwndOwner, HMENU32 hmenu, - HMENU32 *hmenuCurrent, POINT32 pt ) +static void MENU_SwitchTracking( MTRACKER* pmt, HMENU32 hPtMenu, UINT32 id ) { - POPUPMENU *menu; - MENUITEM *item; - UINT32 id; + POPUPMENU *ptmenu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hPtMenu ); + POPUPMENU *topmenu = (POPUPMENU *) USER_HEAP_LIN_ADDR( pmt->hTopMenu ); - if (!hmenu) return FALSE; /* Outside all menus */ - menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); - item = MENU_FindItemByCoords( menu, pt.x, pt.y, &id ); - if (!item) /* Maybe in system menu */ + if( pmt->hTopMenu != hPtMenu && + !((ptmenu->wFlags | topmenu->wFlags) & MF_POPUP) ) { - if (!MENU_IsInSysMenu( menu, pt )) return FALSE; - id = SYSMENU_SELECTED; - } + /* both are top level menus (system and menu-bar) */ - if (menu->FocusedItem == id) - { - if (id == SYSMENU_SELECTED) return FALSE; - if (item->item_flags & MF_POPUP) - { - if (item->item_flags & MF_MOUSESELECT) - { - if (menu->wFlags & MF_POPUP) - { - MENU_HideSubPopups( hwndOwner, hmenu, TRUE ); - *hmenuCurrent = hmenu; - } - else return FALSE; - } - else *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, FALSE ); - } + MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE ); + MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE ); + pmt->hTopMenu = hPtMenu; } - else - { - MENU_HideSubPopups( hwndOwner, hmenu, FALSE ); - MENU_SelectItem( hwndOwner, hmenu, id, TRUE ); - *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, FALSE ); - } - return TRUE; + else MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, FALSE ); + MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, id, TRUE ); } /*********************************************************************** - * MENU_ButtonUp + * MENU_ButtonDown * - * Handle a button-up event in a menu. Point is in screen coords. - * hmenuCurrent is the top-most visible popup. * Return TRUE if we can go on with menu tracking. */ -static BOOL32 MENU_ButtonUp( HWND32 hwndOwner, HMENU32 hmenu, - HMENU32 *hmenuCurrent, POINT32 pt ) +static BOOL32 MENU_ButtonDown( MTRACKER* pmt, HMENU32 hPtMenu ) { - POPUPMENU *menu; - MENUITEM *item; - HMENU32 hsubmenu = 0; - UINT32 id; - - if (!hmenu) return FALSE; /* Outside all menus */ - menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); - item = MENU_FindItemByCoords( menu, pt.x, pt.y, &id ); - if (!item) /* Maybe in system menu */ + if (hPtMenu) { - if (!MENU_IsInSysMenu( menu, pt )) return FALSE; - id = SYSMENU_SELECTED; - hsubmenu = WIN_FindWndPtr(menu->hWnd)->hSysMenu; - } + UINT32 id = 0; + POPUPMENU *ptmenu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hPtMenu ); + MENUITEM *item; - if (menu->FocusedItem != id) return FALSE; + if( IS_SYSTEM_MENU(ptmenu) ) + item = ptmenu->items; + else + item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id ); - if (id != SYSMENU_SELECTED) - { - if (!(item->item_flags & MF_POPUP)) + if( item ) { - return MENU_ExecFocusedItem( hwndOwner, hmenu, hmenuCurrent ); - } - hsubmenu = (HMENU32)item->item_id; + if( ptmenu->FocusedItem == id ) + { + /* nothing to do with already selected non-popup */ + if( !(item->item_flags & MF_POPUP) ) return TRUE; + + if( item->item_flags & MF_MOUSESELECT ) + { + if( ptmenu->wFlags & MF_POPUP ) + { + /* hide selected subpopup */ + + MENU_HideSubPopups( pmt->hOwnerWnd, hPtMenu, TRUE ); + pmt->hCurrentMenu = hPtMenu; + return TRUE; + } + return FALSE; /* shouldn't get here */ + } + } + else MENU_SwitchTracking( pmt, hPtMenu, id ); + + /* try to display a subpopup */ + + pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE ); + return TRUE; + } + else dprintf_menu(stddeb,"\tunable to find clicked item!\n"); } - /* Select first item of sub-popup */ - MENU_SelectItem( hwndOwner, hsubmenu, NO_SELECTED_ITEM, FALSE ); - MENU_SelectItemRel( hwndOwner, hsubmenu, ITEM_NEXT ); - return TRUE; + return FALSE; +} + +/*********************************************************************** + * MENU_ButtonUp + * + * Return TRUE if we can go on with menu tracking. + */ +static BOOL32 MENU_ButtonUp( MTRACKER* pmt, HMENU32 hPtMenu ) +{ + if (hPtMenu) + { + UINT32 id = 0; + POPUPMENU *ptmenu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hPtMenu ); + MENUITEM *item; + + if( IS_SYSTEM_MENU(ptmenu) ) + item = ptmenu->items; + else + item = MENU_FindItemByCoords( ptmenu, pmt->pt, &id ); + + if( ptmenu->FocusedItem == id ) + { + if( !(item->item_flags & MF_POPUP) ) + return MENU_ExecFocusedItem( pmt, hPtMenu ); + hPtMenu = (HMENU32)item->item_id; + if( hPtMenu == pmt->hCurrentMenu ) + { + /* Select first item of sub-popup */ + + MENU_SelectItem( pmt->hOwnerWnd, hPtMenu, NO_SELECTED_ITEM, FALSE ); + MENU_MoveSelection( pmt->hOwnerWnd, hPtMenu, ITEM_NEXT ); + } + return TRUE; + } + } + return FALSE; } /*********************************************************************** * MENU_MouseMove * - * Handle a motion event in a menu. Point is in screen coords. - * hmenuCurrent is the top-most visible popup. * Return TRUE if we can go on with menu tracking. */ -static BOOL32 MENU_MouseMove( HWND32 hwndOwner, HMENU32 hmenu, - HMENU32 *hmenuCurrent, POINT32 pt ) +static BOOL32 MENU_MouseMove( MTRACKER* pmt, HMENU32 hPtMenu ) { - MENUITEM *item; - POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); UINT32 id = NO_SELECTED_ITEM; + POPUPMENU *ptmenu = NULL; - if (hmenu) + if( hPtMenu ) { - item = MENU_FindItemByCoords( menu, pt.x, pt.y, &id ); - if (!item) /* Maybe in system menu */ - { - if (!MENU_IsInSysMenu( menu, pt )) - id = NO_SELECTED_ITEM; /* Outside all items */ - else id = SYSMENU_SELECTED; - } - } - if (id == NO_SELECTED_ITEM) + ptmenu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hPtMenu ); + if( IS_SYSTEM_MENU(ptmenu) ) + id = 0; + else + MENU_FindItemByCoords( ptmenu, pmt->pt, &id ); + } + + if( id == NO_SELECTED_ITEM ) { - MENU_SelectItem( hwndOwner, *hmenuCurrent, NO_SELECTED_ITEM, TRUE ); + MENU_SelectItem( pmt->hOwnerWnd, pmt->hCurrentMenu, + NO_SELECTED_ITEM, TRUE ); } - else if (menu->FocusedItem != id) + else if( ptmenu->FocusedItem != id ) { - MENU_HideSubPopups( hwndOwner, hmenu, FALSE ); - MENU_SelectItem( hwndOwner, hmenu, id, TRUE ); - *hmenuCurrent = MENU_ShowSubPopup( hwndOwner, hmenu, FALSE ); + MENU_SwitchTracking( pmt, hPtMenu, id ); + pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hPtMenu, FALSE ); } return TRUE; } @@ -1462,126 +1614,178 @@ static BOOL32 MENU_MouseMove( HWND32 hwndOwner, HMENU32 hmenu, /*********************************************************************** * MENU_DoNextMenu + * + * NOTE: WM_NEXTMENU documented in Win32 is a bit different. */ -static LRESULT MENU_DoNextMenu( HWND32* hwndOwner, HMENU32* hmenu, - HMENU32 *hmenuCurrent, UINT32 vk ) +static LRESULT MENU_DoNextMenu( MTRACKER* pmt, UINT32 vk ) { - POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( *hmenu ); - UINT32 id = 0; + POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( pmt->hTopMenu ); - if( (vk == VK_LEFT && !menu->FocusedItem) - || (vk == VK_RIGHT && menu->FocusedItem == menu->nItems - 1) - || menu->FocusedItem == SYSMENU_SELECTED - || ((menu->wFlags & (MF_POPUP | MF_SYSMENU)) == (MF_POPUP | MF_SYSMENU))) - { - LRESULT l = SendMessage16( *hwndOwner, WM_NEXTMENU, (WPARAM16)vk, - (LPARAM)((menu->FocusedItem == SYSMENU_SELECTED) - ? GetSystemMenu32( *hwndOwner, 0) - : *hmenu)); + if( (vk == VK_LEFT && menu->FocusedItem == 0 ) || + (vk == VK_RIGHT && menu->FocusedItem == menu->nItems - 1)) + { + WND* wndPtr; + HMENU32 hNewMenu; + HWND32 hNewWnd; + UINT32 id = 0; + LRESULT l = SendMessage16( pmt->hOwnerWnd, WM_NEXTMENU, (WPARAM16)vk, + (IS_SYSTEM_MENU(menu)) ? GetSubMenu16(pmt->hTopMenu,0) : pmt->hTopMenu ); - if( l == 0 || !IsMenu32(LOWORD(l)) || !IsWindow32(HIWORD(l)) ) return 0; + dprintf_menu(stddeb,"NextMenu: %04x [%04x] -> %04x [%04x]\n", + (UINT16)pmt->hCurrentMenu, (UINT16)pmt->hOwnerWnd, LOWORD(l), HIWORD(l) ); - /* shutdown current menu - - * all these checks for system popup window are needed - * only because Wine system menu tracking is unsuitable - * for a lot of things (esp. when we do not have wIDmenu to fall back on). - */ - - MENU_SelectItem( *hwndOwner, *hmenu, NO_SELECTED_ITEM, FALSE ); - - if( (menu->wFlags & (MF_POPUP | MF_SYSMENU)) == (MF_POPUP | MF_SYSMENU) ) + if( l == 0 ) { - ShowWindow32( menu->hWnd, SW_HIDE ); - uSubPWndLevel = 0; + wndPtr = WIN_FindWndPtr(pmt->hOwnerWnd); - if( !IsIconic32( *hwndOwner ) ) - { - HDC32 hdc = GetDCEx32( *hwndOwner, 0, DCX_CACHE | DCX_WINDOW); - NC_DrawSysButton( *hwndOwner, hdc, FALSE ); - ReleaseDC32( *hwndOwner, hdc ); - } + hNewWnd = pmt->hOwnerWnd; + if( IS_SYSTEM_MENU(menu) ) + { + /* switch to the menu bar */ + + if( wndPtr->dwStyle & WS_CHILD || !wndPtr->wIDmenu ) + return FALSE; + + hNewMenu = wndPtr->wIDmenu; + if( vk == VK_LEFT ) + { + menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hNewMenu ); + id = menu->nItems - 1; + } + } + else if( wndPtr->dwStyle & WS_SYSMENU ) + { + /* switch to the system menu */ + hNewMenu = wndPtr->hSysMenu; + } + else return FALSE; + } + else /* application returned a new menu to switch to */ + { + hNewMenu = LOWORD(l); hNewWnd = HIWORD(l); + + if( IsMenu32(hNewMenu) && IsWindow32(hNewWnd) ) + { + wndPtr = WIN_FindWndPtr(hNewWnd); + + if( wndPtr->dwStyle & WS_SYSMENU && + GetSubMenu16(wndPtr->hSysMenu, 0) == hNewMenu ) + { + /* get the real system menu */ + hNewMenu = wndPtr->hSysMenu; + } + else if( wndPtr->dwStyle & WS_CHILD || wndPtr->wIDmenu != hNewMenu ) + { + /* FIXME: Not sure what to do here, perhaps, + * try to track hNewMenu as a popup? */ + + dprintf_menu(stddeb,"MENU_DoNextMenu() got confused.\n"); + return FALSE; + } + } + else return FALSE; } - ReleaseCapture(); - *hwndOwner = HIWORD(l); - *hmenu = LOWORD(l); - SetCapture32( *hwndOwner ); + if( hNewMenu != pmt->hTopMenu ) + { + MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, NO_SELECTED_ITEM, FALSE ); + if( pmt->hCurrentMenu != pmt->hTopMenu ) + MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE ); + } - menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( *hmenu ); + if( hNewWnd != pmt->hOwnerWnd ) + { + ReleaseCapture(); + pmt->hOwnerWnd = hNewWnd; + EVENT_Capture( pmt->hOwnerWnd, HTMENU ); + } - /* init next menu */ + pmt->hTopMenu = pmt->hCurrentMenu = hNewMenu; /* all subpopups are hidden */ + MENU_SelectItem( pmt->hOwnerWnd, pmt->hTopMenu, id, TRUE ); - if( (menu->wFlags & (MF_POPUP | MF_SYSMENU)) == (MF_POPUP | MF_SYSMENU) ) + return TRUE; + } + return FALSE; +} + +/*********************************************************************** + * MENU_SuspendPopup + * + * The idea is not to show the popup if the next input message is + * going to hide it anyway. + */ +static BOOL32 MENU_SuspendPopup( MTRACKER* pmt, UINT16 uMsg ) +{ + MSG16 msg; + + msg.hwnd = pmt->hOwnerWnd; + + PeekMessage16( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE); + pmt->trackFlags |= TF_SKIPREMOVE; + + switch( uMsg ) { - RECT32 rect; - WND* wndPtr = WIN_FindWndPtr( *hwndOwner ); - - /* stupid kludge, see above */ - - if( wndPtr->wIDmenu && !(wndPtr->dwStyle & WS_CHILD) ) - { - *hmenu = wndPtr->wIDmenu; - id = SYSMENU_SELECTED; - } - else - { - if( NC_GetSysPopupPos( wndPtr, &rect ) ) - MENU_ShowPopup( *hwndOwner, *hmenu, 0, rect.left, rect.bottom, - SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE ); - - if( !IsIconic32( *hwndOwner ) ) - { - HDC32 hdc = GetDCEx32( *hwndOwner, 0, DCX_CACHE | DCX_WINDOW); - NC_DrawSysButton( *hwndOwner, hdc, TRUE ); - ReleaseDC32( *hwndOwner, hdc ); - } - } + case WM_KEYDOWN: + PeekMessage16( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE); + if( msg.message == WM_KEYUP || msg.message == WM_PAINT ) + { + PeekMessage16( &msg, 0, 0, 0, PM_NOYIELD | PM_REMOVE); + PeekMessage16( &msg, 0, 0, 0, PM_NOYIELD | PM_NOREMOVE); + if( msg.message == WM_KEYDOWN && + (msg.wParam == VK_LEFT || msg.wParam == VK_RIGHT)) + { + pmt->trackFlags |= TF_SUSPENDPOPUP; + return TRUE; + } + } + break; } - MENU_SelectItem( *hwndOwner, *hmenu, id, TRUE ); - return l; - } - return 0; + /* failures go through this */ + pmt->trackFlags &= ~TF_SUSPENDPOPUP; + return FALSE; } /*********************************************************************** * MENU_KeyLeft * - * Handle a VK_LEFT key event in a menu. - * hmenuCurrent is the top-most visible popup. + * Handle a VK_LEFT key event in a menu. */ -static void MENU_KeyLeft( HWND32* hwndOwner, HMENU32* hmenu, - HMENU32 *hmenuCurrent ) +static void MENU_KeyLeft( MTRACKER* pmt ) { POPUPMENU *menu; HMENU32 hmenutmp, hmenuprev; - menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( *hmenu ); - hmenuprev = hmenutmp = *hmenu; - while (hmenutmp != *hmenuCurrent) + hmenuprev = hmenutmp = pmt->hTopMenu; + menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenutmp ); + + /* close topmost popup */ + while (hmenutmp != pmt->hCurrentMenu) { + hmenuprev = hmenutmp; hmenutmp = MENU_GetSubPopup( hmenuprev ); - if (hmenutmp != *hmenuCurrent) hmenuprev = hmenutmp; } - MENU_HideSubPopups( *hwndOwner, hmenuprev, TRUE ); - hmenutmp = *hmenu; - if ( (hmenuprev == *hmenu) && - ((menu->wFlags & MF_SYSMENU) || !(menu->wFlags & MF_POPUP)) ) + MENU_HideSubPopups( pmt->hOwnerWnd, hmenuprev, TRUE ); + pmt->hCurrentMenu = hmenuprev; + + if ( (hmenuprev == pmt->hTopMenu) && !(menu->wFlags & MF_POPUP) ) { - /* send WM_NEXTMENU */ + /* move menu bar selection if no more popups are left */ - if( !MENU_DoNextMenu( hwndOwner, hmenu, hmenuCurrent, VK_LEFT) ) - MENU_SelectItemRel( *hwndOwner, *hmenu, ITEM_PREV ); - else *hmenuCurrent = *hmenu; + if( !MENU_DoNextMenu( pmt, VK_LEFT) ) + MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_PREV ); - if (*hmenuCurrent != hmenutmp) + if ( hmenuprev != hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP ) { - /* A sublevel menu was displayed -> display the next one */ - *hmenuCurrent = MENU_ShowSubPopup( *hwndOwner, *hmenu, TRUE ); + /* A sublevel menu was displayed - display the next one + * unless there is another displacement coming up */ + + if( !MENU_SuspendPopup( pmt, WM_KEYDOWN ) ) + pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, + pmt->hTopMenu, TRUE ); } } - else *hmenuCurrent = hmenuprev; } @@ -1589,57 +1793,39 @@ static void MENU_KeyLeft( HWND32* hwndOwner, HMENU32* hmenu, * MENU_KeyRight * * Handle a VK_RIGHT key event in a menu. - * hmenuCurrent is the top-most visible popup. */ -static void MENU_KeyRight( HWND32* hwndOwner, HMENU32* hmenu, - HMENU32 *hmenuCurrent ) +static void MENU_KeyRight( MTRACKER* pmt ) { - POPUPMENU *menu; HMENU32 hmenutmp; + POPUPMENU *menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( pmt->hTopMenu ); - menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( *hmenu ); - - if ((menu->wFlags & MF_POPUP) || (*hmenuCurrent != *hmenu)) + if ( (menu->wFlags & MF_POPUP) || (pmt->hCurrentMenu != pmt->hTopMenu)) { - /* If already displaying a popup, try to display sub-popup */ - hmenutmp = MENU_ShowSubPopup( *hwndOwner, *hmenuCurrent, TRUE ); - if (hmenutmp != *hmenuCurrent) /* Sub-popup displayed */ - { - *hmenuCurrent = hmenutmp; - return; - } + /* If already displaying a popup, try to display sub-popup */ + + hmenutmp = pmt->hCurrentMenu; + pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, hmenutmp, TRUE ); + + /* if subpopup was displayed then we are done */ + if (hmenutmp != pmt->hCurrentMenu) return; } - /* If menu-bar tracking, go to next item */ - - if (!(menu->wFlags & MF_POPUP) || (menu->wFlags & MF_SYSMENU)) + if (!(menu->wFlags & MF_POPUP)) /* menu bar tracking */ { - MENU_HideSubPopups( *hwndOwner, *hmenu, FALSE ); - hmenutmp = *hmenu; - - /* Send WM_NEXTMENU */ - - if( !MENU_DoNextMenu( hwndOwner, hmenu, hmenuCurrent, VK_RIGHT) ) - MENU_SelectItemRel( *hwndOwner, *hmenu, ITEM_NEXT ); - else *hmenuCurrent = *hmenu; - - if (*hmenuCurrent != hmenutmp) + if( pmt->hCurrentMenu != pmt->hTopMenu ) { - /* A sublevel menu was displayed -> display the next one */ - *hmenuCurrent = MENU_ShowSubPopup( *hwndOwner, *hmenu, TRUE ); - } - } - else if (*hmenuCurrent != *hmenu) /* Hide last level popup */ - { - HMENU16 hmenuprev; - hmenuprev = hmenutmp = *hmenu; - while (hmenutmp != *hmenuCurrent) - { - hmenutmp = MENU_GetSubPopup( hmenuprev ); - if (hmenutmp != *hmenuCurrent) hmenuprev = hmenutmp; - } - MENU_HideSubPopups( *hwndOwner, hmenuprev, TRUE ); - *hmenuCurrent = hmenuprev; + MENU_HideSubPopups( pmt->hOwnerWnd, pmt->hTopMenu, FALSE ); + hmenutmp = pmt->hCurrentMenu = pmt->hTopMenu; + } else hmenutmp = 0; + + /* try to move to the next item */ + if( !MENU_DoNextMenu( pmt, VK_RIGHT) ) + MENU_MoveSelection( pmt->hOwnerWnd, pmt->hTopMenu, ITEM_NEXT ); + + if( hmenutmp || pmt->trackFlags & TF_SUSPENDPOPUP ) + if( !MENU_SuspendPopup(pmt, WM_KEYDOWN) ) + pmt->hCurrentMenu = MENU_ShowSubPopup( pmt->hOwnerWnd, + pmt->hTopMenu, TRUE ); } } @@ -1648,86 +1834,75 @@ static void MENU_KeyRight( HWND32* hwndOwner, HMENU32* hmenu, * MENU_TrackMenu * * Menu tracking code. - * If 'x' and 'y' are not 0, we simulate a button-down event at (x,y) - * before beginning tracking. This is to help menu-bar tracking. */ static BOOL32 MENU_TrackMenu( HMENU32 hmenu, UINT32 wFlags, INT32 x, INT32 y, HWND32 hwnd, const RECT32 *lprect ) { MSG16 msg; POPUPMENU *menu; - HMENU32 hmenuCurrent = hmenu; - BOOL32 fClosed = FALSE, fRemove; - UINT32 pos; - POINT32 pt; + BOOL32 fRemove; + MTRACKER mt = { 0, hmenu, hmenu, hwnd, {x, y} }; /* control struct */ - fEndMenuCalled = FALSE; + fEndMenu = FALSE; if (!(menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ))) return FALSE; - if (x && y) - { - pt.x = x; - pt.y = y; - MENU_ButtonDown( hwnd, hmenu, &hmenuCurrent, pt ); - } - EVENT_Capture( hwnd, HTMENU ); + if (wFlags & TPM_BUTTONDOWN) MENU_ButtonDown( &mt, hmenu ); - while (!fClosed) + EVENT_Capture( mt.hOwnerWnd, HTMENU ); + + while (!fEndMenu) { + menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( mt.hCurrentMenu ); + msg.hwnd = (wFlags & TPM_ENTERIDLEEX && menu->wFlags & MF_POPUP) ? menu->hWnd : 0; + /* we have to keep the message in the queue until it's - * clear that menu loop is not over yet. - */ + * clear that menu loop is not over yet. */ - if (!MSG_InternalGetMessage( &msg, 0, hwnd, MSGF_MENU, - PM_NOREMOVE, TRUE )) - break; + if (!MSG_InternalGetMessage( &msg, msg.hwnd, mt.hOwnerWnd, + MSGF_MENU, PM_NOREMOVE, TRUE )) break; TranslateMessage16( &msg ); - CONV_POINT16TO32( &msg.pt, &pt ); + CONV_POINT16TO32( &msg.pt, &mt.pt ); fRemove = FALSE; if ((msg.message >= WM_MOUSEFIRST) && (msg.message <= WM_MOUSELAST)) { - /* Find the sub-popup for this mouse event (if any) */ + /* Find a menu for this mouse event */ - HMENU32 hsubmenu = MENU_FindMenuByCoords( hmenu, pt ); + hmenu = MENU_PtMenu( mt.hTopMenu, msg.pt ); switch(msg.message) { /* no WM_NC... messages in captured state */ - case WM_RBUTTONDBLCLK: - case WM_RBUTTONDOWN: - if (!(wFlags & TPM_RIGHTBUTTON)) break; - /* fall through */ - - case WM_LBUTTONDBLCLK: - case WM_LBUTTONDOWN: - fClosed = !MENU_ButtonDown( hwnd, hsubmenu, - &hmenuCurrent, pt ); - break; + case WM_RBUTTONDBLCLK: + case WM_RBUTTONDOWN: + if (!(wFlags & TPM_RIGHTBUTTON)) break; + /* fall through */ + case WM_LBUTTONDBLCLK: + case WM_LBUTTONDOWN: + fEndMenu |= !MENU_ButtonDown( &mt, hmenu ); + break; - case WM_RBUTTONUP: - if (!(wFlags & TPM_RIGHTBUTTON)) break; - /* fall through */ - - case WM_LBUTTONUP: - /* If outside all menus but inside lprect, ignore it */ - if (!hsubmenu && lprect && PtInRect32(lprect, pt)) break; - fClosed = !MENU_ButtonUp( hwnd, hsubmenu, - &hmenuCurrent, pt ); - fRemove = TRUE; /* Remove event even if outside menu */ - break; + case WM_RBUTTONUP: + if (!(wFlags & TPM_RIGHTBUTTON)) break; + /* fall through */ + case WM_LBUTTONUP: + /* If outside all menus but inside lprect, ignore it */ + if (hmenu || !lprect || !PtInRect32(lprect, mt.pt)) + { + fEndMenu |= !MENU_ButtonUp( &mt, hmenu ); + fRemove = TRUE; + } + break; - case WM_MOUSEMOVE: - if ((msg.wParam & MK_LBUTTON) || - ((wFlags & TPM_RIGHTBUTTON) && (msg.wParam & MK_RBUTTON))) - { - fClosed = !MENU_MouseMove( hwnd, hsubmenu, - &hmenuCurrent, pt ); - } - break; - } + case WM_MOUSEMOVE: + if ((msg.wParam & MK_LBUTTON) || ((wFlags & TPM_RIGHTBUTTON) + && (msg.wParam & MK_RBUTTON))) + { + fEndMenu |= !MENU_MouseMove( &mt, hmenu ); + } + } /* switch(msg.message) - mouse */ } else if ((msg.message >= WM_KEYFIRST) && (msg.message <= WM_KEYLAST)) { @@ -1739,39 +1914,38 @@ static BOOL32 MENU_TrackMenu( HMENU32 hmenu, UINT32 wFlags, INT32 x, INT32 y, { case VK_HOME: case VK_END: - MENU_SelectItem( hwnd, hmenuCurrent, NO_SELECTED_ITEM, FALSE ); - + MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu, + NO_SELECTED_ITEM, FALSE ); /* fall through */ case VK_UP: - MENU_SelectItemRel( hwnd, hmenuCurrent, + MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu, (msg.wParam == VK_HOME)? ITEM_NEXT : ITEM_PREV ); break; case VK_DOWN: /* If on menu bar, pull-down the menu */ - menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); - if (!(menu->wFlags & MF_POPUP) && (hmenuCurrent == hmenu)) - hmenuCurrent = MENU_ShowSubPopup( hwnd, hmenu, TRUE ); - else - MENU_SelectItemRel( hwnd, hmenuCurrent, ITEM_NEXT ); + menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( mt.hCurrentMenu ); + if (!(menu->wFlags & MF_POPUP)) + mt.hCurrentMenu = MENU_ShowSubPopup( mt.hOwnerWnd, mt.hTopMenu, TRUE ); + else /* otherwise try to move selection */ + MENU_MoveSelection( mt.hOwnerWnd, mt.hCurrentMenu, ITEM_NEXT ); break; case VK_LEFT: - MENU_KeyLeft( &hwnd, &hmenu, &hmenuCurrent ); + MENU_KeyLeft( &mt ); break; case VK_RIGHT: - MENU_KeyRight( &hwnd, &hmenu, &hmenuCurrent ); + MENU_KeyRight( &mt ); break; case VK_SPACE: case VK_RETURN: - fClosed = !MENU_ExecFocusedItem( hwnd, hmenuCurrent, - &hmenuCurrent ); + fEndMenu |= !MENU_ExecFocusedItem( &mt, mt.hCurrentMenu ); break; case VK_ESCAPE: - fClosed = TRUE; + fEndMenu = TRUE; break; default: @@ -1783,7 +1957,7 @@ static BOOL32 MENU_TrackMenu( HMENU32 hmenu, UINT32 wFlags, INT32 x, INT32 y, switch(msg.wParam) { case VK_MENU: - fClosed = TRUE; + fEndMenu = TRUE; break; } @@ -1791,80 +1965,57 @@ static BOOL32 MENU_TrackMenu( HMENU32 hmenu, UINT32 wFlags, INT32 x, INT32 y, case WM_CHAR: { + UINT32 pos; + /* Hack to avoid control chars. */ /* We will find a better way real soon... */ if ((msg.wParam <= 32) || (msg.wParam >= 127)) break; - pos = MENU_FindItemByKey( hwnd, hmenuCurrent, msg.wParam, FALSE ); - if (pos == (UINT32)-2) fClosed = TRUE; + + pos = MENU_FindItemByKey( mt.hOwnerWnd, mt.hCurrentMenu, + msg.wParam, FALSE ); + if (pos == (UINT32)-2) fEndMenu = TRUE; else if (pos == (UINT32)-1) MessageBeep32(0); else { - MENU_SelectItem( hwnd, hmenuCurrent, pos, TRUE ); - fClosed = !MENU_ExecFocusedItem( hwnd, hmenuCurrent, - &hmenuCurrent ); - + MENU_SelectItem( mt.hOwnerWnd, mt.hCurrentMenu, pos, TRUE ); + fEndMenu |= !MENU_ExecFocusedItem( &mt, mt.hCurrentMenu ); } } - break; /* WM_CHAR */ - } /* switch(msg.message) */ + break; + } /* switch(msg.message) - kbd */ } else { DispatchMessage16( &msg ); } - if (fEndMenuCalled) fClosed = TRUE; - if (!fClosed) fRemove = TRUE; - if (fRemove) /* Remove the message from the queue */ + if (!fEndMenu) fRemove = TRUE; + + /* finally remove message from the queue */ + + if (fRemove && !(mt.trackFlags & TF_SKIPREMOVE) ) PeekMessage16( &msg, 0, msg.message, msg.message, PM_REMOVE ); + else mt.trackFlags &= ~TF_SKIPREMOVE; } ReleaseCapture(); - MENU_HideSubPopups( hwnd, hmenu, FALSE ); - menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( hmenu ); - if (menu && menu->wFlags & MF_POPUP) + if( IsWindow32( mt.hOwnerWnd ) ) { - ShowWindow32( menu->hWnd, SW_HIDE ); - uSubPWndLevel = 0; + MENU_HideSubPopups( mt.hOwnerWnd, mt.hTopMenu, FALSE ); + + menu = (POPUPMENU *) USER_HEAP_LIN_ADDR( mt.hTopMenu ); + if (menu && menu->wFlags & MF_POPUP) + { + ShowWindow32( menu->hWnd, SW_HIDE ); + uSubPWndLevel = 0; + } + MENU_SelectItem( mt.hOwnerWnd, mt.hTopMenu, NO_SELECTED_ITEM, FALSE ); + SendMessage16( mt.hOwnerWnd, WM_MENUSELECT, 0, MAKELONG( 0xffff, 0 ) ); } - MENU_SelectItem( hwnd, hmenu, NO_SELECTED_ITEM, FALSE ); - SendMessage16( hwnd, WM_MENUSELECT, 0, MAKELONG( 0xffff, 0 ) ); - fEndMenuCalled = FALSE; + fEndMenu = FALSE; return TRUE; } -/*********************************************************************** - * MENU_TrackSysPopup - */ -static void MENU_TrackSysPopup( WND* pWnd ) -{ - RECT32 rect; - HMENU32 hMenu = pWnd->hSysMenu; - HDC32 hDC = 0; - - /* track the system menu like a normal popup menu */ - - if(IsMenu32(hMenu)) - { - HWND32 hWnd = pWnd->hwndSelf; - if (!(pWnd->dwStyle & WS_MINIMIZE)) - { - hDC = GetWindowDC32( hWnd ); - NC_DrawSysButton( hWnd, hDC, TRUE ); - } - NC_GetSysPopupPos( pWnd, &rect ); - MENU_InitSysMenuPopup( hMenu, pWnd->dwStyle, - pWnd->class->style); - TrackPopupMenu32( hMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON, - rect.left, rect.bottom, 0, hWnd, &rect ); - if (!(pWnd->dwStyle & WS_MINIMIZE)) - { - NC_DrawSysButton( hWnd, hDC, FALSE ); - ReleaseDC32( hWnd, hDC ); - } - } -} - /*********************************************************************** * MENU_InitTracking */ @@ -1884,19 +2035,15 @@ static BOOL32 MENU_InitTracking(HWND32 hWnd, HMENU32 hMenu) */ void MENU_TrackMouseMenuBar( WND* wndPtr, INT32 ht, POINT32 pt ) { - BOOL32 bTrackSys = ((ht == HTSYSMENU && !wndPtr->wIDmenu) || - (wndPtr->dwStyle & (WS_MINIMIZE | WS_CHILD))); HWND32 hWnd = wndPtr->hwndSelf; - HMENU32 hMenu = (bTrackSys) ? wndPtr->hSysMenu : wndPtr->wIDmenu; + HMENU32 hMenu = (ht == HTSYSMENU) ? wndPtr->hSysMenu : wndPtr->wIDmenu; if (IsMenu32(hMenu)) { MENU_InitTracking( hWnd, hMenu ); - if( bTrackSys ) - MENU_TrackSysPopup( wndPtr ); - else - MENU_TrackMenu( hMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON, - pt.x, pt.y, hWnd, NULL ); + MENU_TrackMenu( hMenu, TPM_ENTERIDLEEX | TPM_BUTTONDOWN | + TPM_LEFTALIGN | TPM_LEFTBUTTON, pt.x, pt.y, hWnd, NULL ); + SendMessage16( hWnd, WM_EXITMENULOOP, 0, 0 ); ShowCaret32(0); } @@ -1910,7 +2057,6 @@ void MENU_TrackMouseMenuBar( WND* wndPtr, INT32 ht, POINT32 pt ) */ void MENU_TrackKbdMenuBar( WND* wndPtr, UINT32 wParam, INT32 vkey) { - INT32 htMenu; UINT32 uItem = NO_SELECTED_ITEM; HMENU32 hTrackMenu; @@ -1918,54 +2064,47 @@ void MENU_TrackKbdMenuBar( WND* wndPtr, UINT32 wParam, INT32 vkey) while( wndPtr->dwStyle & WS_CHILD && !(wndPtr->dwStyle & WS_SYSMENU) ) if( !(wndPtr = wndPtr->parent) ) return; - - if( !wndPtr->wIDmenu && !(wndPtr->dwStyle & WS_SYSMENU) ) return; - if((wndPtr->dwStyle & (WS_CHILD | WS_MINIMIZE)) || !wndPtr->wIDmenu) + /* check if we have to track a system menu */ + + if( (wndPtr->dwStyle & (WS_CHILD | WS_MINIMIZE)) || + !wndPtr->wIDmenu || vkey == VK_SPACE ) { + if( !(wndPtr->dwStyle & WS_SYSMENU) ) return; hTrackMenu = wndPtr->hSysMenu; - htMenu = HTSYSMENU; + uItem = 0; + wParam |= HTSYSMENU; /* prevent item lookup */ } else - { hTrackMenu = wndPtr->wIDmenu; - htMenu = HTMENU; - } if (IsMenu32( hTrackMenu )) { MENU_InitTracking( wndPtr->hwndSelf, hTrackMenu ); - if( vkey == VK_SPACE ) - uItem = SYSMENU_SELECTED; - else if( vkey ) + if( vkey && vkey != VK_SPACE ) { uItem = MENU_FindItemByKey( wndPtr->hwndSelf, hTrackMenu, - vkey, (htMenu == HTSYSMENU) ); + vkey, (wParam & HTSYSMENU) ); if( uItem >= (UINT32)(-2) ) { if( uItem == (UINT32)(-1) ) MessageBeep32(0); - htMenu = 0; + hTrackMenu = 0; } } - switch( htMenu ) + if( hTrackMenu ) { - case HTMENU: - MENU_SelectItem( wndPtr->hwndSelf, hTrackMenu, uItem, TRUE ); - if( uItem == NO_SELECTED_ITEM ) - MENU_SelectItemRel( wndPtr->hwndSelf, hTrackMenu, ITEM_NEXT ); - else - PostMessage16( wndPtr->hwndSelf, WM_KEYDOWN, VK_DOWN, 0L ); + MENU_SelectItem( wndPtr->hwndSelf, hTrackMenu, uItem, TRUE ); - MENU_TrackMenu( hTrackMenu, TPM_LEFTALIGN | TPM_LEFTBUTTON, - 0, 0, wndPtr->hwndSelf, NULL ); - break; + if( uItem == NO_SELECTED_ITEM ) + MENU_MoveSelection( wndPtr->hwndSelf, hTrackMenu, ITEM_NEXT ); + else if( vkey ) + PostMessage16( wndPtr->hwndSelf, WM_KEYDOWN, VK_DOWN, 0L ); - case HTSYSMENU: - MENU_TrackSysPopup( wndPtr ); + MENU_TrackMenu( hTrackMenu, TPM_ENTERIDLEEX | TPM_LEFTALIGN | TPM_LEFTBUTTON, + 0, 0, wndPtr->hwndSelf, NULL ); } - SendMessage16( wndPtr->hwndSelf, WM_EXITMENULOOP, 0, 0 ); ShowCaret32(0); } @@ -1996,7 +2135,7 @@ BOOL32 TrackPopupMenu32( HMENU32 hMenu, UINT32 wFlags, INT32 x, INT32 y, HideCaret32(0); if (MENU_ShowPopup( hWnd, hMenu, 0, x, y, 0, 0 )) - ret = MENU_TrackMenu( hMenu, wFlags, 0, 0, hWnd, lpRect ); + ret = MENU_TrackMenu( hMenu, wFlags & ~TPM_INTERNAL, 0, 0, hWnd, lpRect ); ShowCaret32(0); return ret; } @@ -2014,10 +2153,14 @@ BOOL32 TrackPopupMenuEx( HMENU32 hMenu, UINT32 wFlags, INT32 x, INT32 y, /*********************************************************************** * PopupMenuWndProc + * + * NOTE: Windows has totally different (and undocumented) popup wndproc. */ LRESULT PopupMenuWndProc( HWND32 hwnd, UINT32 message, WPARAM32 wParam, LPARAM lParam ) { + WND* wndPtr = WIN_FindWndPtr(hwnd); + switch(message) { case WM_CREATE: @@ -2039,21 +2182,45 @@ LRESULT PopupMenuWndProc( HWND32 hwnd, UINT32 message, WPARAM32 wParam, EndPaint32( hwnd, &ps ); return 0; } + case WM_ERASEBKGND: + return 1; case WM_DESTROY: - /* zero out global pointer in case system popup - * was destroyed by AppExit - */ - if( hwnd == pTopPWnd->hwndSelf ) - { pTopPWnd = NULL; uSubPWndLevel = 0; } - else - uSubPWndLevel--; - break; + /* zero out global pointer in case resident popup window + * was somehow destroyed. */ - case WM_USER: - if (wParam) SetWindowLong32A( hwnd, 0, (HMENU16)wParam ); + if( hwnd == pTopPopupWnd->hwndSelf ) + { + dprintf_menu(stddeb,"resident popup destroyed!\n"); + + pTopPopupWnd = NULL; + uSubPWndLevel = 0; + } + else + uSubPWndLevel--; + break; + + case WM_SHOWWINDOW: + + if( wParam ) + { + if( !(*(HMENU32*)wndPtr->wExtra) ) + fprintf(stderr,"MenuWndProc: no menu to display\n"); + } + else + *(HMENU32*)wndPtr->wExtra = 0; + break; + + case MM_SETMENUHANDLE: + + *(HMENU32*)wndPtr->wExtra = (HMENU32)wParam; break; + + case MM_GETMENUHANDLE: + + return *(HMENU32*)wndPtr->wExtra; + default: return DefWindowProc32A( hwnd, message, wParam, lParam ); } @@ -2095,9 +2262,11 @@ BOOL16 ChangeMenu16( HMENU16 hMenu, UINT16 pos, SEGPTR data, hMenu, pos, (DWORD)data, id, flags ); if (flags & MF_APPEND) return AppendMenu16( hMenu, flags & ~MF_APPEND, id, data ); + /* FIXME: Word passes the item id in 'pos' and 0 or 0xffff as id */ /* for MF_DELETE. We should check the parameters for all others */ /* MF_* actions also (anybody got a doc on ChangeMenu?). */ + if (flags & MF_DELETE) return DeleteMenu16(hMenu, pos, flags & ~MF_DELETE); if (flags & MF_CHANGE) return ModifyMenu16(hMenu, pos, flags & ~MF_CHANGE, id, data ); @@ -2425,8 +2594,7 @@ BOOL32 InsertMenu32A( HMENU32 hMenu, UINT32 pos, UINT32 flags, if (flags & MF_POPUP) /* Set the MF_POPUP flag on the popup-menu */ ((POPUPMENU *)USER_HEAP_LIN_ADDR((HMENU16)id))->wFlags |= MF_POPUP; - item->hCheckBit = hStdCheck; - item->hUnCheckBit = 0; + item->pCB = NULL; return TRUE; } @@ -2500,8 +2668,8 @@ BOOL32 RemoveMenu32( HMENU32 hMenu, UINT32 nPos, UINT32 wFlags ) /* Remove item */ - if (IS_STRING_ITEM(item->item_flags) && item->text) - HeapFree( SystemHeap, 0, item->text ); + MENU_FreeItemData( item ); + if (--menu->nItems == 0) { HeapFree( SystemHeap, 0, menu->items ); @@ -2658,15 +2826,16 @@ BOOL32 SetMenuItemBitmaps32( HMENU32 hMenu, UINT32 nPos, UINT32 wFlags, if (!hNewCheck && !hNewUnCheck) { - /* If both are NULL, restore default bitmaps */ - item->hCheckBit = hStdCheck; - item->hUnCheckBit = 0; + if( item->pCB ) HeapFree( SystemHeap, 0, item->pCB ); + item->pCB = NULL; item->item_flags &= ~MF_USECHECKBITMAPS; } else /* Install new bitmaps */ { - item->hCheckBit = hNewCheck; - item->hUnCheckBit = hNewUnCheck; + if( item->pCB == NULL ) + item->pCB = HeapAlloc( SystemHeap, 0, sizeof(CBITMAPS)); + item->pCB->hCheckBit = hNewCheck; + item->pCB->hUnCheckBit = hNewUnCheck; item->item_flags |= MF_USECHECKBITMAPS; } return TRUE; @@ -2719,35 +2888,42 @@ BOOL16 DestroyMenu16( HMENU16 hMenu ) */ BOOL32 DestroyMenu32( HMENU32 hMenu ) { - LPPOPUPMENU lppop; dprintf_menu(stddeb,"DestroyMenu(%04x)\n", hMenu); - if (hMenu == 0) return FALSE; - /* Silently ignore attempts to destroy default system menu */ - if (hMenu == MENU_DefSysMenu) return TRUE; - lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu); - if (!lppop || (lppop->wMagic != MENU_MAGIC)) return FALSE; - lppop->wMagic = 0; /* Mark it as destroyed */ - if ((lppop->wFlags & MF_POPUP) && - lppop->hWnd && - (!pTopPWnd || (lppop->hWnd != pTopPWnd->hwndSelf))) - DestroyWindow32( lppop->hWnd ); + /* Silently ignore attempts to destroy default system popup */ - if (lppop->items) + if (hMenu && hMenu != MENU_DefSysPopup) { - int i; - MENUITEM *item = lppop->items; - for (i = lppop->nItems; i > 0; i--, item++) - { - if (item->item_flags & MF_POPUP) - DestroyMenu32( (HMENU32)item->item_id ); - if (IS_STRING_ITEM(item->item_flags) && item->text) - HeapFree( SystemHeap, 0, item->text ); - } - HeapFree( SystemHeap, 0, lppop->items ); + LPPOPUPMENU lppop = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu); + + if( pTopPopupWnd && (hMenu == *(HMENU32*)pTopPopupWnd->wExtra) ) + *(UINT32*)pTopPopupWnd->wExtra = 0; + + if (lppop && (lppop->wMagic == MENU_MAGIC)) + { + lppop->wMagic = 0; /* Mark it as destroyed */ + + if ((lppop->wFlags & MF_POPUP) && lppop->hWnd && + (!pTopPopupWnd || (lppop->hWnd != pTopPopupWnd->hwndSelf))) + DestroyWindow32( lppop->hWnd ); + + if (lppop->items) /* recursively destroy submenus */ + { + int i; + MENUITEM *item = lppop->items; + for (i = lppop->nItems; i > 0; i--, item++) + { + if (item->item_flags & MF_POPUP) + DestroyMenu32( (HMENU32)item->item_id ); + MENU_FreeItemData( item ); + } + HeapFree( SystemHeap, 0, lppop->items ); + } + USER_HEAP_FREE( hMenu ); + } + else return FALSE; } - USER_HEAP_FREE( hMenu ); - return TRUE; + return (hMenu != MENU_DefSysPopup); } @@ -2766,17 +2942,32 @@ HMENU16 GetSystemMenu16( HWND16 hWnd, BOOL16 bRevert ) HMENU32 GetSystemMenu32( HWND32 hWnd, BOOL32 bRevert ) { WND *wndPtr = WIN_FindWndPtr( hWnd ); - if (!wndPtr) return 0; - if (!wndPtr->hSysMenu || (wndPtr->hSysMenu == MENU_DefSysMenu)) + if (wndPtr) { - wndPtr->hSysMenu = MENU_CopySysMenu(); - return wndPtr->hSysMenu; + if( wndPtr->hSysMenu ) + { + if( bRevert ) + { + DestroyMenu32(wndPtr->hSysMenu); + wndPtr->hSysMenu = 0; + } + else + { + POPUPMENU *menu = (POPUPMENU*) + USER_HEAP_LIN_ADDR(wndPtr->hSysMenu); + if( menu->items[0].item_id == MENU_DefSysPopup ) + menu->items[0].item_id = MENU_CopySysPopup(); + } + } + + if(!wndPtr->hSysMenu && (wndPtr->dwStyle & WS_SYSMENU) ) + wndPtr->hSysMenu = MENU_GetSysMenu( hWnd, (HMENU32)(-1) ); + + if( wndPtr->hSysMenu ) + return GetSubMenu16(wndPtr->hSysMenu, 0); } - if (!bRevert) return wndPtr->hSysMenu; - if (wndPtr->hSysMenu) DestroyMenu32(wndPtr->hSysMenu); - wndPtr->hSysMenu = MENU_CopySysMenu(); - return wndPtr->hSysMenu; + return 0; } @@ -2794,13 +2985,15 @@ BOOL16 SetSystemMenu16( HWND16 hwnd, HMENU16 hMenu ) */ BOOL32 SetSystemMenu32( HWND32 hwnd, HMENU32 hMenu ) { - WND *wndPtr; + WND *wndPtr = WIN_FindWndPtr(hwnd); - if (!(wndPtr = WIN_FindWndPtr(hwnd))) return FALSE; - if (wndPtr->hSysMenu && (wndPtr->hSysMenu != MENU_DefSysMenu)) - DestroyMenu32( wndPtr->hSysMenu ); - wndPtr->hSysMenu = hMenu; - return TRUE; + if (wndPtr) + { + if (wndPtr->hSysMenu) DestroyMenu32( wndPtr->hSysMenu ); + wndPtr->hSysMenu = MENU_GetSysMenu( hwnd, hMenu ); + return TRUE; + } + return FALSE; } @@ -2810,7 +3003,8 @@ BOOL32 SetSystemMenu32( HWND32 hwnd, HMENU32 hMenu ) HMENU16 GetMenu16( HWND16 hWnd ) { WND * wndPtr = WIN_FindWndPtr(hWnd); - if (wndPtr) return (HMENU16)wndPtr->wIDmenu; + if (wndPtr && !(wndPtr->dwStyle & WS_CHILD)) + return (HMENU16)wndPtr->wIDmenu; return 0; } @@ -2821,7 +3015,8 @@ HMENU16 GetMenu16( HWND16 hWnd ) HMENU32 GetMenu32( HWND32 hWnd ) { WND * wndPtr = WIN_FindWndPtr(hWnd); - if (wndPtr) return (HMENU32)wndPtr->wIDmenu; + if (wndPtr && !(wndPtr->dwStyle & WS_CHILD)) + return (HMENU32)wndPtr->wIDmenu; return 0; } @@ -2840,23 +3035,30 @@ BOOL16 SetMenu16( HWND16 hWnd, HMENU16 hMenu ) */ BOOL32 SetMenu32( HWND32 hWnd, HMENU32 hMenu ) { - LPPOPUPMENU lpmenu; WND * wndPtr = WIN_FindWndPtr(hWnd); - if (!wndPtr) return FALSE; + dprintf_menu(stddeb,"SetMenu(%04x, %04x);\n", hWnd, hMenu); - if (GetCapture32() == hWnd) ReleaseCapture(); - wndPtr->wIDmenu = (UINT32)hMenu; - if (hMenu != 0) + + if (wndPtr && !(wndPtr->dwStyle & WS_CHILD)) { - if (!(lpmenu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return FALSE; - lpmenu->hWnd = hWnd; - lpmenu->wFlags &= ~MF_POPUP; /* Can't be a popup */ - lpmenu->Height = 0; /* Make sure we recalculate the size */ - } - if (IsWindowVisible32(hWnd)) - SetWindowPos32( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | + if (GetCapture32() == hWnd) ReleaseCapture(); + + wndPtr->wIDmenu = (UINT32)hMenu; + if (hMenu != 0) + { + LPPOPUPMENU lpmenu; + + if (!(lpmenu = (LPPOPUPMENU) USER_HEAP_LIN_ADDR(hMenu))) return FALSE; + lpmenu->hWnd = hWnd; + lpmenu->wFlags &= ~MF_POPUP; /* Can't be a popup */ + lpmenu->Height = 0; /* Make sure we recalculate the size */ + } + if (IsWindowVisible32(hWnd)) + SetWindowPos32( hWnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED ); - return TRUE; + return TRUE; + } + return FALSE; } @@ -2919,8 +3121,7 @@ BOOL32 DrawMenuBar32( HWND32 hWnd ) */ void EndMenu(void) { - /* FIXME: this won't work when we have multiple tasks... */ - fEndMenuCalled = TRUE; + fEndMenu = TRUE; } diff --git a/controls/widgets.c b/controls/widgets.c index 04769d922d..729bd6dca2 100644 --- a/controls/widgets.c +++ b/controls/widgets.c @@ -76,7 +76,7 @@ static WNDCLASS32A WIDGETS_BuiltinClasses32[BIC32_NB_CLASSES] = ComboLBWndProc, 0, sizeof(void *), 0, 0, IDC_ARROW, 0, 0, "ComboLBox" }, /* BIC32_POPUPMENU */ { CS_GLOBALCLASS | CS_SAVEBITS, PopupMenuWndProc, - 0, sizeof(HMENU32), 0, 0, IDC_ARROW, 0, 0, POPUPMENU_CLASS_NAME }, + 0, sizeof(HMENU32), 0, 0, IDC_ARROW, NULL_BRUSH, 0, POPUPMENU_CLASS_NAME }, /* BIC32_SCROLL */ { CS_GLOBALCLASS | CS_DBLCLKS | CS_VREDRAW | CS_HREDRAW | CS_PARENTDC, ScrollBarWndProc, 0, sizeof(SCROLLBAR_INFO), 0, 0, IDC_ARROW, 0, 0, "ScrollBar"}, diff --git a/debugger/db_disasm.c b/debugger/db_disasm.c index 32e0d44dcb..715ddbe6df 100644 --- a/debugger/db_disasm.c +++ b/debugger/db_disasm.c @@ -1531,7 +1531,7 @@ void DEBUG_Disasm( DBG_ADDR *addr, int display ) } if (seg) - fprintf(stderr,"%s:%d",seg, displ); + fprintf(stderr,"%s:0x%x",seg, displ); else db_task_printsym(displ, short_addr ? WORD : LONG); break; diff --git a/documentation/winsock b/documentation/winsock index d8c497eb68..a6e41bf485 100644 --- a/documentation/winsock +++ b/documentation/winsock @@ -1,3 +1,5 @@ +----- Information in this file is obsolete. ----- + Winsock Platform 1. diff --git a/files/file.c b/files/file.c index 641957f776..1ff6c2167b 100644 --- a/files/file.c +++ b/files/file.c @@ -981,10 +981,17 @@ LONG _hwrite32( HFILE32 hFile, LPCSTR buffer, LONG count ) if (count == 0) /* Expand or truncate at current position */ result = ftruncate( file->unix_handle, lseek( file->unix_handle, 0, SEEK_CUR ) ); - else + else for (;;) + { result = write( file->unix_handle, buffer, count ); + if (result != -1) break; + if (errno != EINTR) + { + FILE_SetDosError(); + break; + } + } - if (result == -1) FILE_SetDosError(); FILE_ReleaseFile( file ); return result; } diff --git a/graphics/wing.c b/graphics/wing.c index aed0e39b2c..90321e523e 100644 --- a/graphics/wing.c +++ b/graphics/wing.c @@ -20,6 +20,8 @@ #include "stddebug.h" #include "debug.h" +extern void CLIPPING_UpdateGCRegion(DC* ); + typedef enum WING_DITHER_TYPE { WING_DISPERSED_4x4, WING_DISPERSED_8x8, WING_CLUSTERED_4x4 diff --git a/graphics/x11drv/bitmap.c b/graphics/x11drv/bitmap.c index b302248d3c..33bf1f69b4 100644 --- a/graphics/x11drv/bitmap.c +++ b/graphics/x11drv/bitmap.c @@ -16,6 +16,8 @@ #include "stddebug.h" #include "debug.h" +extern void CLIPPING_UpdateGCRegion(DC* ); + /*********************************************************************** * X11DRV_BITMAP_Init */ diff --git a/graphics/x11drv/font.c b/graphics/x11drv/font.c index 0d4e2c6791..7826db64c9 100644 --- a/graphics/x11drv/font.c +++ b/graphics/x11drv/font.c @@ -332,6 +332,9 @@ BOOL32 X11DRV_GetTextMetrics(DC *dc, TEXTMETRIC32A *metrics) /*********************************************************************** * X11DRV_FONT_SelectObject + * + * FIXME: the fonts should not be cached by hfont only, because + * metrics may be different in an other DC. */ HFONT32 X11DRV_FONT_SelectObject( DC * dc, HFONT32 hfont, FONTOBJ * font ) { diff --git a/if1632/mmsystem.spec b/if1632/mmsystem.spec index 482ff50bed..c0f75d171b 100644 --- a/if1632/mmsystem.spec +++ b/if1632/mmsystem.spec @@ -55,7 +55,7 @@ type win16 401 pascal WAVEOUTGETNUMDEVS() waveOutGetNumDevs 402 pascal WAVEOUTGETDEVCAPS(word segptr word) waveOutGetDevCaps 403 pascal WAVEOUTGETERRORTEXT(word ptr word) waveOutGetErrorText -404 pascal WAVEOUTOPEN(ptr word ptr long long long) waveOutOpen +404 pascal WAVEOUTOPEN(ptr word segptr long long long) waveOutOpen 405 pascal WAVEOUTCLOSE(word) waveOutClose 406 pascal WAVEOUTPREPAREHEADER(word segptr word) waveOutPrepareHeader 407 pascal WAVEOUTUNPREPAREHEADER(word segptr word) waveOutUnprepareHeader @@ -76,7 +76,7 @@ type win16 501 pascal WAVEINGETNUMDEVS() waveInGetNumDevs 502 pascal WAVEINGETDEVCAPS(word segptr word) waveInGetDevCaps 503 pascal WAVEINGETERRORTEXT(word ptr word) waveInGetErrorText -504 pascal WAVEINOPEN(ptr word ptr long long long) waveInOpen +504 pascal WAVEINOPEN(ptr word segptr long long long) waveInOpen 505 pascal WAVEINCLOSE(word) waveInClose 506 pascal WAVEINPREPAREHEADER(word segptr word) waveInPrepareHeader 507 pascal WAVEINUNPREPAREHEADER(word segptr word) waveInUnprepareHeader diff --git a/if1632/winsock.spec b/if1632/winsock.spec index fea16ef202..3961ed710d 100644 --- a/if1632/winsock.spec +++ b/if1632/winsock.spec @@ -50,7 +50,7 @@ type win16 107 pascal16 WSAAsyncGetServByName(word word ptr ptr segptr word) WSAAsyncGetServByName 108 pascal16 WSACancelAsyncRequest(word) WSACancelAsyncRequest -109 pascal16 WSASetBlockingHook() WSASetBlockingHook +109 pascal16 WSASetBlockingHook(segptr) WSASetBlockingHook16 110 pascal16 WSAUnhookBlockingHook() WSAUnhookBlockingHook 111 pascal16 WSAGetLastError() WSAGetLastError 112 pascal WSASetLastError(word) WSASetLastError diff --git a/if1632/wsock32.spec b/if1632/wsock32.spec index f8686901c7..c7597e291d 100644 --- a/if1632/wsock32.spec +++ b/if1632/wsock32.spec @@ -40,7 +40,7 @@ base 0 106 stub WSAAsyncGetServByPort 107 stub WSAAsyncGetServByName 108 stub WSACancelAsyncRequest -109 stub WSASetBlockingHook +109 stdcall WSASetBlockingHook(ptr) WSASetBlockingHook32 110 stub WSAUnhookBlockingHook 111 stub WSAGetLastError 112 stub WSASetLastError diff --git a/include/bitmap.h b/include/bitmap.h index 72dc215966..3b8bfe2097 100644 --- a/include/bitmap.h +++ b/include/bitmap.h @@ -42,7 +42,7 @@ extern GC BITMAP_monoGC, BITMAP_colorGC; #define XCREATEIMAGE(image,width,height,bpp) \ { \ - int width_bytes = DIB_GetImageWidthBytesX11( (width), (bpp) ); \ + int width_bytes = DIB_GetXImageWidthBytes( (width), (bpp) ); \ (image) = XCreateImage(display, DefaultVisualOfScreen(screen), \ (bpp), ZPixmap, 0, xmalloc( (height)*width_bytes ),\ (width), (height), 32, width_bytes ); \ @@ -55,8 +55,8 @@ extern INT32 BITMAP_GetObject32( BITMAPOBJ * bmp, INT32 count, LPVOID buffer ); extern BOOL32 BITMAP_DeleteObject( HBITMAP16 hbitmap, BITMAPOBJ * bitmap ); /* objects/dib.c */ -extern int DIB_GetImageWidthBytes( int width, int depth ); -extern int DIB_GetImageWidthBytesX11( int width, int depth ); +extern int DIB_GetDIBWidthBytes( int width, int depth ); +extern int DIB_GetXImageWidthBytes( int width, int depth ); extern int DIB_BitmapInfoSize( BITMAPINFO * info, WORD coloruse ); /* objects/oembitmap.c */ diff --git a/include/color.h b/include/color.h index 1bd269bcea..94be6f31f0 100644 --- a/include/color.h +++ b/include/color.h @@ -8,6 +8,7 @@ #define COLOR_VIRTUAL 0x0002 /* no mapping needed - pixel == pixel color */ #define COLOR_PRIVATE 0x1000 /* private colormap, identity mapping */ +#define COLOR_WHITESET 0x2000 #define PC_SYS_USED 0x80 /* palentry is used (both system and logical) */ #define PC_SYS_RESERVED 0x40 /* system palentry is not to be mapped to */ @@ -22,6 +23,7 @@ extern BOOL32 COLOR_IsSolid( COLORREF color ); extern Colormap COLOR_GetColormap(); extern UINT16 COLOR_GetSystemPaletteSize(); extern UINT16 COLOR_GetSystemPaletteFlags(); +extern BOOL32 COLOR_GetMonoPlane( int* ); extern COLORREF COLOR_LookupNearestColor( PALETTEENTRY*, int, COLORREF ); extern int COLOR_PaletteLookupPixel( PALETTEENTRY*, int, int* , COLORREF, BOOL32 ); diff --git a/include/debug.h b/include/debug.h index dd40d37704..55a01eab6f 100644 --- a/include/debug.h +++ b/include/debug.h @@ -53,6 +53,7 @@ #undef DEBUG_MESSAGE #undef DEBUG_METAFILE #undef DEBUG_MIDI +#undef DEBUG_MMAUX #undef DEBUG_MMIO #undef DEBUG_MMSYS #undef DEBUG_MMTIME @@ -135,6 +136,7 @@ #define DEBUG_MESSAGE #define DEBUG_METAFILE #define DEBUG_MIDI +#define DEBUG_MMAUX #define DEBUG_MMIO #define DEBUG_MMSYS #define DEBUG_MMTIME @@ -407,6 +409,11 @@ short debug_msg_enabled[]={ #else 0, #endif +#ifdef DEBUG_MMAUX + 1, +#else + 0, +#endif #ifdef DEBUG_MMIO 1, #else @@ -1186,8 +1193,21 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_mmio if(!debug_msg_enabled[47]) ; else fprintf -#define debugging_mmio debug_msg_enabled[47] +#define dprintf_mmaux if(!debug_msg_enabled[47]) ; else fprintf +#define debugging_mmaux debug_msg_enabled[47] +#else +#ifdef DEBUG_MMAUX +#define dprintf_mmaux fprintf +#define debugging_mmaux 1 +#else +#define dprintf_mmaux while(0) fprintf +#define debugging_mmaux 0 +#endif +#endif + +#ifdef DEBUG_RUNTIME +#define dprintf_mmio if(!debug_msg_enabled[48]) ; else fprintf +#define debugging_mmio debug_msg_enabled[48] #else #ifdef DEBUG_MMIO #define dprintf_mmio fprintf @@ -1199,8 +1219,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_mmsys if(!debug_msg_enabled[48]) ; else fprintf -#define debugging_mmsys debug_msg_enabled[48] +#define dprintf_mmsys if(!debug_msg_enabled[49]) ; else fprintf +#define debugging_mmsys debug_msg_enabled[49] #else #ifdef DEBUG_MMSYS #define dprintf_mmsys fprintf @@ -1212,8 +1232,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_mmtime if(!debug_msg_enabled[49]) ; else fprintf -#define debugging_mmtime debug_msg_enabled[49] +#define dprintf_mmtime if(!debug_msg_enabled[50]) ; else fprintf +#define debugging_mmtime debug_msg_enabled[50] #else #ifdef DEBUG_MMTIME #define dprintf_mmtime fprintf @@ -1225,8 +1245,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_module if(!debug_msg_enabled[50]) ; else fprintf -#define debugging_module debug_msg_enabled[50] +#define dprintf_module if(!debug_msg_enabled[51]) ; else fprintf +#define debugging_module debug_msg_enabled[51] #else #ifdef DEBUG_MODULE #define dprintf_module fprintf @@ -1238,8 +1258,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_msg if(!debug_msg_enabled[51]) ; else fprintf -#define debugging_msg debug_msg_enabled[51] +#define dprintf_msg if(!debug_msg_enabled[52]) ; else fprintf +#define debugging_msg debug_msg_enabled[52] #else #ifdef DEBUG_MSG #define dprintf_msg fprintf @@ -1251,8 +1271,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_nonclient if(!debug_msg_enabled[52]) ; else fprintf -#define debugging_nonclient debug_msg_enabled[52] +#define dprintf_nonclient if(!debug_msg_enabled[53]) ; else fprintf +#define debugging_nonclient debug_msg_enabled[53] #else #ifdef DEBUG_NONCLIENT #define dprintf_nonclient fprintf @@ -1264,8 +1284,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_ole if(!debug_msg_enabled[53]) ; else fprintf -#define debugging_ole debug_msg_enabled[53] +#define dprintf_ole if(!debug_msg_enabled[54]) ; else fprintf +#define debugging_ole debug_msg_enabled[54] #else #ifdef DEBUG_OLE #define dprintf_ole fprintf @@ -1277,8 +1297,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_palette if(!debug_msg_enabled[54]) ; else fprintf -#define debugging_palette debug_msg_enabled[54] +#define dprintf_palette if(!debug_msg_enabled[55]) ; else fprintf +#define debugging_palette debug_msg_enabled[55] #else #ifdef DEBUG_PALETTE #define dprintf_palette fprintf @@ -1290,8 +1310,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_profile if(!debug_msg_enabled[55]) ; else fprintf -#define debugging_profile debug_msg_enabled[55] +#define dprintf_profile if(!debug_msg_enabled[56]) ; else fprintf +#define debugging_profile debug_msg_enabled[56] #else #ifdef DEBUG_PROFILE #define dprintf_profile fprintf @@ -1303,8 +1323,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_prop if(!debug_msg_enabled[56]) ; else fprintf -#define debugging_prop debug_msg_enabled[56] +#define dprintf_prop if(!debug_msg_enabled[57]) ; else fprintf +#define debugging_prop debug_msg_enabled[57] #else #ifdef DEBUG_PROP #define dprintf_prop fprintf @@ -1316,8 +1336,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_reg if(!debug_msg_enabled[57]) ; else fprintf -#define debugging_reg debug_msg_enabled[57] +#define dprintf_reg if(!debug_msg_enabled[58]) ; else fprintf +#define debugging_reg debug_msg_enabled[58] #else #ifdef DEBUG_REG #define dprintf_reg fprintf @@ -1329,8 +1349,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_region if(!debug_msg_enabled[58]) ; else fprintf -#define debugging_region debug_msg_enabled[58] +#define dprintf_region if(!debug_msg_enabled[59]) ; else fprintf +#define debugging_region debug_msg_enabled[59] #else #ifdef DEBUG_REGION #define dprintf_region fprintf @@ -1342,8 +1362,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_relay if(!debug_msg_enabled[59]) ; else fprintf -#define debugging_relay debug_msg_enabled[59] +#define dprintf_relay if(!debug_msg_enabled[60]) ; else fprintf +#define debugging_relay debug_msg_enabled[60] #else #ifdef DEBUG_RELAY #define dprintf_relay fprintf @@ -1355,8 +1375,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_resource if(!debug_msg_enabled[60]) ; else fprintf -#define debugging_resource debug_msg_enabled[60] +#define dprintf_resource if(!debug_msg_enabled[61]) ; else fprintf +#define debugging_resource debug_msg_enabled[61] #else #ifdef DEBUG_RESOURCE #define dprintf_resource fprintf @@ -1368,8 +1388,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_scroll if(!debug_msg_enabled[61]) ; else fprintf -#define debugging_scroll debug_msg_enabled[61] +#define dprintf_scroll if(!debug_msg_enabled[62]) ; else fprintf +#define debugging_scroll debug_msg_enabled[62] #else #ifdef DEBUG_SCROLL #define dprintf_scroll fprintf @@ -1381,8 +1401,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_selector if(!debug_msg_enabled[62]) ; else fprintf -#define debugging_selector debug_msg_enabled[62] +#define dprintf_selector if(!debug_msg_enabled[63]) ; else fprintf +#define debugging_selector debug_msg_enabled[63] #else #ifdef DEBUG_SELECTOR #define dprintf_selector fprintf @@ -1394,8 +1414,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_sem if(!debug_msg_enabled[63]) ; else fprintf -#define debugging_sem debug_msg_enabled[63] +#define dprintf_sem if(!debug_msg_enabled[64]) ; else fprintf +#define debugging_sem debug_msg_enabled[64] #else #ifdef DEBUG_SEM #define dprintf_sem fprintf @@ -1407,8 +1427,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_sendmsg if(!debug_msg_enabled[64]) ; else fprintf -#define debugging_sendmsg debug_msg_enabled[64] +#define dprintf_sendmsg if(!debug_msg_enabled[65]) ; else fprintf +#define debugging_sendmsg debug_msg_enabled[65] #else #ifdef DEBUG_SENDMSG #define dprintf_sendmsg fprintf @@ -1420,8 +1440,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_shm if(!debug_msg_enabled[65]) ; else fprintf -#define debugging_shm debug_msg_enabled[65] +#define dprintf_shm if(!debug_msg_enabled[66]) ; else fprintf +#define debugging_shm debug_msg_enabled[66] #else #ifdef DEBUG_SHM #define dprintf_shm fprintf @@ -1433,8 +1453,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_stress if(!debug_msg_enabled[66]) ; else fprintf -#define debugging_stress debug_msg_enabled[66] +#define dprintf_stress if(!debug_msg_enabled[67]) ; else fprintf +#define debugging_stress debug_msg_enabled[67] #else #ifdef DEBUG_STRESS #define dprintf_stress fprintf @@ -1446,8 +1466,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_string if(!debug_msg_enabled[67]) ; else fprintf -#define debugging_string debug_msg_enabled[67] +#define dprintf_string if(!debug_msg_enabled[68]) ; else fprintf +#define debugging_string debug_msg_enabled[68] #else #ifdef DEBUG_STRING #define dprintf_string fprintf @@ -1459,8 +1479,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_task if(!debug_msg_enabled[68]) ; else fprintf -#define debugging_task debug_msg_enabled[68] +#define dprintf_task if(!debug_msg_enabled[69]) ; else fprintf +#define debugging_task debug_msg_enabled[69] #else #ifdef DEBUG_TASK #define dprintf_task fprintf @@ -1472,8 +1492,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_text if(!debug_msg_enabled[69]) ; else fprintf -#define debugging_text debug_msg_enabled[69] +#define dprintf_text if(!debug_msg_enabled[70]) ; else fprintf +#define debugging_text debug_msg_enabled[70] #else #ifdef DEBUG_TEXT #define dprintf_text fprintf @@ -1485,8 +1505,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_timer if(!debug_msg_enabled[70]) ; else fprintf -#define debugging_timer debug_msg_enabled[70] +#define dprintf_timer if(!debug_msg_enabled[71]) ; else fprintf +#define debugging_timer debug_msg_enabled[71] #else #ifdef DEBUG_TIMER #define dprintf_timer fprintf @@ -1498,8 +1518,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_toolhelp if(!debug_msg_enabled[71]) ; else fprintf -#define debugging_toolhelp debug_msg_enabled[71] +#define dprintf_toolhelp if(!debug_msg_enabled[72]) ; else fprintf +#define debugging_toolhelp debug_msg_enabled[72] #else #ifdef DEBUG_TOOLHELP #define dprintf_toolhelp fprintf @@ -1511,8 +1531,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_ver if(!debug_msg_enabled[72]) ; else fprintf -#define debugging_ver debug_msg_enabled[72] +#define dprintf_ver if(!debug_msg_enabled[73]) ; else fprintf +#define debugging_ver debug_msg_enabled[73] #else #ifdef DEBUG_VER #define dprintf_ver fprintf @@ -1524,8 +1544,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_virtual if(!debug_msg_enabled[73]) ; else fprintf -#define debugging_virtual debug_msg_enabled[73] +#define dprintf_virtual if(!debug_msg_enabled[74]) ; else fprintf +#define debugging_virtual debug_msg_enabled[74] #else #ifdef DEBUG_VIRTUAL #define dprintf_virtual fprintf @@ -1537,8 +1557,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_vxd if(!debug_msg_enabled[74]) ; else fprintf -#define debugging_vxd debug_msg_enabled[74] +#define dprintf_vxd if(!debug_msg_enabled[75]) ; else fprintf +#define debugging_vxd debug_msg_enabled[75] #else #ifdef DEBUG_VXD #define dprintf_vxd fprintf @@ -1550,8 +1570,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_win if(!debug_msg_enabled[75]) ; else fprintf -#define debugging_win debug_msg_enabled[75] +#define dprintf_win if(!debug_msg_enabled[76]) ; else fprintf +#define debugging_win debug_msg_enabled[76] #else #ifdef DEBUG_WIN #define dprintf_win fprintf @@ -1563,8 +1583,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_win16drv if(!debug_msg_enabled[76]) ; else fprintf -#define debugging_win16drv debug_msg_enabled[76] +#define dprintf_win16drv if(!debug_msg_enabled[77]) ; else fprintf +#define debugging_win16drv debug_msg_enabled[77] #else #ifdef DEBUG_WIN16DRV #define dprintf_win16drv fprintf @@ -1576,8 +1596,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_win32 if(!debug_msg_enabled[77]) ; else fprintf -#define debugging_win32 debug_msg_enabled[77] +#define dprintf_win32 if(!debug_msg_enabled[78]) ; else fprintf +#define debugging_win32 debug_msg_enabled[78] #else #ifdef DEBUG_WIN32 #define dprintf_win32 fprintf @@ -1589,8 +1609,8 @@ extern short debug_msg_enabled[]; #endif #ifdef DEBUG_RUNTIME -#define dprintf_winsock if(!debug_msg_enabled[78]) ; else fprintf -#define debugging_winsock debug_msg_enabled[78] +#define dprintf_winsock if(!debug_msg_enabled[79]) ; else fprintf +#define debugging_winsock debug_msg_enabled[79] #else #ifdef DEBUG_WINSOCK #define dprintf_winsock fprintf @@ -1652,6 +1672,7 @@ static char *debug_msg_name[] = { "message", "metafile", "midi", + "mmaux", "mmio", "mmsys", "mmtime", diff --git a/include/graphics.h b/include/graphics.h index 6d933fde77..00d963a156 100644 --- a/include/graphics.h +++ b/include/graphics.h @@ -18,7 +18,7 @@ extern void GRAPH_DrawRectangle( HDC32 hdc, INT32 x, INT32 y, INT32 width, INT32 height, HPEN32 hPen); extern BOOL32 GRAPH_DrawBitmap( HDC32 hdc, HBITMAP32 hbitmap, INT32 xdest, INT32 ydest, INT32 xsrc, - INT32 ysrc, INT32 width, INT32 height ); + INT32 ysrc, INT32 width, INT32 height, BOOL32 bMono ); extern BOOL32 GRAPH_SelectClipMask( HDC32 hdc, HBITMAP32 hMono, INT32 x, INT32 y ); diff --git a/include/mdi.h b/include/mdi.h index 0ad2700e9d..4915730eee 100644 --- a/include/mdi.h +++ b/include/mdi.h @@ -31,15 +31,15 @@ typedef struct tagMDIWCL typedef struct { - WORD nActiveChildren; + UINT16 nActiveChildren; HWND16 hwndChildMaximized; HWND16 hwndActiveChild; HMENU16 hWindowMenu; - WORD idFirstChild; - WORD nTotalCreated; + UINT32 idFirstChild; LPSTR frameTitle; - WORD sbNeedUpdate; - WORD sbRecalc; + UINT16 nTotalCreated; + UINT16 mdiFlags; + UINT16 sbRecalc; /* SB_xxx flags for scrollbar fixup */ HWND16 self; } MDICLIENTINFO; diff --git a/include/menu.h b/include/menu.h index 69ef851abf..121c0910a5 100644 --- a/include/menu.h +++ b/include/menu.h @@ -6,7 +6,7 @@ #define __WINE_MENU_H extern BOOL32 MENU_Init(void); -extern HMENU32 MENU_GetDefSysMenu(void); +extern HMENU32 MENU_GetSysMenu(HWND32 hWndOwner, HMENU32 hSysPopup); extern void MENU_InitSysMenuPopup(HMENU32 hmenu, DWORD style, DWORD clsStyle); extern UINT32 MENU_GetMenuBarHeight( HWND32 hwnd, UINT32 menubarWidth, INT32 orgX, INT32 orgY ); diff --git a/include/mmsystem.h b/include/mmsystem.h index 56bc61119e..cc138fe360 100644 --- a/include/mmsystem.h +++ b/include/mmsystem.h @@ -1485,6 +1485,7 @@ typedef struct { LPWAVEFORMAT lpFormat; DWORD dwCallBack; DWORD dwInstance; + UINT16 uDeviceID; } WAVEOPENDESC, *LPWAVEOPENDESC; typedef struct { diff --git a/include/queue.h b/include/queue.h index 30107843d3..80fe77d59f 100644 --- a/include/queue.h +++ b/include/queue.h @@ -75,8 +75,8 @@ typedef struct tagMESSAGEQUEUE extern void QUEUE_DumpQueue( HQUEUE16 hQueue ); extern void QUEUE_WalkQueues(void); -extern BOOL32 QUEUE_IsDoomedQueue( HQUEUE16 hQueue ); -extern void QUEUE_SetDoomedQueue( HQUEUE16 hQueue ); +extern BOOL32 QUEUE_IsExitingQueue( HQUEUE16 hQueue ); +extern void QUEUE_SetExitingQueue( HQUEUE16 hQueue ); extern MESSAGEQUEUE *QUEUE_GetSysQueue(void); extern void QUEUE_SetWakeBit( MESSAGEQUEUE *queue, WORD bit ); extern void QUEUE_ClearWakeBit( MESSAGEQUEUE *queue, WORD bit ); @@ -95,5 +95,6 @@ extern int QUEUE_FindMsg( MESSAGEQUEUE * msgQueue, HWND32 hwnd, extern void QUEUE_RemoveMsg( MESSAGEQUEUE * msgQueue, int pos ); extern void hardware_event( WORD message, WORD wParam, LONG lParam, int xPos, int yPos, DWORD time, DWORD extraInfo ); +extern void QUEUE_FlushMessages( HQUEUE16 hQueue ); #endif /* __WINE_QUEUE_H */ diff --git a/include/stddebug.h b/include/stddebug.h index 98177e0900..e05112d17f 100644 --- a/include/stddebug.h +++ b/include/stddebug.h @@ -123,6 +123,7 @@ #undef DEBUG_MESSAGE #undef DEBUG_METAFILE #undef DEBUG_MIDI +#undef DEBUG_MMAUX #undef DEBUG_MMIO #undef DEBUG_MMSYS #undef DEBUG_MMTIME @@ -205,6 +206,7 @@ #define DEBUG_MESSAGE #define DEBUG_METAFILE #define DEBUG_MIDI +#define DEBUG_MMAUX #define DEBUG_MMIO #define DEBUG_MMSYS #define DEBUG_MMTIME diff --git a/loader/ne_image.c b/loader/ne_image.c index ec82673e88..d5f1e8005d 100644 --- a/loader/ne_image.c +++ b/loader/ne_image.c @@ -281,7 +281,13 @@ BOOL32 NE_LoadSegment( HMODULE16 hModule, WORD segnum ) offset = rep->offset; - switch (rep->address_type) + /* Apparently, high bit of address_type is sometimes set; */ + /* we ignore it for now */ + if (rep->address_type & 0x80) + fprintf( stderr, "Warning: reloc addr type = 0x%02x\n", + rep->address_type ); + + switch (rep->address_type & 0x7f) { case NE_RADDR_LOWBYTE: do { @@ -415,12 +421,16 @@ void NE_FixupPrologs( NE_MODULE *pModule ) { if (*p & 0x0002) { - if (pModule->flags & NE_FFLAGS_MULTIPLEDATA) { + if (pModule->flags & NE_FFLAGS_MULTIPLEDATA) + { /* can this happen? */ fprintf( stderr, "FixupPrologs got confused\n" ); } - *fixup_ptr = 0xb8; /* MOV AX, */ - *(WORD *)(fixup_ptr+1) = dgroup; + else if (pModule->flags & NE_FFLAGS_SINGLEDATA) + { + *fixup_ptr = 0xb8; /* MOV AX, */ + *(WORD *)(fixup_ptr+1) = dgroup; + } } else { diff --git a/memory/global.c b/memory/global.c index f5d7d18622..749d28439d 100644 --- a/memory/global.c +++ b/memory/global.c @@ -872,7 +872,7 @@ HGLOBAL32 GlobalAlloc32(UINT32 flags, DWORD size) pintern=HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN)); if(size) { - palloc=HeapAlloc(GetProcessHeap(), 0, size+sizeof(HGLOBAL32)); + palloc=HeapAlloc(GetProcessHeap(), hpflags, size+sizeof(HGLOBAL32)); *(HGLOBAL32 *)palloc=INTERN_TO_HANDLE(pintern); pintern->Pointer=palloc+sizeof(HGLOBAL32); } diff --git a/misc/commdlg.c b/misc/commdlg.c index 07ced79157..2f053daa02 100644 --- a/misc/commdlg.c +++ b/misc/commdlg.c @@ -202,7 +202,8 @@ static BOOL32 FILEDLG_ScanDir(HWND16 hWnd, LPSTR newPath) len = strlen(str); GetDlgItemText32A( hWnd, edt1, str + len, sizeof(str) - len ); if (!DlgDirList32A( hWnd, str, lst1, 0, 0x0000 )) return FALSE; - return DlgDirList32A( hWnd, "*.*", lst2, stc1, 0x8010 ); + strcpy( str, "*.*" ); + return DlgDirList32A( hWnd, str, lst2, stc1, 0x8010 ); } /*********************************************************************** @@ -409,7 +410,8 @@ static LONG FILEDLG_WMInitDialog(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam) lpofn->nFilterIndex, tmpstr); SetDlgItemText32A( hWnd, edt1, tmpstr ); /* get drive list */ - DlgDirListComboBox32A(hWnd, "", cmb2, 0, 0xC000); + *tmpstr = 0; + DlgDirListComboBox32A(hWnd, tmpstr, cmb2, 0, 0xC000); /* read initial directory */ if (PTR_SEG_TO_LIN(lpofn->lpstrInitialDir) != NULL) { diff --git a/misc/crtdll.c b/misc/crtdll.c index f9ab8c0cec..60d3aebb59 100644 --- a/misc/crtdll.c +++ b/misc/crtdll.c @@ -25,6 +25,8 @@ #include "crtdll.h" #include "drive.h" +extern INT32 WIN32_wsprintf32W( DWORD *args ); + UINT32 CRTDLL_argc_dll; /* CRTDLL.23 */ LPSTR *CRTDLL_argv_dll; /* CRTDLL.24 */ LPSTR CRTDLL_acmdln_dll; /* CRTDLL.38 */ diff --git a/misc/winsock.c b/misc/winsock.c index b250184f60..926c51491f 100644 --- a/misc/winsock.c +++ b/misc/winsock.c @@ -628,19 +628,31 @@ INT16 WINSOCK_ioctlsocket(SOCKET16 s, UINT32 cmd, UINT32 *argp) switch( cmd ) { - case WS_FIONREAD: newcmd=FIONREAD; break; - case WS_FIONBIO: newcmd=FIONBIO; - if( pws->p_aop && *argp == 0 ) - { - pwsi->err = WSAEINVAL; - return SOCKET_ERROR; - } - break; - case WS_SIOCATMARK: newcmd=SIOCATMARK; break; + case WS_FIONREAD: + newcmd=FIONREAD; + break; + + case WS_FIONBIO: + newcmd=FIONBIO; + if( pws->p_aop && *argp == 0 ) + { + pwsi->err = WSAEINVAL; + return SOCKET_ERROR; + } + break; + + case WS_SIOCATMARK: + newcmd=SIOCATMARK; + break; + case WS_IOW('f',125,u_long): - fprintf(stderr,"Warning: WS1.1 shouldn't be using async I/O\n"); - pwsi->err = WSAEINVAL; return SOCKET_ERROR; - default: fprintf(stderr,"Warning: Unknown WS_IOCTL cmd (%08x)\n", cmd); + fprintf(stderr,"Warning: WS1.1 shouldn't be using async I/O\n"); + pwsi->err = WSAEINVAL; + return SOCKET_ERROR; + + default: + /* Netscape tries hard to use bogus ioctl 0x667e */ + dprintf_winsock(stddeb,"\tunknown WS_IOCTL cmd (%08x)\n", cmd); } if( ioctl(pws->fd, newcmd, (char*)argp ) == 0 ) return 0; pwsi->err = (errno == EBADF) ? WSAENOTSOCK : wsaErrno(); @@ -1429,7 +1441,7 @@ INT16 WSACancelBlockingCall(void) return SOCKET_ERROR; } -FARPROC16 WSASetBlockingHook(FARPROC16 lpBlockFunc) +FARPROC16 WSASetBlockingHook16(FARPROC16 lpBlockFunc) { FARPROC16 prev; LPWSINFO pwsi = wsi_find(GetCurrentTask()); @@ -1445,6 +1457,12 @@ FARPROC16 WSASetBlockingHook(FARPROC16 lpBlockFunc) return 0; } +FARPROC32 WSASetBlockingHook32(FARPROC32 lpBlockFunc) +{ + fprintf( stderr, "Empty stub WSASetBlockingHook32(%p)\n", lpBlockFunc ); + return NULL; +} + INT16 WSAUnhookBlockingHook(void) { LPWSINFO pwsi = wsi_find(GetCurrentTask()); diff --git a/misc/wsprintf.c b/misc/wsprintf.c index bdb6713031..4ca48280d9 100644 --- a/misc/wsprintf.c +++ b/misc/wsprintf.c @@ -524,7 +524,7 @@ INT32 wsprintf32A( LPSTR buffer, LPCSTR spec, ... ) } /* Emulator version */ -INT32 WIN32_wsprintf32A( int *args ) +INT32 WIN32_wsprintf32A( DWORD *args ) { return wvsprintf32A( (LPSTR)args[0], (LPCSTR)args[1], (LPCVOID)&args[2] ); } @@ -546,7 +546,7 @@ INT32 wsprintf32W( LPWSTR buffer, LPCWSTR spec, ... ) } /* Emulator version */ -INT32 WIN32_wsprintf32W( int *args ) +INT32 WIN32_wsprintf32W( DWORD *args ) { return wvsprintf32W( (LPWSTR)args[0], (LPCWSTR)args[1], (LPCVOID)&args[2]); } diff --git a/msdos/dpmi.c b/msdos/dpmi.c index 408e6dc696..05404ceb81 100644 --- a/msdos/dpmi.c +++ b/msdos/dpmi.c @@ -20,6 +20,8 @@ #define DOS_GET_DRIVE(reg) ((reg) ? (reg) - 1 : DRIVE_GetCurrentDrive()) +void CreateBPB(int drive, BYTE *data); /* defined in int21.c */ + /* Structure for real-mode callbacks */ typedef struct diff --git a/multimedia/audio.c b/multimedia/audio.c index 558466f2e5..31af318961 100644 --- a/multimedia/audio.c +++ b/multimedia/audio.c @@ -26,10 +26,9 @@ #include "stddebug.h" #include "debug.h" -int MMSYSTEM_DevIDToIndex(UINT16); - #if defined(linux) || defined(__FreeBSD__) #define SOUND_DEV "/dev/dsp" +#define MIXER_DEV "/dev/mixer" #ifdef SOUND_VERSION #define IOCTL(a,b,c) ((-1==ioctl(a,b,&c))&&(perror("ioctl:"#b":"#c),0)) @@ -37,42 +36,43 @@ int MMSYSTEM_DevIDToIndex(UINT16); #define IOCTL(a,b,c) (c = ioctl(a,b,c) ) #endif -#define MAX_WAVOUTDRV 2 -#define MAX_WAVINDRV 2 -#define MAX_MCIWAVDRV 2 +#define MAX_WAVOUTDRV (1) +#define MAX_WAVINDRV (1) +#define MAX_MCIWAVDRV (1) typedef struct { - int unixdev; - int state; - DWORD bufsize; - WAVEOPENDESC waveDesc; - WORD wFlags; - PCMWAVEFORMAT Format; - LPWAVEHDR lpQueueHdr; - DWORD dwTotalPlayed; + int unixdev; + int state; + DWORD bufsize; + WAVEOPENDESC waveDesc; + WORD wFlags; + PCMWAVEFORMAT Format; + LPWAVEHDR lpQueueHdr; + DWORD dwTotalPlayed; } LINUX_WAVEOUT; typedef struct { - int unixdev; - int state; - DWORD bufsize; /* Linux '/dev/dsp' give us that size */ - WAVEOPENDESC waveDesc; - WORD wFlags; - PCMWAVEFORMAT Format; - LPWAVEHDR lpQueueHdr; - DWORD dwTotalRecorded; + int unixdev; + int state; + DWORD bufsize; /* Linux '/dev/dsp' give us that size */ + WAVEOPENDESC waveDesc; + WORD wFlags; + PCMWAVEFORMAT Format; + LPWAVEHDR lpQueueHdr; + DWORD dwTotalRecorded; } LINUX_WAVEIN; typedef struct { - int nUseCount; /* Incremented for each shared open */ - BOOL16 fShareable; /* TRUE if first open was shareable */ - WORD wNotifyDeviceID; /* MCI device ID with a pending notification */ - HANDLE16 hCallback; /* Callback handle for pending notification */ - HMMIO16 hFile; /* mmio file handle open as Element */ + int nUseCount; /* Incremented for each shared open */ + BOOL16 fShareable; /* TRUE if first open was shareable */ + WORD wNotifyDeviceID; /* MCI device ID with a pending notification */ + HANDLE16 hCallback; /* Callback handle for pending notification */ + HMMIO16 hFile; /* mmio file handle open as Element */ MCI_WAVE_OPEN_PARMS openParms; - PCMWAVEFORMAT WaveFormat; - WAVEHDR WaveHdr; - } LINUX_MCIWAVE; + PCMWAVEFORMAT WaveFormat; + WAVEHDR WaveHdr; + BOOL16 fInput; /* FALSE = Output, TRUE = Input */ +} LINUX_MCIWAVE; static LINUX_WAVEOUT WOutDev[MAX_WAVOUTDRV]; static LINUX_WAVEIN WInDev[MAX_WAVOUTDRV]; @@ -85,12 +85,14 @@ static LINUX_MCIWAVE MCIWavDev[MAX_MCIWAVDRV]; static DWORD WAVE_NotifyClient(UINT16 wDevID, WORD wMsg, DWORD dwParam1, DWORD dwParam2) { - int index = MMSYSTEM_DevIDToIndex(wDevID); + dprintf_mciwave(stddeb,"WAVE_NotifyClient // wDevID = %04X wMsg = %d dwParm1 = %04lX dwParam2 = %04lX\n",wDevID, wMsg, dwParam1, dwParam2); - if (WInDev[index].wFlags != DCB_NULL && !DriverCallback( - WInDev[index].waveDesc.dwCallBack, WInDev[index].wFlags, - WInDev[index].waveDesc.hWave, wMsg, - WInDev[index].waveDesc.dwInstance, dwParam1, dwParam2)) { + if (wDevID > MAX_WAVOUTDRV) return MCIERR_INTERNAL; + + if (WInDev[wDevID].wFlags != DCB_NULL && !DriverCallback( + WInDev[wDevID].waveDesc.dwCallBack, WInDev[wDevID].wFlags, + WInDev[wDevID].waveDesc.hWave, wMsg, + WInDev[wDevID].waveDesc.dwInstance, dwParam1, dwParam2)) { dprintf_mciwave(stddeb,"WAVE_NotifyClient // can't notify client !\n"); return MMSYSERR_NOERROR; } @@ -99,11 +101,11 @@ static DWORD WAVE_NotifyClient(UINT16 wDevID, WORD wMsg, /************************************************************************** -* WAVE_mciOpen */ + * WAVE_mciOpen [internal]*/ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS lpParms) { - int index = MMSYSTEM_DevIDToIndex(wDevID); - HLOCAL16 hFormat; + HLOCAL16 hFormat; + LPWAVEFORMAT lpFormat; LPPCMWAVEFORMAT lpWaveFormat; HLOCAL16 hDesc; LPWAVEOPENDESC lpDesc; @@ -115,23 +117,22 @@ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS lp wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - wDevID = lpParms->wDeviceID; - index = MMSYSTEM_DevIDToIndex(wDevID); - - if (MCIWavDev[index].nUseCount > 0) { + if (MCIWavDev[wDevID].nUseCount > 0) { /* The driver already open on this channel */ /* If the driver was opened shareable before and this open specifies */ /* shareable then increment the use count */ - if (MCIWavDev[index].fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) - ++MCIWavDev[index].nUseCount; + if (MCIWavDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) + ++MCIWavDev[wDevID].nUseCount; else return MCIERR_MUST_USE_SHAREABLE; } else { - MCIWavDev[index].nUseCount = 1; - MCIWavDev[index].fShareable = dwFlags & MCI_OPEN_SHAREABLE; + MCIWavDev[wDevID].nUseCount = 1; + MCIWavDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE; } - lpParms->wDeviceID = wDevID; + + MCIWavDev[wDevID].fInput = FALSE; + dprintf_mciwave(stddeb,"WAVE_mciOpen // wDevID=%04X\n", wDevID); dprintf_mciwave(stddeb,"WAVE_mciOpen // before OPEN_ELEMENT\n"); if (dwFlags & MCI_OPEN_ELEMENT) { @@ -141,20 +142,20 @@ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS lp if (strlen(lpstrElementName) > 0) { strcpy(str, lpstrElementName); CharUpper32A(str); - MCIWavDev[index].hFile = mmioOpen(str, NULL, + MCIWavDev[wDevID].hFile = mmioOpen(str, NULL, MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_EXCLUSIVE); - if (MCIWavDev[index].hFile == 0) { + if (MCIWavDev[wDevID].hFile == 0) { dprintf_mciwave(stddeb,"WAVE_mciOpen // can't find file='%s' !\n", str); return MCIERR_FILE_NOT_FOUND; } } else - MCIWavDev[index].hFile = 0; + MCIWavDev[wDevID].hFile = 0; } - dprintf_mciwave(stddeb,"WAVE_mciOpen // hFile=%u\n", MCIWavDev[index].hFile); - memcpy(&MCIWavDev[index].openParms, lpParms, sizeof(MCI_WAVE_OPEN_PARMS)); - MCIWavDev[index].wNotifyDeviceID = lpParms->wDeviceID; - lpWaveFormat = &MCIWavDev[index].WaveFormat; + dprintf_mciwave(stddeb,"WAVE_mciOpen // hFile=%u\n", MCIWavDev[wDevID].hFile); + memcpy(&MCIWavDev[wDevID].openParms, lpParms, sizeof(MCI_WAVE_OPEN_PARMS)); + MCIWavDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID; + lpWaveFormat = &MCIWavDev[wDevID].WaveFormat; hDesc = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC)); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hDesc); lpDesc->hWave = 0; @@ -166,10 +167,10 @@ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS lp lpWaveFormat->wf.nAvgBytesPerSec = 11025; lpWaveFormat->wf.nBlockAlign = 1; */ - if (MCIWavDev[index].hFile != 0) { + if (MCIWavDev[wDevID].hFile != 0) { MMCKINFO mmckInfo; MMCKINFO ckMainRIFF; - if (mmioDescend(MCIWavDev[index].hFile, &ckMainRIFF, NULL, 0) != 0) { + if (mmioDescend(MCIWavDev[wDevID].hFile, &ckMainRIFF, NULL, 0) != 0) { return MCIERR_INTERNAL; } dprintf_mciwave(stddeb, @@ -181,19 +182,19 @@ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS lp return MCIERR_INTERNAL; } mmckInfo.ckid = mmioFOURCC('f', 'm', 't', ' '); - if (mmioDescend(MCIWavDev[index].hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) != 0) { + if (mmioDescend(MCIWavDev[wDevID].hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) != 0) { return MCIERR_INTERNAL; } dprintf_mciwave(stddeb, "WAVE_mciOpen // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n", (LPSTR)&mmckInfo.ckid, (LPSTR)&mmckInfo.fccType, mmckInfo.cksize); - if (mmioRead(MCIWavDev[index].hFile, (HPSTR) lpWaveFormat, + if (mmioRead(MCIWavDev[wDevID].hFile, (HPSTR) lpWaveFormat, (long) sizeof(PCMWAVEFORMAT)) != (long) sizeof(PCMWAVEFORMAT)) { return MCIERR_INTERNAL; } mmckInfo.ckid = mmioFOURCC('d', 'a', 't', 'a'); - if (mmioDescend(MCIWavDev[index].hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) != 0) { + if (mmioDescend(MCIWavDev[wDevID].hFile, &mmckInfo, &ckMainRIFF, MMIO_FINDCHUNK) != 0) { return MCIERR_INTERNAL; } dprintf_mciwave(stddeb, @@ -205,39 +206,107 @@ static DWORD WAVE_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS lp lpWaveFormat->wf.nChannels, lpWaveFormat->wf.nSamplesPerSec); lpWaveFormat->wBitsPerSample = 0; } + lpWaveFormat->wf.nAvgBytesPerSec = lpWaveFormat->wf.nSamplesPerSec * lpWaveFormat->wf.nBlockAlign; hFormat = USER_HEAP_ALLOC(sizeof(PCMWAVEFORMAT)); - lpDesc->lpFormat = (LPWAVEFORMAT) USER_HEAP_LIN_ADDR(hFormat); - memcpy(lpDesc->lpFormat, lpWaveFormat, sizeof(PCMWAVEFORMAT)); + lpFormat = (LPWAVEFORMAT) USER_HEAP_LIN_ADDR(hFormat); + memcpy(lpFormat, lpWaveFormat, sizeof(PCMWAVEFORMAT)); + lpDesc->lpFormat = (LPWAVEFORMAT)USER_HEAP_SEG_ADDR(hFormat); lpDesc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hDesc); - dwRet = wodMessage(index, WODM_OPEN, 0, (DWORD)lpDesc, CALLBACK_NULL); - dwRet = widMessage(index, WIDM_OPEN, 0, (DWORD)lpDesc, CALLBACK_NULL); + +/* + By default the device will be opened for output, the MCI_CUE function is there to + change from output to input and back +*/ + + dwRet = wodMessage(wDevID, WODM_OPEN, 0, (DWORD)lpDesc, CALLBACK_NULL); + USER_HEAP_FREE(hFormat); USER_HEAP_FREE(hDesc); return 0; } +/************************************************************************** +* WAVE_mciCue [internal] +*/ + +static DWORD WAVE_mciCue(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) +{ +/* + FIXME + + This routine is far from complete. At the moment only a check is done on the + MCI_WAVE_INPUT flag. No explicit check on MCI_WAVE_OUTPUT is done since that + is the default. + + The flags MCI_NOTIFY (and the callback parameter in lpParms) and MCI_WAIT are + ignored +*/ + + DWORD dwRet; + HLOCAL16 hDesc; + LPWAVEOPENDESC lpDesc; + + dprintf_mciwave(stddeb,"WAVE_mciCue(%u, %08lX, %p);\n", wDevID, dwParam, lpParms); + +/* always close elements ? */ + + if (MCIWavDev[wDevID].hFile != 0) { + mmioClose(MCIWavDev[wDevID].hFile, 0); + MCIWavDev[wDevID].hFile = 0; + } + + hDesc = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC)); + lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hDesc); + + dwRet = MMSYSERR_NOERROR; /* assume success */ + + if ((dwParam & MCI_WAVE_INPUT) && !MCIWavDev[wDevID].fInput) { + +/* FIXME this is just a hack WOutDev should be hidden here */ + memcpy(lpDesc,&WOutDev[wDevID].waveDesc,sizeof(WAVEOPENDESC)); + + dwRet = wodMessage(wDevID, WODM_CLOSE, 0, 0L, 0L); + if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL; + dwRet = widMessage(wDevID, WIDM_OPEN, 0, (DWORD)lpDesc, CALLBACK_NULL); + } + else if (MCIWavDev[wDevID].fInput) { +/* FIXME this is just a hack WInDev should be hidden here */ + memcpy(lpDesc,&WInDev[wDevID].waveDesc,sizeof(WAVEOPENDESC)); + + dwRet = widMessage(wDevID, WIDM_CLOSE, 0, 0L, 0L); + if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL; + dwRet = wodMessage(wDevID, WODM_OPEN, 0, (DWORD)lpDesc, CALLBACK_NULL); + } + + USER_HEAP_FREE(hDesc); + + return dwRet; +} + /************************************************************************** * WAVE_mciClose [internal] */ static DWORD WAVE_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) { - int index = MMSYSTEM_DevIDToIndex(wDevID); DWORD dwRet; + dprintf_mciwave(stddeb, - "WAVE_mciClose(%u, %08lX, %p);\n", wDevID, dwParam, lpParms); - MCIWavDev[index].nUseCount--; - if (MCIWavDev[index].nUseCount == 0) { - if (MCIWavDev[index].hFile != 0) { - mmioClose(MCIWavDev[index].hFile, 0); - MCIWavDev[index].hFile = 0; - } - dwRet = wodMessage(index, WODM_CLOSE, 0, 0L, 0L); - if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL; - dwRet = widMessage(index, WIDM_CLOSE, 0, 0L, 0L); - if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL; + "WAVE_mciClose(%u, %08lX, %p);\n", wDevID, dwParam, lpParms); + MCIWavDev[wDevID].nUseCount--; + if (MCIWavDev[wDevID].nUseCount == 0) { + if (MCIWavDev[wDevID].hFile != 0) { + mmioClose(MCIWavDev[wDevID].hFile, 0); + MCIWavDev[wDevID].hFile = 0; } + if (MCIWavDev[wDevID].fInput) + dwRet = widMessage(wDevID, WIDM_CLOSE, 0, 0L, 0L); + else + dwRet = wodMessage(wDevID, WODM_CLOSE, 0, 0L, 0L); + + if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL; + } return 0; } @@ -247,7 +316,6 @@ static DWORD WAVE_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpP */ static DWORD WAVE_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms) { - int index = MMSYSTEM_DevIDToIndex(wDevID); int start, end; LONG bufsize, count; HGLOBAL16 hData; @@ -255,13 +323,20 @@ static DWORD WAVE_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms LPWAVEHDR lpWaveHdr; LPWAVEHDR lp16WaveHdr; DWORD dwRet; + dprintf_mciwave(stddeb, "WAVE_mciPlay(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); - if (MCIWavDev[index].hFile == 0) { - dprintf_mciwave(stddeb,"WAVE_mciPlay // can't find file='%08lx' !\n", - MCIWavDev[index].openParms.lpstrElementName); + + if (MCIWavDev[wDevID].fInput) { + dprintf_mciwave(stddeb,"WAVE_mciPlay // cannot play on input device\n"); + return MCIERR_NONAPPLICABLE_FUNCTION; + } + + if (MCIWavDev[wDevID].hFile == 0) { + dprintf_mciwave(stddeb,"WAVE_mciPlay // can't find file='%08lx' !\n", + MCIWavDev[wDevID].openParms.lpstrElementName); return MCIERR_FILE_NOT_FOUND; - } + } start = 1; end = 99999; if (dwFlags & MCI_FROM) { start = lpParms->dwFrom; @@ -290,7 +365,7 @@ static DWORD WAVE_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms } #endif bufsize = 64000; - lpWaveHdr = &MCIWavDev[index].WaveHdr; + lpWaveHdr = &MCIWavDev[wDevID].WaveHdr; hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize); lpWaveHdr->lpData = (LPSTR) WIN16_GlobalLock16(hData); lpWaveHdr->dwUser = 0L; @@ -300,9 +375,9 @@ static DWORD WAVE_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms lp16WaveHdr = (LPWAVEHDR) USER_HEAP_SEG_ADDR(hWaveHdr); memcpy(PTR_SEG_TO_LIN(lp16WaveHdr), lpWaveHdr, sizeof(WAVEHDR)); lpWaveHdr = PTR_SEG_TO_LIN(lp16WaveHdr); - dwRet = wodMessage(index, WODM_PREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); + dwRet = wodMessage(wDevID, WODM_PREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); while(TRUE) { - count = mmioRead(MCIWavDev[index].hFile, + count = mmioRead(MCIWavDev[wDevID].hFile, PTR_SEG_TO_LIN(lpWaveHdr->lpData), bufsize); dprintf_mciwave(stddeb,"WAVE_mciPlay // mmioRead bufsize=%ld count=%ld\n", bufsize, count); if (count < 1) break; @@ -310,9 +385,9 @@ static DWORD WAVE_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms /* lpWaveHdr->dwBytesRecorded = count; */ dprintf_mciwave(stddeb,"WAVE_mciPlay // before WODM_WRITE lpWaveHdr=%p dwBufferLength=%lu dwBytesRecorded=%lu\n", lpWaveHdr, lpWaveHdr->dwBufferLength, lpWaveHdr->dwBytesRecorded); - dwRet = wodMessage(index, WODM_WRITE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); + dwRet = wodMessage(wDevID, WODM_WRITE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); } - dwRet = wodMessage(index, WODM_UNPREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); + dwRet = wodMessage(wDevID, WODM_UNPREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); if (lpWaveHdr->lpData != NULL) { GlobalUnlock16(hData); GlobalFree16(hData); @@ -322,7 +397,7 @@ static DWORD WAVE_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms if (dwFlags & MCI_NOTIFY) { dprintf_mciwave(stddeb,"WAVE_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - MCIWavDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; } @@ -333,8 +408,7 @@ static DWORD WAVE_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms */ static DWORD WAVE_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms) { - int index = MMSYSTEM_DevIDToIndex(wDevID); - int start, end; + int start, end; LONG bufsize; HGLOBAL16 hData; HLOCAL16 hWaveHdr; @@ -344,11 +418,17 @@ static DWORD WAVE_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpP dprintf_mciwave(stddeb, "WAVE_mciRecord(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); - if (MCIWavDev[index].hFile == 0) { + + if (!MCIWavDev[wDevID].fInput) { + dprintf_mciwave(stddeb,"WAVE_mciPlay // cannot record on output device\n"); + return MCIERR_NONAPPLICABLE_FUNCTION; + } + + if (MCIWavDev[wDevID].hFile == 0) { dprintf_mciwave(stddeb,"WAVE_mciRecord // can't find file='%08lx' !\n", - MCIWavDev[index].openParms.lpstrElementName); + MCIWavDev[wDevID].openParms.lpstrElementName); return MCIERR_FILE_NOT_FOUND; - } + } start = 1; end = 99999; if (dwFlags & MCI_FROM) { start = lpParms->dwFrom; @@ -360,7 +440,7 @@ static DWORD WAVE_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpP dprintf_mciwave(stddeb,"WAVE_mciRecord // MCI_TO=%d \n", end); } bufsize = 64000; - lpWaveHdr = &MCIWavDev[index].WaveHdr; + lpWaveHdr = &MCIWavDev[wDevID].WaveHdr; hData = GlobalAlloc16(GMEM_MOVEABLE, bufsize); lpWaveHdr->lpData = (LPSTR) WIN16_GlobalLock16(hData); lpWaveHdr->dwBufferLength = bufsize; @@ -371,18 +451,18 @@ static DWORD WAVE_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpP lp16WaveHdr = (LPWAVEHDR) USER_HEAP_SEG_ADDR(hWaveHdr); memcpy(PTR_SEG_TO_LIN(lp16WaveHdr), lpWaveHdr, sizeof(WAVEHDR)); lpWaveHdr = PTR_SEG_TO_LIN(lp16WaveHdr); - dwRet = widMessage(index, WIDM_PREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); + dwRet = widMessage(wDevID, WIDM_PREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); dprintf_mciwave(stddeb,"WAVE_mciRecord // after WIDM_PREPARE \n"); while(TRUE) { lpWaveHdr->dwBytesRecorded = 0; - dwRet = widMessage(index, WIDM_START, 0, 0L, 0L); + dwRet = widMessage(wDevID, WIDM_START, 0, 0L, 0L); dprintf_mciwave(stddeb, "WAVE_mciRecord // after WIDM_START lpWaveHdr=%p dwBytesRecorded=%lu\n", lpWaveHdr, lpWaveHdr->dwBytesRecorded); if (lpWaveHdr->dwBytesRecorded == 0) break; } dprintf_mciwave(stddeb,"WAVE_mciRecord // before WIDM_UNPREPARE \n"); - dwRet = widMessage(index, WIDM_UNPREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); + dwRet = widMessage(wDevID, WIDM_UNPREPARE, 0, (DWORD)lp16WaveHdr, sizeof(WAVEHDR)); dprintf_mciwave(stddeb,"WAVE_mciRecord // after WIDM_UNPREPARE \n"); if (lpWaveHdr->lpData != NULL) { GlobalUnlock16(hData); @@ -393,7 +473,7 @@ static DWORD WAVE_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpP if (dwFlags & MCI_NOTIFY) { dprintf_mciwave(stddeb,"WAVE_mciRecord // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - MCIWavDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; } @@ -509,7 +589,6 @@ static DWORD WAVE_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms) */ static DWORD WAVE_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms) { - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_mciwave(stddeb, "WAVE_mciStatus(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; @@ -597,7 +676,7 @@ static DWORD WAVE_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpP if (dwFlags & MCI_NOTIFY) { dprintf_mciwave(stddeb,"WAVE_mciStatus // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - MCIWavDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; } @@ -658,7 +737,6 @@ static DWORD WAVE_mciGetDevCaps(UINT16 wDevID, DWORD dwFlags, */ static DWORD WAVE_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms) { - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_mciwave(stddeb, "WAVE_mciInfo(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; @@ -669,7 +747,7 @@ static DWORD WAVE_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms break; case MCI_INFO_FILE: lpParms->lpstrReturn = - (LPSTR)MCIWavDev[index].openParms.lpstrElementName; + (LPSTR)MCIWavDev[wDevID].openParms.lpstrElementName; break; case MCI_WAVE_INPUT: lpParms->lpstrReturn = "Linux Sound System 0.5"; @@ -704,8 +782,9 @@ static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPS lpCaps, DWORD dwSize) dprintf_mciwave(stddeb, "wodGetDevCaps(%u, %p, %lu);\n", wDevID, lpCaps, dwSize); if (lpCaps == NULL) return MMSYSERR_NOTENABLED; + if (access(SOUND_DEV,0) != 0) return MMSYSERR_NOTENABLED; audio = open (SOUND_DEV, O_WRONLY, 0); - if (audio == -1) return MMSYSERR_NOTENABLED; + if (audio == -1) return MMSYSERR_ALLOCATED ; #ifdef EMULATE_SB16 lpCaps->wMid = 0x0002; lpCaps->wPid = 0x0104; @@ -777,10 +856,11 @@ static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags) return MMSYSERR_ALLOCATED; } WOutDev[wDevID].unixdev = 0; + if (access(SOUND_DEV,0) != 0) return MMSYSERR_NOTENABLED; audio = open (SOUND_DEV, O_WRONLY, 0); if (audio == -1) { dprintf_mciwave(stddeb,"Linux 'wodOpen' // can't open !\n"); - return MMSYSERR_NOTENABLED; + return MMSYSERR_ALLOCATED ; } IOCTL(audio, SNDCTL_DSP_GETBLKSIZE, abuf_size); if (abuf_size < 1024 || abuf_size > 65536) { @@ -810,7 +890,10 @@ static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags) WOutDev[wDevID].dwTotalPlayed = 0; WOutDev[wDevID].bufsize = abuf_size; memcpy(&WOutDev[wDevID].waveDesc, lpDesc, sizeof(WAVEOPENDESC)); + dprintf_mciwave(stddeb,"Linux 'wodOpen' // lpDesc->lpFormat = %p\n",lpDesc->lpFormat); lpFormat = (LPWAVEFORMAT) PTR_SEG_TO_LIN(lpDesc->lpFormat); +/* lpFormat = lpDesc->lpFormat; */ + dprintf_mciwave(stddeb,"Linux 'wodOpen' // lpFormat = %p\n",lpFormat); if (lpFormat->wFormatTag != WAVE_FORMAT_PCM) { dprintf_mciwave(stddeb,"Linux 'wodOpen' // Bad format %04X !\n", lpFormat->wFormatTag); @@ -1042,7 +1125,7 @@ static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol) int volume, left, right; dprintf_mciwave(stddeb,"wodGetVolume(%u, %p);\n", wDevID, lpdwVol); if (lpdwVol == NULL) return MMSYSERR_NOTENABLED; - if ((mixer = open("/dev/mixer", O_RDONLY)) < 0) { + if ((mixer = open(MIXER_DEV, O_RDONLY)) < 0) { dprintf_mciwave(stddeb, "Linux 'wodGetVolume' // mixer device not available !\n"); return MMSYSERR_NOTENABLED; } @@ -1053,7 +1136,7 @@ static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol) close(mixer); left = volume & 0x7F; right = (volume >> 8) & 0x7F; - printf("Linux 'AUX_GetVolume' // left=%d right=%d !\n", left, right); + dprintf_mciwave(stddeb,"Linux 'wodGetVolume' // left=%d right=%d !\n", left, right); *lpdwVol = MAKELONG(left << 9, right << 9); return MMSYSERR_NOERROR; } @@ -1069,7 +1152,7 @@ static DWORD wodSetVolume(WORD wDevID, DWORD dwParam) dprintf_mciwave(stddeb,"wodSetVolume(%u, %08lX);\n", wDevID, dwParam); volume = (LOWORD(dwParam) >> 9 & 0x7F) + ((HIWORD(dwParam) >> 9 & 0x7F) << 8); - if ((mixer = open("/dev/mixer", O_WRONLY)) < 0) { + if ((mixer = open(MIXER_DEV, O_WRONLY)) < 0) { dprintf_mciwave(stddeb, "Linux 'wodSetVolume' // mixer device not available !\n"); return MMSYSERR_NOTENABLED; } @@ -1114,13 +1197,13 @@ DWORD wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser, case WODM_GETNUMDEVS: return 1L; case WODM_GETPITCH: - return 0L; + return MMSYSERR_NOTSUPPORTED; case WODM_SETPITCH: - return 0L; + return MMSYSERR_NOTSUPPORTED; case WODM_GETPLAYBACKRATE: - return 0L; + return MMSYSERR_NOTSUPPORTED; case WODM_SETPLAYBACKRATE: - return 0L; + return MMSYSERR_NOTSUPPORTED; case WODM_GETVOLUME: return wodGetVolume(wDevID, (LPDWORD)PTR_SEG_TO_LIN(dwParam1)); case WODM_SETVOLUME: @@ -1156,12 +1239,13 @@ static DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPS lpCaps, DWORD dwSize) dprintf_mciwave(stddeb, "widGetDevCaps(%u, %p, %lu);\n", wDevID, lpCaps, dwSize); if (lpCaps == NULL) return MMSYSERR_NOTENABLED; + if (access(SOUND_DEV,0) != 0) return MMSYSERR_NOTENABLED; audio = open (SOUND_DEV, O_RDONLY, 0); - if (audio == -1) return MMSYSERR_NOTENABLED; + if (audio == -1) return MMSYSERR_ALLOCATED ; #ifdef EMULATE_SB16 lpCaps->wMid = 0x0002; lpCaps->wPid = 0x0004; - strcpy(lpCaps->szPname, "SB16 Wave Out"); + strcpy(lpCaps->szPname, "SB16 Wave In"); #else lpCaps->wMid = 0x00FF; /* Manufac ID */ lpCaps->wPid = 0x0001; /* Product ID */ @@ -1225,10 +1309,11 @@ static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags) return MMSYSERR_ALLOCATED; } WInDev[wDevID].unixdev = 0; + if (access(SOUND_DEV,0) != 0) return MMSYSERR_NOTENABLED; audio = open (SOUND_DEV, O_RDONLY, 0); if (audio == -1) { dprintf_mciwave(stddeb,"Linux 'widOpen' // can't open !\n"); - return MMSYSERR_NOTENABLED; + return MMSYSERR_ALLOCATED; } IOCTL(audio, SNDCTL_DSP_GETBLKSIZE, abuf_size); if (abuf_size < 1024 || abuf_size > 65536) { @@ -1258,7 +1343,8 @@ static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags) WInDev[wDevID].bufsize = abuf_size; WInDev[wDevID].dwTotalRecorded = 0; memcpy(&WInDev[wDevID].waveDesc, lpDesc, sizeof(WAVEOPENDESC)); - lpFormat = lpDesc->lpFormat; + lpFormat = (LPWAVEFORMAT) PTR_SEG_TO_LIN(lpDesc->lpFormat); +/* lpFormat = lpDesc->lpFormat; */ if (lpFormat->wFormatTag != WAVE_FORMAT_PCM) { dprintf_mciwave(stddeb,"Linux 'widOpen' // Bad format %04X !\n", lpFormat->wFormatTag); @@ -1619,6 +1705,8 @@ LONG WAVE_DriverProc(DWORD dwDevID, HDRVR16 hDriv, WORD wMsg, case MCI_OPEN_DRIVER: case MCI_OPEN: return WAVE_mciOpen(dwDevID, dwParam1, (LPMCI_WAVE_OPEN_PARMS)PTR_SEG_TO_LIN(dwParam2)); + case MCI_CUE: + return WAVE_mciCue(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2)); case MCI_CLOSE_DRIVER: case MCI_CLOSE: return WAVE_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)PTR_SEG_TO_LIN(dwParam2)); diff --git a/multimedia/mcianim.c b/multimedia/mcianim.c index babcf25b50..6ab5ddf960 100644 --- a/multimedia/mcianim.c +++ b/multimedia/mcianim.c @@ -17,8 +17,6 @@ #include "stddebug.h" #include "debug.h" -int MMSYSTEM_DevIDToIndex(UINT16); - #define MAX_ANIMDRV 2 #define ANIMFRAMES_PERSEC 30 @@ -54,24 +52,24 @@ static LINUX_ANIM AnimDev[MAX_ANIMDRV]; static DWORD ANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); LPSTR lpstrElementName; char str[128]; + dprintf_mcianim(stddeb,"ANIM_mciOpen(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - if (AnimDev[index].nUseCount > 0) { + if (AnimDev[wDevID].nUseCount > 0) { /* The driver already open on this channel */ /* If the driver was opened shareable before and this open specifies */ /* shareable then increment the use count */ - if (AnimDev[index].fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) - ++AnimDev[index].nUseCount; + if (AnimDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) + ++AnimDev[wDevID].nUseCount; else return MCIERR_MUST_USE_SHAREABLE; } else { - AnimDev[index].nUseCount = 1; - AnimDev[index].fShareable = dwFlags & MCI_OPEN_SHAREABLE; + AnimDev[wDevID].nUseCount = 1; + AnimDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE; } dprintf_mcianim(stddeb,"ANIM_mciOpen // wDevID=%04X\n", wDevID); lpParms->wDeviceID = wDevID; @@ -85,21 +83,21 @@ static DWORD ANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms CharUpper32A(str); } } - memcpy(&AnimDev[index].openParms, lpParms, sizeof(MCI_OPEN_PARMS)); - AnimDev[index].wNotifyDeviceID = lpParms->wDeviceID; - AnimDev[index].mode = 0; - AnimDev[index].dwTimeFormat = MCI_FORMAT_TMSF; - AnimDev[index].nCurTrack = 0; - AnimDev[index].nTracks = 0; - AnimDev[index].dwTotalLen = 0; - AnimDev[index].lpdwTrackLen = NULL; - AnimDev[index].lpdwTrackPos = NULL; + memcpy(&AnimDev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS)); + AnimDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID; + AnimDev[wDevID].mode = 0; + AnimDev[wDevID].dwTimeFormat = MCI_FORMAT_TMSF; + AnimDev[wDevID].nCurTrack = 0; + AnimDev[wDevID].nTracks = 0; + AnimDev[wDevID].dwTotalLen = 0; + AnimDev[wDevID].lpdwTrackLen = NULL; + AnimDev[wDevID].lpdwTrackPos = NULL; if (dwFlags & MCI_NOTIFY) { dprintf_mcianim(stddeb, "ANIM_mciOpen // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - AnimDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -113,11 +111,10 @@ static DWORD ANIM_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms static DWORD ANIM_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_mcianim(stddeb,"ANIM_mciClose(%u, %08lX, %p);\n", wDevID, dwParam, lpParms); - if (AnimDev[index].lpdwTrackLen != NULL) free(AnimDev[index].lpdwTrackLen); - if (AnimDev[index].lpdwTrackPos != NULL) free(AnimDev[index].lpdwTrackPos); + if (AnimDev[wDevID].lpdwTrackLen != NULL) free(AnimDev[wDevID].lpdwTrackLen); + if (AnimDev[wDevID].lpdwTrackPos != NULL) free(AnimDev[wDevID].lpdwTrackPos); #endif return 0; } @@ -185,7 +182,6 @@ static DWORD ANIM_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame) { DWORD dwTime = 0; #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); UINT16 wTrack; UINT16 wMinutes; UINT16 wSeconds; @@ -212,11 +208,11 @@ static DWORD ANIM_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame) /* unknown format ! force TMSF ! ... */ dwFormatType = MCI_FORMAT_TMSF; case MCI_FORMAT_TMSF: - for (wTrack = 0; wTrack < AnimDev[index].nTracks; wTrack++) { -/* dwTime += AnimDev[index].lpdwTrackLen[wTrack - 1]; + for (wTrack = 0; wTrack < AnimDev[wDevID].nTracks; wTrack++) { +/* dwTime += AnimDev[wDevID].lpdwTrackLen[wTrack - 1]; printf("Adding trk#%u curpos=%u \n", dwTime); if (dwTime >= dwFrame) break; */ - if (AnimDev[index].lpdwTrackPos[wTrack - 1] >= dwFrame) break; + if (AnimDev[wDevID].lpdwTrackPos[wTrack - 1] >= dwFrame) break; } wMinutes = dwFrame / ANIMFRAMES_PERMIN; wSeconds = (dwFrame - ANIMFRAMES_PERMIN * wMinutes) / ANIMFRAMES_PERSEC; @@ -240,7 +236,6 @@ static DWORD ANIM_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime) { DWORD dwFrame = 0; #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); UINT16 wTrack; dprintf_mcianim(stddeb,"ANIM_CalcFrame(%u, %08lX, %lu);\n", wDevID, dwFormatType, dwTime); @@ -271,8 +266,8 @@ static DWORD ANIM_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime) MCI_TMSF_SECOND(dwTime), MCI_TMSF_FRAME(dwTime)); dprintf_mcianim(stddeb, "ANIM_CalcFrame // TMSF trackpos[%u]=%lu\n", - wTrack, AnimDev[index].lpdwTrackPos[wTrack - 1]); - dwFrame = AnimDev[index].lpdwTrackPos[wTrack - 1]; + wTrack, AnimDev[wDevID].lpdwTrackPos[wTrack - 1]); + dwFrame = AnimDev[wDevID].lpdwTrackPos[wTrack - 1]; dwFrame += ANIMFRAMES_PERMIN * MCI_TMSF_MINUTE(dwTime); dwFrame += ANIMFRAMES_PERSEC * MCI_TMSF_SECOND(dwTime); dwFrame += MCI_TMSF_FRAME(dwTime); @@ -289,7 +284,6 @@ static DWORD ANIM_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime) static DWORD ANIM_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_mcianim(stddeb,"ANIM_mciInfo(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; @@ -300,7 +294,7 @@ static DWORD ANIM_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms break; case MCI_INFO_FILE: lpParms->lpstrReturn = - (LPSTR)AnimDev[index].openParms.lpstrElementName; + (LPSTR)AnimDev[wDevID].openParms.lpstrElementName; break; case MCI_ANIM_INFO_TEXT: lpParms->lpstrReturn = "Animation Window"; @@ -324,7 +318,6 @@ static DWORD ANIM_mciInfo(UINT16 wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms static DWORD ANIM_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_mcianim(stddeb,"ANIM_mciStatus(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; @@ -333,30 +326,30 @@ static DWORD ANIM_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpP "ANIM_mciStatus // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - AnimDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } if (dwFlags & MCI_STATUS_ITEM) { switch(lpParms->dwItem) { case MCI_STATUS_CURRENT_TRACK: - lpParms->dwReturn = AnimDev[index].nCurTrack; + lpParms->dwReturn = AnimDev[wDevID].nCurTrack; dprintf_mcianim(stddeb,"ANIM_mciStatus // CURRENT_TRACK=%lu!\n", lpParms->dwReturn); return 0; case MCI_STATUS_LENGTH: if (dwFlags & MCI_TRACK) { dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_TRACK #%lu LENGTH=??? !\n", lpParms->dwTrack); - if (lpParms->dwTrack > AnimDev[index].nTracks) + if (lpParms->dwTrack > AnimDev[wDevID].nTracks) return MCIERR_OUTOFRANGE; - lpParms->dwReturn = AnimDev[index].lpdwTrackLen[lpParms->dwTrack]; + lpParms->dwReturn = AnimDev[wDevID].lpdwTrackLen[lpParms->dwTrack]; } else - lpParms->dwReturn = AnimDev[index].dwTotalLen; + lpParms->dwReturn = AnimDev[wDevID].dwTotalLen; lpParms->dwReturn = ANIM_CalcTime(wDevID, - AnimDev[index].dwTimeFormat, lpParms->dwReturn); + AnimDev[wDevID].dwTimeFormat, lpParms->dwReturn); dprintf_mcianim(stddeb,"ANIM_mciStatus // LENGTH=%lu !\n", lpParms->dwReturn); return 0; case MCI_STATUS_MODE: - lpParms->dwReturn = AnimDev[index].mode; + lpParms->dwReturn = AnimDev[wDevID].mode; dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_MODE=%08lX !\n", lpParms->dwReturn); return 0; @@ -371,19 +364,19 @@ static DWORD ANIM_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpP if (lpParms->dwReturn == (WORD)-1) return MCIERR_INTERNAL; return 0; case MCI_STATUS_POSITION: - lpParms->dwReturn = AnimDev[index].dwCurFrame; + lpParms->dwReturn = AnimDev[wDevID].dwCurFrame; if (dwFlags & MCI_STATUS_START) { lpParms->dwReturn = 0; dprintf_mcianim(stddeb,"CDAUDIO_mciStatus // get MCI_STATUS_START !\n"); } if (dwFlags & MCI_TRACK) { - if (lpParms->dwTrack > AnimDev[index].nTracks) + if (lpParms->dwTrack > AnimDev[wDevID].nTracks) return MCIERR_OUTOFRANGE; - lpParms->dwReturn = AnimDev[index].lpdwTrackPos[lpParms->dwTrack - 1]; + lpParms->dwReturn = AnimDev[wDevID].lpdwTrackPos[lpParms->dwTrack - 1]; dprintf_mcianim(stddeb,"ANIM_mciStatus // get MCI_TRACK #%lu !\n", lpParms->dwTrack); } lpParms->dwReturn = ANIM_CalcTime(wDevID, - AnimDev[index].dwTimeFormat, lpParms->dwReturn); + AnimDev[wDevID].dwTimeFormat, lpParms->dwReturn); dprintf_mcianim(stddeb,"ANIM_mciStatus // MCI_STATUS_POSITION=%08lX !\n", lpParms->dwReturn); return 0; @@ -414,33 +407,32 @@ static DWORD ANIM_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpP static DWORD ANIM_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); int start, end; dprintf_mcianim(stddeb,"ANIM_mciPlay(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - start = 0; end = AnimDev[index].dwTotalLen; - AnimDev[index].nCurTrack = 1; + start = 0; end = AnimDev[wDevID].dwTotalLen; + AnimDev[wDevID].nCurTrack = 1; if (dwFlags & MCI_FROM) { start = ANIM_CalcFrame(wDevID, - AnimDev[index].dwTimeFormat, lpParms->dwFrom); + AnimDev[wDevID].dwTimeFormat, lpParms->dwFrom); dprintf_mcianim(stddeb,"ANIM_mciPlay // MCI_FROM=%08lX -> %u \n", lpParms->dwFrom, start); } if (dwFlags & MCI_TO) { end = ANIM_CalcFrame(wDevID, - AnimDev[index].dwTimeFormat, lpParms->dwTo); + AnimDev[wDevID].dwTimeFormat, lpParms->dwTo); dprintf_mcianim(stddeb, "ANIM_mciPlay // MCI_TO=%08lX -> %u \n", lpParms->dwTo, end); } - AnimDev[index].mode = MCI_MODE_PLAY; + AnimDev[wDevID].mode = MCI_MODE_PLAY; if (dwFlags & MCI_NOTIFY) { dprintf_mcianim(stddeb, "ANIM_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - AnimDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -454,17 +446,16 @@ static DWORD ANIM_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms static DWORD ANIM_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_mcianim(stddeb,"ANIM_mciStop(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - AnimDev[index].mode = MCI_MODE_STOP; + AnimDev[wDevID].mode = MCI_MODE_STOP; if (dwFlags & MCI_NOTIFY) { dprintf_mcianim(stddeb, "ANIM_mciStop // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - AnimDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -478,17 +469,16 @@ static DWORD ANIM_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpPa static DWORD ANIM_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_mcianim(stddeb,"ANIM_mciPause(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - AnimDev[index].mode = MCI_MODE_PAUSE; + AnimDev[wDevID].mode = MCI_MODE_PAUSE; if (dwFlags & MCI_NOTIFY) { dprintf_mcianim(stddeb, "ANIM_mciPause // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - AnimDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -502,17 +492,16 @@ static DWORD ANIM_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpP static DWORD ANIM_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_mcianim(stddeb,"ANIM_mciResume(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - AnimDev[index].mode = MCI_MODE_STOP; + AnimDev[wDevID].mode = MCI_MODE_STOP; if (dwFlags & MCI_NOTIFY) { dprintf_mcianim(stddeb, "ANIM_mciResume // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - AnimDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -526,19 +515,18 @@ static DWORD ANIM_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lp static DWORD ANIM_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); DWORD dwRet; MCI_PLAY_PARMS PlayParms; dprintf_mcianim(stddeb,"ANIM_mciSeek(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - AnimDev[index].mode = MCI_MODE_SEEK; + AnimDev[wDevID].mode = MCI_MODE_SEEK; switch(dwFlags) { case MCI_SEEK_TO_START: PlayParms.dwFrom = 0; break; case MCI_SEEK_TO_END: - PlayParms.dwFrom = AnimDev[index].dwTotalLen; + PlayParms.dwFrom = AnimDev[wDevID].dwTotalLen; break; case MCI_TO: PlayParms.dwFrom = lpParms->dwTo; @@ -552,7 +540,7 @@ static DWORD ANIM_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms "ANIM_mciSeek // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - AnimDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return dwRet; #else @@ -567,7 +555,6 @@ static DWORD ANIM_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms static DWORD ANIM_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_mcianim(stddeb,"ANIM_mciSet(%u, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; @@ -591,7 +578,7 @@ static DWORD ANIM_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms) fprintf(stderr,"ANIM_mciSet // bad time format !\n"); return MCIERR_BAD_TIME_FORMAT; } - AnimDev[index].dwTimeFormat = lpParms->dwTimeFormat; + AnimDev[wDevID].dwTimeFormat = lpParms->dwTimeFormat; } if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION; if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION; @@ -601,7 +588,7 @@ static DWORD ANIM_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms) "ANIM_mciSet // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - AnimDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + AnimDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else diff --git a/multimedia/mcicda.c b/multimedia/mcicda.c index 5c9781db3b..42139335c5 100644 --- a/multimedia/mcicda.c +++ b/multimedia/mcicda.c @@ -25,8 +25,6 @@ #include #endif -int MMSYSTEM_DevIDToIndex(UINT16); - #define SOUND_DEV "/dev/dsp" #ifdef __FreeBSD__ #define CDAUDIO_DEV "/dev/rcd0c" @@ -40,7 +38,7 @@ int MMSYSTEM_DevIDToIndex(UINT16); #define IOCTL(a,b,c) (c = ioctl(a,b,c) ) #endif -#define MAX_CDAUDIODRV 2 +#define MAX_CDAUDIODRV (1) #define MAX_CDAUDIO_TRACKS 256 #define CDFRAMES_PERSEC 75 @@ -84,14 +82,14 @@ static LINUX_CDAUDIO CDADev[MAX_CDAUDIODRV]; static UINT16 CDAUDIO_GetNumberOfTracks(UINT16 wDevID) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); #ifdef linux struct cdrom_tochdr hdr; #elif __FreeBSD__ struct ioc_toc_header hdr; #endif - if (CDADev[index].nTracks == 0) { - if (ioctl(CDADev[index].unixdev, + + if (CDADev[wDevID].nTracks == 0) { + if (ioctl(CDADev[wDevID].unixdev, #ifdef linux CDROMREADTOCHDR #elif __FreeBSD__ @@ -104,12 +102,12 @@ static UINT16 CDAUDIO_GetNumberOfTracks(UINT16 wDevID) return (WORD)-1; } #ifdef linux - CDADev[index].nTracks = hdr.cdth_trk1; + CDADev[wDevID].nTracks = hdr.cdth_trk1; #elif __FreeBSD__ - CDADev[index].nTracks = hdr.ending_track - hdr.starting_track + 1; + CDADev[wDevID].nTracks = hdr.ending_track - hdr.starting_track + 1; #endif } - return CDADev[index].nTracks; + return CDADev[wDevID].nTracks; #else return (WORD)-1; #endif @@ -122,7 +120,6 @@ static UINT16 CDAUDIO_GetNumberOfTracks(UINT16 wDevID) static BOOL32 CDAUDIO_GetTracksInfo(UINT16 wDevID) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); int i, length; int start, last_start = 0; int total_length = 0; @@ -132,31 +129,32 @@ static BOOL32 CDAUDIO_GetTracksInfo(UINT16 wDevID) struct ioc_read_toc_entry entry; struct cd_toc_entry toc_buffer; #endif - if (CDADev[index].nTracks == 0) { + + if (CDADev[wDevID].nTracks == 0) { if (CDAUDIO_GetNumberOfTracks(wDevID) == (WORD)-1) return FALSE; } dprintf_cdaudio(stddeb,"CDAUDIO_GetTracksInfo // nTracks=%u\n", - CDADev[index].nTracks); - if (CDADev[index].lpdwTrackLen != NULL) - free(CDADev[index].lpdwTrackLen); - CDADev[index].lpdwTrackLen = (LPDWORD)malloc( - (CDADev[index].nTracks + 1) * sizeof(DWORD)); - if (CDADev[index].lpdwTrackPos != NULL) - free(CDADev[index].lpdwTrackPos); - CDADev[index].lpdwTrackPos = (LPDWORD)malloc( - (CDADev[index].nTracks + 1) * sizeof(DWORD)); - if (CDADev[index].lpdwTrackLen == NULL || - CDADev[index].lpdwTrackPos == NULL) { + CDADev[wDevID].nTracks); + if (CDADev[wDevID].lpdwTrackLen != NULL) + free(CDADev[wDevID].lpdwTrackLen); + CDADev[wDevID].lpdwTrackLen = (LPDWORD)malloc( + (CDADev[wDevID].nTracks + 1) * sizeof(DWORD)); + if (CDADev[wDevID].lpdwTrackPos != NULL) + free(CDADev[wDevID].lpdwTrackPos); + CDADev[wDevID].lpdwTrackPos = (LPDWORD)malloc( + (CDADev[wDevID].nTracks + 1) * sizeof(DWORD)); + if (CDADev[wDevID].lpdwTrackLen == NULL || + CDADev[wDevID].lpdwTrackPos == NULL) { dprintf_cdaudio(stddeb, "CDAUDIO_GetTracksInfo // error allocating track table !\n"); return FALSE; } - memset(CDADev[index].lpdwTrackLen, 0, - (CDADev[index].nTracks + 1) * sizeof(DWORD)); - memset(CDADev[index].lpdwTrackPos, 0, - (CDADev[index].nTracks + 1) * sizeof(DWORD)); - for (i = 0; i <= CDADev[index].nTracks; i++) { - if (i == CDADev[index].nTracks) + memset(CDADev[wDevID].lpdwTrackLen, 0, + (CDADev[wDevID].nTracks + 1) * sizeof(DWORD)); + memset(CDADev[wDevID].lpdwTrackPos, 0, + (CDADev[wDevID].nTracks + 1) * sizeof(DWORD)); + for (i = 0; i <= CDADev[wDevID].nTracks; i++) { + if (i == CDADev[wDevID].nTracks) #ifdef linux entry.cdte_track = CDROM_LEADOUT; #elif __FreeBSD__ @@ -177,7 +175,7 @@ static BOOL32 CDAUDIO_GetTracksInfo(UINT16 wDevID) entry.data_len = sizeof(toc_buffer); entry.data = &toc_buffer; #endif - if (ioctl(CDADev[index].unixdev, + if (ioctl(CDADev[wDevID].unixdev, #ifdef linux CDROMREADTOCENTRY #elif __FreeBSD__ @@ -199,7 +197,7 @@ static BOOL32 CDAUDIO_GetTracksInfo(UINT16 wDevID) #endif if (i == 0) { last_start = start; - CDADev[index].dwFirstOffset = start; + CDADev[wDevID].dwFirstOffset = start; dprintf_cdaudio(stddeb, "CDAUDIO_GetTracksInfo // dwFirstOffset=%u\n", start); @@ -209,17 +207,16 @@ static BOOL32 CDAUDIO_GetTracksInfo(UINT16 wDevID) last_start = start; start = last_start - length; total_length += length; - CDADev[index].lpdwTrackLen[i - 1] = length; - CDADev[index].lpdwTrackPos[i - 1] = start; + CDADev[wDevID].lpdwTrackLen[i - 1] = length; + CDADev[wDevID].lpdwTrackPos[i - 1] = start; dprintf_cdaudio(stddeb, "CDAUDIO_GetTracksInfo // track #%u start=%u len=%u\n", i, start, length); } } - CDADev[index].dwTotalLen = total_length; + CDADev[wDevID].dwTotalLen = total_length; dprintf_cdaudio(stddeb,"CDAUDIO_GetTracksInfo // total_len=%u\n", total_length); - fflush(stdout); return TRUE; #else return FALSE; @@ -233,46 +230,42 @@ static BOOL32 CDAUDIO_GetTracksInfo(UINT16 wDevID) static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index; dprintf_cdaudio(stddeb,"CDAUDIO_mciOpen(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - wDevID = lpParms->wDeviceID; - index = MMSYSTEM_DevIDToIndex(wDevID); - - if (CDADev[index].nUseCount > 0) { + if (CDADev[wDevID].nUseCount > 0) { /* The driver already open on this channel */ /* If the driver was opened shareable before and this open specifies */ /* shareable then increment the use count */ - if (CDADev[index].fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) - ++CDADev[index].nUseCount; + if (CDADev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) + ++CDADev[wDevID].nUseCount; else return MCIERR_MUST_USE_SHAREABLE; } else { - CDADev[index].nUseCount = 1; - CDADev[index].fShareable = dwFlags & MCI_OPEN_SHAREABLE; + CDADev[wDevID].nUseCount = 1; + CDADev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE; } if (dwFlags & MCI_OPEN_ELEMENT) { dprintf_cdaudio(stddeb,"CDAUDIO_mciOpen // MCI_OPEN_ELEMENT !\n"); /* return MCIERR_NO_ELEMENT_ALLOWED; */ } - memcpy(&CDADev[index].openParms, lpParms, sizeof(MCI_OPEN_PARMS)); - CDADev[index].wNotifyDeviceID = lpParms->wDeviceID; - CDADev[index].unixdev = open (CDAUDIO_DEV, O_RDONLY, 0); - if (CDADev[index].unixdev == -1) { + memcpy(&CDADev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS)); + CDADev[wDevID].wNotifyDeviceID = lpParms->wDeviceID; + CDADev[wDevID].unixdev = open (CDAUDIO_DEV, O_RDONLY, 0); + if (CDADev[wDevID].unixdev == -1) { dprintf_cdaudio(stddeb,"CDAUDIO_mciOpen // can't open '%s' !\n", CDAUDIO_DEV); return MCIERR_HARDWARE; } - CDADev[index].mode = 0; - CDADev[index].dwTimeFormat = MCI_FORMAT_TMSF; - CDADev[index].nCurTrack = 0; - CDADev[index].nTracks = 0; - CDADev[index].dwTotalLen = 0; - CDADev[index].dwFirstOffset = 0; - CDADev[index].lpdwTrackLen = NULL; - CDADev[index].lpdwTrackPos = NULL; + CDADev[wDevID].mode = 0; + CDADev[wDevID].dwTimeFormat = MCI_FORMAT_TMSF; + CDADev[wDevID].nCurTrack = 0; + CDADev[wDevID].nTracks = 0; + CDADev[wDevID].dwTotalLen = 0; + CDADev[wDevID].dwFirstOffset = 0; + CDADev[wDevID].lpdwTrackLen = NULL; + CDADev[wDevID].lpdwTrackPos = NULL; if (!CDAUDIO_GetTracksInfo(wDevID)) { dprintf_cdaudio(stddeb,"CDAUDIO_mciOpen // error reading TracksInfo !\n"); /* return MCIERR_INTERNAL; */ @@ -282,7 +275,7 @@ static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpPa "CDAUDIO_mciOpen // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - CDADev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -296,12 +289,11 @@ static DWORD CDAUDIO_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpPa static DWORD CDAUDIO_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_cdaudio(stddeb,"CDAUDIO_mciClose(%04X, %08lX, %p);\n", wDevID, dwParam, lpParms); - if (CDADev[index].lpdwTrackLen != NULL) free(CDADev[index].lpdwTrackLen); - if (CDADev[index].lpdwTrackPos != NULL) free(CDADev[index].lpdwTrackPos); - close(CDADev[index].unixdev); + if (CDADev[wDevID].lpdwTrackLen != NULL) free(CDADev[wDevID].lpdwTrackLen); + if (CDADev[wDevID].lpdwTrackPos != NULL) free(CDADev[wDevID].lpdwTrackPos); + close(CDADev[wDevID].unixdev); #endif return 0; } @@ -396,7 +388,6 @@ static DWORD CDAUDIO_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime) { DWORD dwFrame = 0; #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); UINT16 wTrack; dprintf_cdaudio(stddeb,"CDAUDIO_CalcFrame(%04X, %08lX, %lu);\n", @@ -429,8 +420,8 @@ static DWORD CDAUDIO_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime) MCI_TMSF_SECOND(dwTime), MCI_TMSF_FRAME(dwTime)); dprintf_cdaudio(stddeb, "CDAUDIO_CalcFrame // TMSF trackpos[%u]=%lu\n", - wTrack, CDADev[index].lpdwTrackPos[wTrack - 1]); - dwFrame = CDADev[index].lpdwTrackPos[wTrack - 1]; + wTrack, CDADev[wDevID].lpdwTrackPos[wTrack - 1]); + dwFrame = CDADev[wDevID].lpdwTrackPos[wTrack - 1]; dwFrame += CDFRAMES_PERMIN * MCI_TMSF_MINUTE(dwTime); dwFrame += CDFRAMES_PERSEC * MCI_TMSF_SECOND(dwTime); dwFrame += MCI_TMSF_FRAME(dwTime); @@ -447,35 +438,34 @@ static DWORD CDAUDIO_CalcFrame(UINT16 wDevID, DWORD dwFormatType, DWORD dwTime) static BOOL32 CDAUDIO_GetCDStatus(UINT16 wDevID) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); - int oldmode = CDADev[index].mode; + int oldmode = CDADev[wDevID].mode; #ifdef __FreeBSD__ struct ioc_read_subchannel read_sc; read_sc.address_format = CD_MSF_FORMAT; read_sc.data_format = CD_CURRENT_POSITION; read_sc.track = 0; - read_sc.data_len = sizeof(CDADev[index].sc); - read_sc.data = (struct cd_sub_channel_info *)&CDADev[index].sc; + read_sc.data_len = sizeof(CDADev[wDevID].sc); + read_sc.data = (struct cd_sub_channel_info *)&CDADev[wDevID].sc; #elif linux - CDADev[index].sc.cdsc_format = CDROM_MSF; + CDADev[wDevID].sc.cdsc_format = CDROM_MSF; #endif - if (ioctl(CDADev[index].unixdev, + if (ioctl(CDADev[wDevID].unixdev, #ifdef linux - CDROMSUBCHNL, &CDADev[index].sc + CDROMSUBCHNL, &CDADev[wDevID].sc #elif __FreeBSD__ CDIOCREADSUBCHANNEL, &read_sc #endif )) { dprintf_cdaudio(stddeb,"CDAUDIO_GetCDStatus // opened or no_media !\n"); - CDADev[index].mode = MCI_MODE_NOT_READY; + CDADev[wDevID].mode = MCI_MODE_NOT_READY; return TRUE; } switch ( #ifdef linux - CDADev[index].sc.cdsc_audiostatus + CDADev[wDevID].sc.cdsc_audiostatus #elif __FreeBSD__ - CDADev[index].sc.header.audio_status + CDADev[wDevID].sc.header.audio_status #endif ) { #ifdef linux @@ -485,9 +475,9 @@ static BOOL32 CDAUDIO_GetCDStatus(UINT16 wDevID) #endif dprintf_cdaudio(stddeb,"CDAUDIO_GetCDStatus // device doesn't support status, returning NOT_READY.\n"); #ifdef linux - CDADev[index].mode = MCI_MODE_NOT_READY; + CDADev[wDevID].mode = MCI_MODE_NOT_READY; #elif __FreeBSD__ - CDADev[index].mode = MCI_MODE_STOP; + CDADev[wDevID].mode = MCI_MODE_STOP; #endif break; #ifdef linux @@ -495,7 +485,7 @@ static BOOL32 CDAUDIO_GetCDStatus(UINT16 wDevID) #elif __FreeBSD__ case CD_AS_NO_STATUS: #endif - CDADev[index].mode = MCI_MODE_STOP; + CDADev[wDevID].mode = MCI_MODE_STOP; dprintf_cdaudio(stddeb,"CDAUDIO_GetCDStatus // MCI_MODE_STOP !\n"); break; #ifdef linux @@ -503,7 +493,7 @@ static BOOL32 CDAUDIO_GetCDStatus(UINT16 wDevID) #elif __FreeBSD__ case CD_AS_PLAY_IN_PROGRESS: #endif - CDADev[index].mode = MCI_MODE_PLAY; + CDADev[wDevID].mode = MCI_MODE_PLAY; dprintf_cdaudio(stddeb,"CDAUDIO_GetCDStatus // MCI_MODE_PLAY !\n"); break; #ifdef linux @@ -511,45 +501,45 @@ static BOOL32 CDAUDIO_GetCDStatus(UINT16 wDevID) #elif __FreeBSD__ case CD_AS_PLAY_PAUSED: #endif - CDADev[index].mode = MCI_MODE_PAUSE; + CDADev[wDevID].mode = MCI_MODE_PAUSE; dprintf_cdaudio(stddeb,"CDAUDIO_GetCDStatus // MCI_MODE_PAUSE !\n"); break; default: dprintf_cdaudio(stddeb,"CDAUDIO_GetCDStatus // status=%02X !\n", #ifdef linux - CDADev[index].sc.cdsc_audiostatus + CDADev[wDevID].sc.cdsc_audiostatus #elif __FreeBSD__ - CDADev[index].sc.header.audio_status + CDADev[wDevID].sc.header.audio_status #endif ); } #ifdef linux - CDADev[index].nCurTrack = CDADev[index].sc.cdsc_trk; - CDADev[index].dwCurFrame = - CDFRAMES_PERMIN * CDADev[index].sc.cdsc_absaddr.msf.minute + - CDFRAMES_PERSEC * CDADev[index].sc.cdsc_absaddr.msf.second + - CDADev[index].sc.cdsc_absaddr.msf.frame; + CDADev[wDevID].nCurTrack = CDADev[wDevID].sc.cdsc_trk; + CDADev[wDevID].dwCurFrame = + CDFRAMES_PERMIN * CDADev[wDevID].sc.cdsc_absaddr.msf.minute + + CDFRAMES_PERSEC * CDADev[wDevID].sc.cdsc_absaddr.msf.second + + CDADev[wDevID].sc.cdsc_absaddr.msf.frame; #elif __FreeBSD__ - CDADev[index].nCurTrack = CDADev[index].sc.what.position.track_number; - CDADev[index].dwCurFrame = - CDFRAMES_PERMIN * CDADev[index].sc.what.position.absaddr.msf.minute + - CDFRAMES_PERSEC * CDADev[index].sc.what.position.absaddr.msf.second + - CDADev[index].sc.what.position.absaddr.msf.frame; + CDADev[wDevID].nCurTrack = CDADev[wDevID].sc.what.position.track_number; + CDADev[wDevID].dwCurFrame = + CDFRAMES_PERMIN * CDADev[wDevID].sc.what.position.absaddr.msf.minute + + CDFRAMES_PERSEC * CDADev[wDevID].sc.what.position.absaddr.msf.second + + CDADev[wDevID].sc.what.position.absaddr.msf.frame; #endif dprintf_cdaudio(stddeb,"CDAUDIO_GetCDStatus // %02u-%02u:%02u:%02u \n", #ifdef linux - CDADev[index].sc.cdsc_trk, - CDADev[index].sc.cdsc_absaddr.msf.minute, - CDADev[index].sc.cdsc_absaddr.msf.second, - CDADev[index].sc.cdsc_absaddr.msf.frame + CDADev[wDevID].sc.cdsc_trk, + CDADev[wDevID].sc.cdsc_absaddr.msf.minute, + CDADev[wDevID].sc.cdsc_absaddr.msf.second, + CDADev[wDevID].sc.cdsc_absaddr.msf.frame #elif __FreeBSD__ - CDADev[index].sc.what.position.track_number, - CDADev[index].sc.what.position.absaddr.msf.minute, - CDADev[index].sc.what.position.absaddr.msf.second, - CDADev[index].sc.what.position.absaddr.msf.frame + CDADev[wDevID].sc.what.position.track_number, + CDADev[wDevID].sc.what.position.absaddr.msf.minute, + CDADev[wDevID].sc.what.position.absaddr.msf.second, + CDADev[wDevID].sc.what.position.absaddr.msf.frame #endif ); - if (oldmode != CDADev[index].mode && oldmode == MCI_MODE_OPEN) { + if (oldmode != CDADev[wDevID].mode && oldmode == MCI_MODE_OPEN) { if (!CDAUDIO_GetTracksInfo(wDevID)) { dprintf_cdaudio(stddeb,"CDAUDIO_GetCDStatus // error updating TracksInfo !\n"); return MCIERR_INTERNAL; @@ -569,11 +559,11 @@ static DWORD CDAUDIO_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame) { DWORD dwTime = 0; #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); UINT16 wTrack; UINT16 wMinutes; UINT16 wSeconds; UINT16 wFrames; + dprintf_cdaudio(stddeb,"CDAUDIO_CalcTime(%04X, %08lX, %lu);\n", wDevID, dwFormatType, dwFrame); @@ -597,11 +587,11 @@ static DWORD CDAUDIO_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame) /* unknown format ! force TMSF ! ... */ dwFormatType = MCI_FORMAT_TMSF; case MCI_FORMAT_TMSF: - for (wTrack = 0; wTrack < CDADev[index].nTracks; wTrack++) { -/* dwTime += CDADev[index].lpdwTrackLen[wTrack - 1]; + for (wTrack = 0; wTrack < CDADev[wDevID].nTracks; wTrack++) { +/* dwTime += CDADev[wDevID].lpdwTrackLen[wTrack - 1]; printf("Adding trk#%u curpos=%u \n", dwTime); if (dwTime >= dwFrame) break; */ - if (CDADev[index].lpdwTrackPos[wTrack - 1] >= dwFrame) break; + if (CDADev[wDevID].lpdwTrackPos[wTrack - 1] >= dwFrame) break; } wMinutes = dwFrame / CDFRAMES_PERMIN; wSeconds = (dwFrame - CDFRAMES_PERMIN * wMinutes) / CDFRAMES_PERSEC; @@ -624,27 +614,26 @@ static DWORD CDAUDIO_CalcTime(UINT16 wDevID, DWORD dwFormatType, DWORD dwFrame) static DWORD CDAUDIO_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - if (CDADev[index].unixdev == 0) return MMSYSERR_NOTENABLED; + if (CDADev[wDevID].unixdev == 0) return MMSYSERR_NOTENABLED; if (dwFlags & MCI_NOTIFY) { dprintf_cdaudio(stddeb, "CDAUDIO_mciStatus // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - CDADev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } if (dwFlags & MCI_STATUS_ITEM) { switch(lpParms->dwItem) { case MCI_STATUS_CURRENT_TRACK: if (!CDAUDIO_GetCDStatus(wDevID)) return MCIERR_INTERNAL; - lpParms->dwReturn = CDADev[index].nCurTrack; + lpParms->dwReturn = CDADev[wDevID].nCurTrack; dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // CURRENT_TRACK=%lu!\n", lpParms->dwReturn); return 0; case MCI_STATUS_LENGTH: - if (CDADev[index].nTracks == 0) { + if (CDADev[wDevID].nTracks == 0) { if (!CDAUDIO_GetTracksInfo(wDevID)) { dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // error reading TracksInfo !\n"); return MCIERR_INTERNAL; @@ -653,24 +642,24 @@ static DWORD CDAUDIO_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS if (dwFlags & MCI_TRACK) { dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // MCI_TRACK #%lu LENGTH=??? !\n", lpParms->dwTrack); - if (lpParms->dwTrack > CDADev[index].nTracks) + if (lpParms->dwTrack > CDADev[wDevID].nTracks) return MCIERR_OUTOFRANGE; - lpParms->dwReturn = CDADev[index].lpdwTrackLen[lpParms->dwTrack]; + lpParms->dwReturn = CDADev[wDevID].lpdwTrackLen[lpParms->dwTrack]; } else - lpParms->dwReturn = CDADev[index].dwTotalLen; + lpParms->dwReturn = CDADev[wDevID].dwTotalLen; lpParms->dwReturn = CDAUDIO_CalcTime(wDevID, - CDADev[index].dwTimeFormat, lpParms->dwReturn); + CDADev[wDevID].dwTimeFormat, lpParms->dwReturn); dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // LENGTH=%lu !\n", lpParms->dwReturn); return 0; case MCI_STATUS_MODE: if (!CDAUDIO_GetCDStatus(wDevID)) return MCIERR_INTERNAL; - lpParms->dwReturn = CDADev[index].mode; + lpParms->dwReturn = CDADev[wDevID].mode; dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // MCI_STATUS_MODE=%08lX !\n", lpParms->dwReturn); return 0; case MCI_STATUS_MEDIA_PRESENT: - lpParms->dwReturn = (CDADev[index].nTracks > 0) ? TRUE : FALSE; + lpParms->dwReturn = (CDADev[wDevID].nTracks > 0) ? TRUE : FALSE; if (lpParms->dwReturn == FALSE) dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // MEDIA_NOT_PRESENT !\n"); else @@ -684,19 +673,19 @@ static DWORD CDAUDIO_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS return 0; case MCI_STATUS_POSITION: if (!CDAUDIO_GetCDStatus(wDevID)) return MCIERR_INTERNAL; - lpParms->dwReturn = CDADev[index].dwCurFrame; + lpParms->dwReturn = CDADev[wDevID].dwCurFrame; if (dwFlags & MCI_STATUS_START) { - lpParms->dwReturn = CDADev[index].dwFirstOffset; + lpParms->dwReturn = CDADev[wDevID].dwFirstOffset; dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // get MCI_STATUS_START !\n"); } if (dwFlags & MCI_TRACK) { - if (lpParms->dwTrack > CDADev[index].nTracks) + if (lpParms->dwTrack > CDADev[wDevID].nTracks) return MCIERR_OUTOFRANGE; - lpParms->dwReturn = CDADev[index].lpdwTrackPos[lpParms->dwTrack - 1]; + lpParms->dwReturn = CDADev[wDevID].lpdwTrackPos[lpParms->dwTrack - 1]; dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // get MCI_TRACK #%lu !\n", lpParms->dwTrack); } lpParms->dwReturn = CDAUDIO_CalcTime(wDevID, - CDADev[index].dwTimeFormat, lpParms->dwReturn); + CDADev[wDevID].dwTimeFormat, lpParms->dwReturn); dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // MCI_STATUS_POSITION=%08lX !\n", lpParms->dwReturn); return 0; @@ -706,7 +695,7 @@ static DWORD CDAUDIO_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS return 0; case MCI_STATUS_TIME_FORMAT: dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // MCI_STATUS_TIME_FORMAT !\n"); - lpParms->dwReturn = CDADev[index].dwTimeFormat; + lpParms->dwReturn = CDADev[wDevID].dwTimeFormat; return 0; default: dprintf_cdaudio(stddeb,"CDAUDIO_mciStatus // unknown command %08lX !\n", lpParms->dwItem); @@ -727,34 +716,34 @@ static DWORD CDAUDIO_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS static DWORD CDAUDIO_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); int start, end; #ifdef linux struct cdrom_msf msf; #elif __FreeBSD__ struct ioc_play_msf msf; #endif + dprintf_cdaudio(stddeb,"CDAUDIO_mciPlay(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - if (CDADev[index].unixdev == 0) return MMSYSERR_NOTENABLED; - start = 0; end = CDADev[index].dwTotalLen; - CDADev[index].nCurTrack = 1; + if (CDADev[wDevID].unixdev == 0) return MMSYSERR_NOTENABLED; + start = 0; end = CDADev[wDevID].dwTotalLen; + CDADev[wDevID].nCurTrack = 1; if (dwFlags & MCI_FROM) { start = CDAUDIO_CalcFrame(wDevID, - CDADev[index].dwTimeFormat, lpParms->dwFrom); + CDADev[wDevID].dwTimeFormat, lpParms->dwFrom); dprintf_cdaudio(stddeb,"CDAUDIO_mciPlay // MCI_FROM=%08lX -> %u \n", lpParms->dwFrom, start); } if (dwFlags & MCI_TO) { end = CDAUDIO_CalcFrame(wDevID, - CDADev[index].dwTimeFormat, lpParms->dwTo); + CDADev[wDevID].dwTimeFormat, lpParms->dwTo); dprintf_cdaudio(stddeb, "CDAUDIO_mciPlay // MCI_TO=%08lX -> %u \n", lpParms->dwTo, end); } - start += CDADev[index].dwFirstOffset; - end += CDADev[index].dwFirstOffset; + start += CDADev[wDevID].dwFirstOffset; + end += CDADev[wDevID].dwFirstOffset; #ifdef linux msf.cdmsf_min0 = start / CDFRAMES_PERMIN; msf.cdmsf_sec0 = (start % CDFRAMES_PERMIN) / CDFRAMES_PERSEC; @@ -770,7 +759,7 @@ static DWORD CDAUDIO_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpPa msf.end_s = (end % CDFRAMES_PERMIN) / CDFRAMES_PERSEC; msf.end_f = end % CDFRAMES_PERSEC; #endif - if (ioctl(CDADev[index].unixdev, + if (ioctl(CDADev[wDevID].unixdev, #ifdef linux CDROMSTART #elif __FreeBSD__ @@ -780,7 +769,7 @@ static DWORD CDAUDIO_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpPa dprintf_cdaudio(stddeb,"CDAUDIO_mciPlay // motor doesn't start !\n"); return MCIERR_HARDWARE; } - if (ioctl(CDADev[index].unixdev, + if (ioctl(CDADev[wDevID].unixdev, #ifdef linux CDROMPLAYMSF #elif __FreeBSD__ @@ -799,14 +788,14 @@ static DWORD CDAUDIO_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpPa msf.end_m, msf.end_s, msf.end_f #endif ); - CDADev[index].mode = MCI_MODE_PLAY; + CDADev[wDevID].mode = MCI_MODE_PLAY; if (dwFlags & MCI_NOTIFY) { dprintf_cdaudio(stddeb, "CDAUDIO_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); /* mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - CDADev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); */ } return 0; @@ -821,24 +810,23 @@ static DWORD CDAUDIO_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpPa static DWORD CDAUDIO_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_cdaudio(stddeb,"CDAUDIO_mciStop(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - if (ioctl(CDADev[index].unixdev, + if (ioctl(CDADev[wDevID].unixdev, #ifdef linux CDROMSTOP #elif __FreeBSD__ CDIOCSTOP #endif )) return MCIERR_HARDWARE; - CDADev[index].mode = MCI_MODE_STOP; + CDADev[wDevID].mode = MCI_MODE_STOP; if (dwFlags & MCI_NOTIFY) { dprintf_cdaudio(stddeb, "CDAUDIO_mciStop // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - CDADev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -852,24 +840,23 @@ static DWORD CDAUDIO_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS l static DWORD CDAUDIO_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_cdaudio(stddeb,"CDAUDIO_mciPause(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - if (ioctl(CDADev[index].unixdev, + if (ioctl(CDADev[wDevID].unixdev, #ifdef linux CDROMPAUSE #elif __FreeBSD__ CDIOCPAUSE #endif )) return MCIERR_HARDWARE; - CDADev[index].mode = MCI_MODE_PAUSE; + CDADev[wDevID].mode = MCI_MODE_PAUSE; if (dwFlags & MCI_NOTIFY) { dprintf_cdaudio(stddeb, "CDAUDIO_mciPause // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - CDADev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -883,24 +870,23 @@ static DWORD CDAUDIO_mciPause(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS static DWORD CDAUDIO_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_cdaudio(stddeb,"CDAUDIO_mciResume(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - if (ioctl(CDADev[index].unixdev, + if (ioctl(CDADev[wDevID].unixdev, #ifdef linux CDROMRESUME #elif __FreeBSD__ CDIOCRESUME #endif )) return MCIERR_HARDWARE; - CDADev[index].mode = MCI_MODE_STOP; + CDADev[wDevID].mode = MCI_MODE_STOP; if (dwFlags & MCI_NOTIFY) { dprintf_cdaudio(stddeb, "CDAUDIO_mciResume // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - CDADev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -914,13 +900,12 @@ static DWORD CDAUDIO_mciResume(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS static DWORD CDAUDIO_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); DWORD dwRet; MCI_PLAY_PARMS PlayParms; dprintf_cdaudio(stddeb,"CDAUDIO_mciSeek(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - if (ioctl(CDADev[index].unixdev, + if (ioctl(CDADev[wDevID].unixdev, #ifdef linux CDROMRESUME #elif __FreeBSD__ @@ -930,13 +915,13 @@ static DWORD CDAUDIO_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpPa perror("ioctl CDROMRESUME"); return MCIERR_HARDWARE; } - CDADev[index].mode = MCI_MODE_SEEK; + CDADev[wDevID].mode = MCI_MODE_SEEK; switch(dwFlags) { case MCI_SEEK_TO_START: PlayParms.dwFrom = 0; break; case MCI_SEEK_TO_END: - PlayParms.dwFrom = CDADev[index].dwTotalLen; + PlayParms.dwFrom = CDADev[wDevID].dwTotalLen; break; case MCI_TO: PlayParms.dwFrom = lpParms->dwTo; @@ -950,7 +935,7 @@ static DWORD CDAUDIO_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpPa "CDAUDIO_mciSeek // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - CDADev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return dwRet; #else @@ -965,7 +950,6 @@ static DWORD CDAUDIO_mciSeek(UINT16 wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpPa static DWORD CDAUDIO_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_cdaudio(stddeb,"CDAUDIO_mciSet(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; @@ -989,32 +973,32 @@ static DWORD CDAUDIO_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParm dprintf_cdaudio(stddeb,"CDAUDIO_mciSet // bad time format !\n"); return MCIERR_BAD_TIME_FORMAT; } - CDADev[index].dwTimeFormat = lpParms->dwTimeFormat; + CDADev[wDevID].dwTimeFormat = lpParms->dwTimeFormat; } if (dwFlags & MCI_SET_DOOR_OPEN) { dprintf_cdaudio(stddeb, "CDAUDIO_mciSet // MCI_SET_DOOR_OPEN !\n"); #ifdef __FreeBSD__ - if (ioctl(CDADev[index].unixdev, CDIOCALLOW)) return MCIERR_HARDWARE; - if (ioctl(CDADev[index].unixdev, CDIOCEJECT)) return MCIERR_HARDWARE; - if (ioctl(CDADev[index].unixdev, CDIOCPREVENT)) return MCIERR_HARDWARE; + if (ioctl(CDADev[wDevID].unixdev, CDIOCALLOW)) return MCIERR_HARDWARE; + if (ioctl(CDADev[wDevID].unixdev, CDIOCEJECT)) return MCIERR_HARDWARE; + if (ioctl(CDADev[wDevID].unixdev, CDIOCPREVENT)) return MCIERR_HARDWARE; #elif linux - if (ioctl(CDADev[index].unixdev, CDROMEJECT)) return MCIERR_HARDWARE; + if (ioctl(CDADev[wDevID].unixdev, CDROMEJECT)) return MCIERR_HARDWARE; #endif - CDADev[index].nTracks = 0; + CDADev[wDevID].nTracks = 0; } if (dwFlags & MCI_SET_DOOR_CLOSED) { dprintf_cdaudio(stddeb, "CDAUDIO_mciSet // MCI_SET_DOOR_CLOSED !\n"); #ifdef __FreeBSD__ - if (ioctl(CDADev[index].unixdev, CDIOCALLOW)) return MCIERR_HARDWARE; - if (ioctl(CDADev[index].unixdev, CDIOCCLOSE)) return MCIERR_HARDWARE; - if (ioctl(CDADev[index].unixdev, CDIOCPREVENT)) return MCIERR_HARDWARE; + if (ioctl(CDADev[wDevID].unixdev, CDIOCALLOW)) return MCIERR_HARDWARE; + if (ioctl(CDADev[wDevID].unixdev, CDIOCCLOSE)) return MCIERR_HARDWARE; + if (ioctl(CDADev[wDevID].unixdev, CDIOCPREVENT)) return MCIERR_HARDWARE; #elif linux - if (ioctl(CDADev[index].unixdev, CDROMEJECT)) return MCIERR_HARDWARE; + if (ioctl(CDADev[wDevID].unixdev, CDROMEJECT)) return MCIERR_HARDWARE; /* XXX should it be ",1" ??? */ #endif - CDADev[index].nTracks = 0; + CDADev[wDevID].nTracks = 0; } if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION; if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION; @@ -1024,7 +1008,7 @@ static DWORD CDAUDIO_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParm "CDAUDIO_mciSet // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - CDADev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else diff --git a/multimedia/mcistring.c b/multimedia/mcistring.c index f61679cb0d..429f2b2365 100644 --- a/multimedia/mcistring.c +++ b/multimedia/mcistring.c @@ -311,6 +311,7 @@ MCISTR_Open(_MCISTR_PROTO_) { if (s!=NULL) { *s++='\0'; pU->openParams.lpstrElementName=SEGPTR_GET(SEGPTR_STRDUP(s)); + dwFlags |= MCI_OPEN_ELEMENT; } if (!STRCMP(dev,"cdaudio")) { uDevTyp=MCI_DEVTYPE_CD_AUDIO; @@ -338,7 +339,7 @@ MCISTR_Open(_MCISTR_PROTO_) { } } GetDrv(wDevID)->wType = uDevTyp; - GetDrv(wDevID)->wDeviceID = wDevID; + GetDrv(wDevID)->wDeviceID = 0; /* FIXME? for multiple devices */ pU->openParams.dwCallback = 0; pU->openParams.wDeviceID = wDevID; pU->ovlyopenParams.dwStyle = 0; diff --git a/multimedia/midi.c b/multimedia/midi.c index 7a52f87f7f..a4446e3413 100644 --- a/multimedia/midi.c +++ b/multimedia/midi.c @@ -11,6 +11,7 @@ #include #include "windows.h" #include "ldt.h" +#include "user.h" #include "driver.h" #include "mmsystem.h" #include "xmalloc.h" @@ -24,8 +25,6 @@ #include #endif -int MMSYSTEM_DevIDToIndex(UINT16); - #if defined(linux) || defined(__FreeBSD__) #define MIDI_DEV "/dev/sequencer" @@ -35,9 +34,9 @@ int MMSYSTEM_DevIDToIndex(UINT16); #define IOCTL(a,b,c) (c = ioctl(a,b,c) ) #endif -#define MAX_MIDIINDRV 2 -#define MAX_MIDIOUTDRV 2 -#define MAX_MCIMIDIDRV 2 +#define MAX_MIDIINDRV (1) +#define MAX_MIDIOUTDRV (1) +#define MAX_MCIMIDIDRV (1) typedef struct { int unixdev; @@ -71,7 +70,8 @@ typedef struct { WORD nTracks; WORD nTempo; MCI_OPEN_PARMS openParms; - MIDIHDR MidiHdr; +/* MIDIHDR MidiHdr; */ + HLOCAL16 hMidiHdr; WORD dwStatus; } LINUX_MCIMIDI; @@ -88,11 +88,10 @@ static DWORD MIDI_NotifyClient(UINT16 wDevID, WORD wMsg, DWORD dwParam1, DWORD dwParam2) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); - if (MidiInDev[index].wFlags != DCB_NULL && !DriverCallback( - MidiInDev[index].midiDesc.dwCallback, MidiInDev[index].wFlags, - MidiInDev[index].midiDesc.hMidi, wMsg, - MidiInDev[index].midiDesc.dwInstance, dwParam1, dwParam2)) { + if (MidiInDev[wDevID].wFlags != DCB_NULL && !DriverCallback( + MidiInDev[wDevID].midiDesc.dwCallback, MidiInDev[wDevID].wFlags, + MidiInDev[wDevID].midiDesc.hMidi, wMsg, + MidiInDev[wDevID].midiDesc.dwInstance, dwParam1, dwParam2)) { dprintf_midi(stddeb, "MIDI_NotifyClient // can't notify client !\n"); return MMSYSERR_NOERROR; } @@ -108,10 +107,9 @@ static DWORD MIDI_NotifyClient(UINT16 wDevID, WORD wMsg, */ static DWORD MIDI_ReadByte(UINT16 wDevID, BYTE *lpbyt) { - int index = MMSYSTEM_DevIDToIndex(wDevID); #if defined(linux) || defined(__FreeBSD__) if (lpbyt != NULL) { - if (mmioRead(MCIMidiDev[index].hFile, (HPSTR)lpbyt, + if (mmioRead(MCIMidiDev[wDevID].hFile, (HPSTR)lpbyt, (long) sizeof(BYTE)) == (long) sizeof(BYTE)) { return 0; } @@ -197,34 +195,33 @@ static DWORD MIDI_ReadVaryLen(UINT16 wDevID, LPDWORD lpdw) static DWORD MIDI_ReadMThd(UINT16 wDevID, DWORD dwOffset) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); DWORD toberead; FOURCC fourcc; dprintf_midi(stddeb, "MIDI_ReadMThd(%04X, %08lX);\n", wDevID, dwOffset); - if (mmioSeek(MCIMidiDev[index].hFile, dwOffset, SEEK_SET) != dwOffset) { + if (mmioSeek(MCIMidiDev[wDevID].hFile, dwOffset, SEEK_SET) != dwOffset) { dprintf_midi(stddeb, "MIDI_ReadMThd // can't seek at %08lX begin of 'MThd' \n", dwOffset); return MCIERR_INTERNAL; } - if (mmioRead(MCIMidiDev[index].hFile, (HPSTR)&fourcc, + if (mmioRead(MCIMidiDev[wDevID].hFile, (HPSTR)&fourcc, (long) sizeof(FOURCC)) != (long) sizeof(FOURCC)) { return MCIERR_INTERNAL; } if (MIDI_ReadLong(wDevID, &toberead) != 0) { return MCIERR_INTERNAL; } - if (MIDI_ReadWord(wDevID, &MCIMidiDev[index].wFormat) != 0) { + if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].wFormat) != 0) { return MCIERR_INTERNAL; } - if (MIDI_ReadWord(wDevID, &MCIMidiDev[index].nTracks) != 0) { + if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].nTracks) != 0) { return MCIERR_INTERNAL; } - if (MIDI_ReadWord(wDevID, &MCIMidiDev[index].nTempo) != 0) { + if (MIDI_ReadWord(wDevID, &MCIMidiDev[wDevID].nTempo) != 0) { return MCIERR_INTERNAL; } dprintf_midi(stddeb, "MIDI_ReadMThd // toberead=%08lX, wFormat=%04X nTracks=%04X nTempo=%04X\n", - toberead, MCIMidiDev[index].wFormat, - MCIMidiDev[index].nTracks, - MCIMidiDev[index].nTempo); + toberead, MCIMidiDev[wDevID].wFormat, + MCIMidiDev[wDevID].nTracks, + MCIMidiDev[wDevID].nTempo); toberead -= 3 * sizeof(WORD); /* ntrks = read16bit (); @@ -241,13 +238,12 @@ static DWORD MIDI_ReadMThd(UINT16 wDevID, DWORD dwOffset) static DWORD MIDI_ReadMTrk(UINT16 wDevID, DWORD dwOffset) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); DWORD toberead; FOURCC fourcc; - if (mmioSeek(MCIMidiDev[index].hFile, dwOffset, SEEK_SET) != dwOffset) { + if (mmioSeek(MCIMidiDev[wDevID].hFile, dwOffset, SEEK_SET) != dwOffset) { dprintf_midi(stddeb, "MIDI_ReadMTrk // can't seek at %08lX begin of 'MThd' \n", dwOffset); } - if (mmioRead(MCIMidiDev[index].hFile, (HPSTR)&fourcc, + if (mmioRead(MCIMidiDev[wDevID].hFile, (HPSTR)&fourcc, (long) sizeof(FOURCC)) != (long) sizeof(FOURCC)) { return MCIERR_INTERNAL; } @@ -256,7 +252,7 @@ static DWORD MIDI_ReadMTrk(UINT16 wDevID, DWORD dwOffset) } dprintf_midi(stddeb, "MIDI_ReadMTrk // toberead=%08lX\n", toberead); toberead -= 3 * sizeof(WORD); - MCIMidiDev[index].dwTotalLen = toberead; + MCIMidiDev[wDevID].dwTotalLen = toberead; return 0; #else return MMSYSERR_NOTENABLED; @@ -270,7 +266,6 @@ static DWORD MIDI_ReadMTrk(UINT16 wDevID, DWORD dwOffset) static DWORD MIDI_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index; MIDIOPENDESC MidiDesc; DWORD dwRet; DWORD dwOffset; @@ -280,24 +275,22 @@ static DWORD MIDI_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms dprintf_midi(stddeb, "MIDI_mciOpen(%08lX, %p)\n", dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - wDevID = lpParms->wDeviceID; - index = MMSYSTEM_DevIDToIndex(wDevID); - - if (MCIMidiDev[index].nUseCount > 0) { + if (MCIMidiDev[wDevID].nUseCount > 0) { /* The driver already open on this channel */ /* If the driver was opened shareable before and this open specifies */ /* shareable then increment the use count */ - if (MCIMidiDev[index].fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) - ++MCIMidiDev[index].nUseCount; + if (MCIMidiDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE)) + ++MCIMidiDev[wDevID].nUseCount; else return MCIERR_MUST_USE_SHAREABLE; } else { - MCIMidiDev[index].nUseCount = 1; - MCIMidiDev[index].fShareable = dwFlags & MCI_OPEN_SHAREABLE; + MCIMidiDev[wDevID].nUseCount = 1; + MCIMidiDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE; + MCIMidiDev[wDevID].hMidiHdr = USER_HEAP_ALLOC(sizeof(MIDIHDR)); } dprintf_midi(stddeb, "MIDI_mciOpen // wDevID=%04X\n", wDevID); - lpParms->wDeviceID = wDevID; +/* lpParms->wDeviceID = wDevID;*/ dprintf_midi(stddeb, "MIDI_mciOpen // lpParms->wDevID=%04X\n", lpParms->wDeviceID); dprintf_midi(stddeb, "MIDI_mciOpen // before OPEN_ELEMENT\n"); if (dwFlags & MCI_OPEN_ELEMENT) { @@ -306,26 +299,26 @@ static DWORD MIDI_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms if (strlen(lpstrElementName) > 0) { strcpy(str, lpstrElementName); CharUpper32A(str); - MCIMidiDev[index].hFile = mmioOpen(str, NULL, + MCIMidiDev[wDevID].hFile = mmioOpen(str, NULL, MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_EXCLUSIVE); - if (MCIMidiDev[index].hFile == 0) { + if (MCIMidiDev[wDevID].hFile == 0) { dprintf_midi(stddeb, "MIDI_mciOpen // can't find file='%s' !\n", str); return MCIERR_FILE_NOT_FOUND; } } else - MCIMidiDev[index].hFile = 0; + MCIMidiDev[wDevID].hFile = 0; } - dprintf_midi(stddeb, "MIDI_mciOpen // hFile=%u\n", MCIMidiDev[index].hFile); - memcpy(&MCIMidiDev[index].openParms, lpParms, sizeof(MCI_OPEN_PARMS)); - MCIMidiDev[index].wNotifyDeviceID = lpParms->wDeviceID; - MCIMidiDev[index].dwStatus = MCI_MODE_STOP; - MCIMidiDev[index].dwBeginData = 0; - MCIMidiDev[index].dwTotalLen = 0; + dprintf_midi(stddeb, "MIDI_mciOpen // hFile=%u\n", MCIMidiDev[wDevID].hFile); + memcpy(&MCIMidiDev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS)); + MCIMidiDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID; + MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; + MCIMidiDev[wDevID].dwBeginData = 0; + MCIMidiDev[wDevID].dwTotalLen = 0; MidiDesc.hMidi = 0; - if (MCIMidiDev[index].hFile != 0) { + if (MCIMidiDev[wDevID].hFile != 0) { MMCKINFO ckMainRIFF; - if (mmioDescend(MCIMidiDev[index].hFile, &ckMainRIFF, NULL, 0) != 0) { + if (mmioDescend(MCIMidiDev[wDevID].hFile, &ckMainRIFF, NULL, 0) != 0) { return MCIERR_INTERNAL; } dprintf_midi(stddeb,"MIDI_mciOpen // ParentChunk ckid=%.4s fccType=%.4s cksize=%08lX \n", @@ -344,19 +337,19 @@ static DWORD MIDI_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms dprintf_midi(stddeb, "MIDI_mciOpen // can't read 'MThd' header \n"); return MCIERR_INTERNAL; } - dwOffset = mmioSeek(MCIMidiDev[index].hFile, 0, SEEK_CUR); + dwOffset = mmioSeek(MCIMidiDev[wDevID].hFile, 0, SEEK_CUR); if (MIDI_ReadMTrk(wDevID, dwOffset) != 0) { dprintf_midi(stddeb, "MIDI_mciOpen // can't read 'MTrk' header \n"); return MCIERR_INTERNAL; } - dwOffset = mmioSeek(MCIMidiDev[index].hFile, 0, SEEK_CUR); - MCIMidiDev[index].dwBeginData = dwOffset; + dwOffset = mmioSeek(MCIMidiDev[wDevID].hFile, 0, SEEK_CUR); + MCIMidiDev[wDevID].dwBeginData = dwOffset; dprintf_midi(stddeb, "MIDI_mciOpen // Chunk Found ckid=%.4s fccType=%.4s cksize=%08lX \n", (LPSTR)&ckMainRIFF.ckid, (LPSTR)&ckMainRIFF.fccType, ckMainRIFF.cksize); } dwRet = modMessage(wDevID, MODM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL); - dwRet = midMessage(wDevID, MIDM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL); +/* dwRet = midMessage(wDevID, MIDM_OPEN, 0, (DWORD)&MidiDesc, CALLBACK_NULL); */ return 0; #else return MMSYSERR_NOTENABLED; @@ -370,12 +363,11 @@ static DWORD MIDI_mciOpen(UINT16 wDevID, DWORD dwFlags, LPMCI_OPEN_PARMS lpParms static DWORD MIDI_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_midi(stddeb, "MIDI_mciStop(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; - MCIMidiDev[index].dwStatus = MCI_MODE_STOP; - dprintf_midi(stddeb, "MIDI_mciStop // MCIMidiDev[index].dwStatus=%p %d\n", - &MCIMidiDev[index].dwStatus, MCIMidiDev[index].dwStatus); + MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; + dprintf_midi(stddeb, "MIDI_mciStop // MCIMidiDev[wDevID].dwStatus=%p %d\n", + &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus); return 0; #else return MCIERR_INTERNAL; @@ -389,24 +381,27 @@ static DWORD MIDI_mciStop(UINT16 wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpPa static DWORD MIDI_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); DWORD dwRet; + dprintf_midi(stddeb, "MIDI_mciClose(%04X, %08lX, %p);\n", wDevID, dwParam, lpParms); - if (MCIMidiDev[index].dwStatus != MCI_MODE_STOP) { + if (MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) { MIDI_mciStop(wDevID, MCI_WAIT, lpParms); } - MCIMidiDev[index].dwStatus = MCI_MODE_STOP; - MCIMidiDev[index].nUseCount--; - if (MCIMidiDev[index].nUseCount == 0) { - if (MCIMidiDev[index].hFile != 0) { - mmioClose(MCIMidiDev[index].hFile, 0); - MCIMidiDev[index].hFile = 0; + MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; + MCIMidiDev[wDevID].nUseCount--; + if (MCIMidiDev[wDevID].nUseCount == 0) { + if (MCIMidiDev[wDevID].hFile != 0) { + mmioClose(MCIMidiDev[wDevID].hFile, 0); + MCIMidiDev[wDevID].hFile = 0; dprintf_midi(stddeb, "MIDI_mciClose // hFile closed !\n"); } + USER_HEAP_FREE(MCIMidiDev[wDevID].hMidiHdr); dwRet = modMessage(wDevID, MODM_CLOSE, 0, 0L, 0L); if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL; +/* dwRet = midMessage(wDevID, MIDM_CLOSE, 0, 0L, 0L); if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL; +*/ } return 0; #else @@ -421,17 +416,18 @@ static DWORD MIDI_mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpP static DWORD MIDI_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); int count; int start, end; LPMIDIHDR lpMidiHdr; + DWORD lp16MidiHdr; DWORD dwData; LPWORD ptr; DWORD dwRet; + dprintf_midi(stddeb, "MIDI_mciPlay(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); - if (MCIMidiDev[index].hFile == 0) { + if (MCIMidiDev[wDevID].hFile == 0) { dprintf_midi(stddeb, "MIDI_mciPlay // can't find file='%08lx' !\n", - MCIMidiDev[index].openParms.lpstrElementName); + MCIMidiDev[wDevID].openParms.lpstrElementName); return MCIERR_FILE_NOT_FOUND; } start = 1; end = 99999; @@ -459,51 +455,80 @@ static DWORD MIDI_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms } } #endif - lpMidiHdr = &MCIMidiDev[index].MidiHdr; + + lpMidiHdr = USER_HEAP_LIN_ADDR(MCIMidiDev[wDevID].hMidiHdr); + lp16MidiHdr = USER_HEAP_SEG_ADDR(MCIMidiDev[wDevID].hMidiHdr); + lpMidiHdr->lpData = (LPSTR) malloc(1200); if (lpMidiHdr->lpData == NULL) return MCIERR_INTERNAL; lpMidiHdr->dwBufferLength = 1024; lpMidiHdr->dwUser = 0L; lpMidiHdr->dwFlags = 0L; - dwRet = modMessage(wDevID, MODM_PREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); + dwRet = modMessage(wDevID, MODM_PREPARE, 0, (DWORD)lp16MidiHdr, sizeof(MIDIHDR)); + /* dprintf_midi(stddeb, "MIDI_mciPlay // after MODM_PREPARE \n"); */ - MCIMidiDev[index].dwStatus = MCI_MODE_PLAY; - while(MCIMidiDev[index].dwStatus != MCI_MODE_STOP) { - dprintf_midi(stddeb, "MIDI_mciPlay // MCIMidiDev[index].dwStatus=%p %d\n", - &MCIMidiDev[index].dwStatus, MCIMidiDev[index].dwStatus); + + MCIMidiDev[wDevID].dwStatus = MCI_MODE_PLAY; + while(MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) { + dprintf_midi(stddeb, "MIDI_mciPlay // MCIMidiDev[wDevID].dwStatus=%p %d\n", + &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus); + ptr = (LPWORD)lpMidiHdr->lpData; for (count = 0; count < lpMidiHdr->dwBufferLength; count++) { if (MIDI_ReadVaryLen(wDevID, &dwData) != 0) break; *ptr = LOWORD(dwData); } /* - count = mmioRead(MCIMidiDev[index].hFile, lpMidiHdr->lpData, lpMidiHdr->dwBufferLength); + count = mmioRead(MCIMidiDev[wDevID].hFile, lpMidiHdr->lpData, lpMidiHdr->dwBufferLength); */ + dprintf_midi(stddeb, "MIDI_mciPlay // after read count = %d\n",count); + if (count < 1) break; lpMidiHdr->dwBytesRecorded = count; dprintf_midi(stddeb, "MIDI_mciPlay // before MODM_LONGDATA lpMidiHdr=%p dwBytesRecorded=%lu\n", lpMidiHdr, lpMidiHdr->dwBytesRecorded); - dwRet = modMessage(wDevID, MODM_LONGDATA, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); + dwRet = modMessage(wDevID, MODM_LONGDATA, 0, (DWORD)lp16MidiHdr, sizeof(MIDIHDR)); + if (dwRet != MMSYSERR_NOERROR) { + switch (dwRet) { + case MMSYSERR_NOTENABLED: + return MCIERR_DEVICE_NOT_READY; + + case MIDIERR_NODEVICE: + return MCIERR_INVALID_DEVICE_ID; + + case MIDIERR_UNPREPARED: + return MCIERR_DRIVER_INTERNAL; + + case MIDIERR_STILLPLAYING: + return MCIERR_SEQ_PORT_INUSE; + + case MMSYSERR_INVALPARAM: + return MCIERR_CANNOT_LOAD_DRIVER; + + default: + return MCIERR_DRIVER; + } } - dwRet = modMessage(wDevID, MODM_UNPREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); + } + dwRet = modMessage(wDevID, MODM_UNPREPARE, 0, (DWORD)lp16MidiHdr, sizeof(MIDIHDR)); if (lpMidiHdr->lpData != NULL) { free(lpMidiHdr->lpData); lpMidiHdr->lpData = NULL; - } - MCIMidiDev[index].dwStatus = MCI_MODE_STOP; + } + MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; if (dwFlags & MCI_NOTIFY) { dprintf_midi(stddeb, "MIDI_mciPlay // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - MCIMidiDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); #if 0 exit(1); #endif - } + } return 0; #else return MMSYSERR_NOTENABLED; #endif -} + } /************************************************************************** @@ -512,15 +537,14 @@ static DWORD MIDI_mciPlay(UINT16 wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms static DWORD MIDI_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); int start, end; LPMIDIHDR lpMidiHdr; DWORD dwRet; dprintf_midi(stddeb, "MIDI_mciRecord(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); - if (MCIMidiDev[index].hFile == 0) { + if (MCIMidiDev[wDevID].hFile == 0) { dprintf_midi(stddeb, "MIDI_mciRecord // can't find file='%08lx' !\n", - MCIMidiDev[index].openParms.lpstrElementName); + MCIMidiDev[wDevID].openParms.lpstrElementName); return MCIERR_FILE_NOT_FOUND; } start = 1; end = 99999; @@ -532,17 +556,17 @@ static DWORD MIDI_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpP end = lpParms->dwTo; dprintf_midi(stddeb, "MIDI_mciRecord // MCI_TO=%d \n", end); } - lpMidiHdr = &MCIMidiDev[index].MidiHdr; + lpMidiHdr = USER_HEAP_LIN_ADDR(MCIMidiDev[wDevID].hMidiHdr); lpMidiHdr->lpData = (LPSTR) xmalloc(1200); lpMidiHdr->dwBufferLength = 1024; lpMidiHdr->dwUser = 0L; lpMidiHdr->dwFlags = 0L; dwRet = midMessage(wDevID, MIDM_PREPARE, 0, (DWORD)lpMidiHdr, sizeof(MIDIHDR)); dprintf_midi(stddeb, "MIDI_mciRecord // after MIDM_PREPARE \n"); - MCIMidiDev[index].dwStatus = MCI_MODE_RECORD; - while(MCIMidiDev[index].dwStatus != MCI_MODE_STOP) { - dprintf_midi(stddeb, "MIDI_mciRecord // MCIMidiDev[index].dwStatus=%p %d\n", - &MCIMidiDev[index].dwStatus, MCIMidiDev[index].dwStatus); + MCIMidiDev[wDevID].dwStatus = MCI_MODE_RECORD; + while(MCIMidiDev[wDevID].dwStatus != MCI_MODE_STOP) { + dprintf_midi(stddeb, "MIDI_mciRecord // MCIMidiDev[wDevID].dwStatus=%p %d\n", + &MCIMidiDev[wDevID].dwStatus, MCIMidiDev[wDevID].dwStatus); lpMidiHdr->dwBytesRecorded = 0; dwRet = midMessage(wDevID, MIDM_START, 0, 0L, 0L); dprintf_midi(stddeb, "MIDI_mciRecord // after MIDM_START lpMidiHdr=%p dwBytesRecorded=%lu\n", @@ -556,11 +580,11 @@ static DWORD MIDI_mciRecord(UINT16 wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpP free(lpMidiHdr->lpData); lpMidiHdr->lpData = NULL; } - MCIMidiDev[index].dwStatus = MCI_MODE_STOP; + MCIMidiDev[wDevID].dwStatus = MCI_MODE_STOP; if (dwFlags & MCI_NOTIFY) { dprintf_midi(stddeb, "MIDI_mciRecord // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - MCIMidiDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -671,7 +695,6 @@ static DWORD MIDI_mciSet(UINT16 wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms) static DWORD MIDI_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_midi(stddeb, "MIDI_mciStatus(%04X, %08lX, %p);\n", wDevID, dwFlags, lpParms); if (lpParms == NULL) return MCIERR_INTERNAL; if (dwFlags & MCI_STATUS_ITEM) { @@ -746,7 +769,7 @@ static DWORD MIDI_mciStatus(UINT16 wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpP if (dwFlags & MCI_NOTIFY) { dprintf_midi(stddeb, "MIDI_mciStatus // MCI_NOTIFY_SUCCESSFUL %08lX !\n", lpParms->dwCallback); mciDriverNotify((HWND16)LOWORD(lpParms->dwCallback), - MCIMidiDev[index].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); + MCIMidiDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL); } return 0; #else @@ -850,7 +873,6 @@ static DWORD midGetDevCaps(WORD wDevID, LPMIDIINCAPS lpCaps, DWORD dwSize) static DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); int midi; dprintf_midi(stddeb, "midOpen(%04X, %p, %08lX);\n", wDevID, lpDesc, dwFlags); @@ -858,18 +880,18 @@ static DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags) dprintf_midi(stddeb,"Linux 'midOpen' // Invalid Parameter !\n"); return MMSYSERR_INVALPARAM; } - if (index >= MAX_MIDIINDRV) { + if (wDevID >= MAX_MIDIINDRV) { dprintf_midi(stddeb,"Linux 'midOpen' // MAX_MIDIINDRV reached !\n"); return MMSYSERR_ALLOCATED; } - MidiInDev[index].unixdev = 0; + MidiInDev[wDevID].unixdev = 0; midi = open (MIDI_DEV, O_RDONLY, 0); if (midi == -1) { dprintf_midi(stddeb,"Linux 'midOpen' // can't open !\n"); return MMSYSERR_NOTENABLED; } - MidiInDev[index].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK); - switch(MidiInDev[index].wFlags) { + MidiInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK); + switch(MidiInDev[wDevID].wFlags) { case DCB_NULL: dprintf_midi(stddeb,"Linux 'midOpen' // CALLBACK_NULL !\n"); break; @@ -886,10 +908,10 @@ static DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags) "Linux 'midOpen' // CALLBACK_FUNCTION !\n"); break; } - MidiInDev[index].lpQueueHdr = NULL; - MidiInDev[index].unixdev = midi; - MidiInDev[index].dwTotalPlayed = 0; - MidiInDev[index].bufsize = 0x3FFF; + MidiInDev[wDevID].lpQueueHdr = NULL; + MidiInDev[wDevID].unixdev = midi; + MidiInDev[wDevID].dwTotalPlayed = 0; + MidiInDev[wDevID].bufsize = 0x3FFF; if (MIDI_NotifyClient(wDevID, MIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) { dprintf_midi(stddeb,"Linux 'midOpen' // can't notify client !\n"); return MMSYSERR_INVALPARAM; @@ -906,15 +928,14 @@ static DWORD midOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags) static DWORD midClose(WORD wDevID) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_midi(stddeb, "midClose(%04X);\n", wDevID); - if (MidiInDev[index].unixdev == 0) { + if (MidiInDev[wDevID].unixdev == 0) { dprintf_midi(stddeb,"Linux 'midClose' // can't close !\n"); return MMSYSERR_NOTENABLED; } - close(MidiInDev[index].unixdev); - MidiInDev[index].unixdev = 0; - MidiInDev[index].bufsize = 0; + close(MidiInDev[wDevID].unixdev); + MidiInDev[wDevID].unixdev = 0; + MidiInDev[wDevID].bufsize = 0; if (MIDI_NotifyClient(wDevID, MIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) { dprintf_midi(stddeb,"Linux 'midClose' // can't notify client !\n"); return MMSYSERR_INVALPARAM; @@ -1034,28 +1055,28 @@ static DWORD modGetDevCaps(WORD wDevID, LPMIDIOUTCAPS lpCaps, DWORD dwSize) * modOpen [internal] */ static DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags) -{ +{ #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); int midi; + dprintf_midi(stddeb, "modOpen(%04X, %p, %08lX);\n", wDevID, lpDesc, dwFlags); if (lpDesc == NULL) { dprintf_midi(stddeb,"Linux 'modOpen' // Invalid Parameter !\n"); return MMSYSERR_INVALPARAM; } - if (index >= MAX_MIDIOUTDRV) { + if (wDevID>= MAX_MIDIOUTDRV) { dprintf_midi(stddeb,"Linux 'modOpen' // MAX_MIDIOUTDRV reached !\n"); return MMSYSERR_ALLOCATED; } - MidiOutDev[index].unixdev = 0; + MidiOutDev[wDevID].unixdev = 0; midi = open (MIDI_DEV, O_WRONLY, 0); if (midi == -1) { dprintf_midi(stddeb,"Linux 'modOpen' // can't open !\n"); return MMSYSERR_NOTENABLED; } - MidiOutDev[index].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK); - switch(MidiOutDev[index].wFlags) { + MidiOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK); + switch(MidiOutDev[wDevID].wFlags) { case DCB_NULL: dprintf_midi(stddeb,"Linux 'modOpen' // CALLBACK_NULL !\n"); break; @@ -1072,10 +1093,10 @@ static DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags) "Linux 'modOpen' // CALLBACK_FUNCTION !\n"); break; } - MidiOutDev[index].lpQueueHdr = NULL; - MidiOutDev[index].unixdev = midi; - MidiOutDev[index].dwTotalPlayed = 0; - MidiOutDev[index].bufsize = 0x3FFF; + MidiOutDev[wDevID].lpQueueHdr = NULL; + MidiOutDev[wDevID].unixdev = midi; + MidiOutDev[wDevID].dwTotalPlayed = 0; + MidiOutDev[wDevID].bufsize = 0x3FFF; if (MIDI_NotifyClient(wDevID, MOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) { dprintf_midi(stddeb,"Linux 'modOpen' // can't notify client !\n"); return MMSYSERR_INVALPARAM; @@ -1095,15 +1116,14 @@ static DWORD modOpen(WORD wDevID, LPMIDIOPENDESC lpDesc, DWORD dwFlags) static DWORD modClose(WORD wDevID) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_midi(stddeb, "modClose(%04X);\n", wDevID); - if (MidiOutDev[index].unixdev == 0) { + if (MidiOutDev[wDevID].unixdev == 0) { dprintf_midi(stddeb,"Linux 'modClose' // can't close !\n"); return MMSYSERR_NOTENABLED; } - close(MidiOutDev[index].unixdev); - MidiOutDev[index].unixdev = 0; - MidiOutDev[index].bufsize = 0; + close(MidiOutDev[wDevID].unixdev); + MidiOutDev[wDevID].unixdev = 0; + MidiOutDev[wDevID].bufsize = 0; if (MIDI_NotifyClient(wDevID, MOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) { dprintf_midi(stddeb,"Linux 'modClose' // can't notify client !\n"); return MMSYSERR_INVALPARAM; @@ -1120,16 +1140,16 @@ static DWORD modClose(WORD wDevID) static DWORD modData(WORD wDevID, DWORD dwParam) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); WORD event; + dprintf_midi(stddeb, "modData(%04X, %08lX);\n", wDevID, dwParam); - if (MidiOutDev[index].unixdev == 0) { + if (MidiOutDev[wDevID].unixdev == 0) { dprintf_midi(stddeb,"Linux 'modData' // can't play !\n"); return MIDIERR_NODEVICE; } event = LOWORD(dwParam); - if (write (MidiOutDev[index].unixdev, + if (write (MidiOutDev[wDevID].unixdev, &event, sizeof(WORD)) != sizeof(WORD)) { dprintf_midi(stddeb, "modData() // error writting unixdev !\n"); @@ -1146,12 +1166,13 @@ static DWORD modData(WORD wDevID, DWORD dwParam) static DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); int count; LPWORD ptr; + int en; + dprintf_midi(stddeb, "modLongData(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize); - if (MidiOutDev[index].unixdev == 0) { + if (MidiOutDev[wDevID].unixdev == 0) { dprintf_midi(stddeb,"Linux 'modLongData' // can't play !\n"); return MIDIERR_NODEVICE; } @@ -1162,20 +1183,30 @@ static DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) lpMidiHdr->dwFlags |= MHDR_INQUEUE; dprintf_midi(stddeb, "modLongData() // dwBytesRecorded %lu !\n", lpMidiHdr->dwBytesRecorded); + dprintf_midi(stddeb, + " %02X %02X %02X %02X\n",lpMidiHdr->lpData[0], + lpMidiHdr->lpData[1], + lpMidiHdr->lpData[2], + lpMidiHdr->lpData[3]); /* - count = write (MidiOutDev[index].unixdev, + count = write (MidiOutDev[wDevID].unixdev, lpMidiHdr->lpData, lpMidiHdr->dwBytesRecorded); */ ptr = (LPWORD)lpMidiHdr->lpData; for (count = 0; count < lpMidiHdr->dwBytesRecorded; count++) { - if (write (MidiOutDev[index].unixdev, ptr, + if (write (MidiOutDev[wDevID].unixdev, ptr, sizeof(WORD)) != sizeof(WORD)) break; ptr++; } + + en = errno; + dprintf_midi(stddeb, "Linux 'modLongData' // after write count = %d\n",count); if (count != lpMidiHdr->dwBytesRecorded) { dprintf_midi(stddeb, "modLongData() // error writting unixdev #%d ! (%d != %ld)\n", - MidiOutDev[index].unixdev, count, lpMidiHdr->dwBytesRecorded); + MidiOutDev[wDevID].unixdev, count, lpMidiHdr->dwBytesRecorded); + dprintf_midi(stddeb, + " errno = %d error = %s\n",en,strerror(en)); return MMSYSERR_NOTENABLED; } lpMidiHdr->dwFlags &= ~MHDR_INQUEUE; @@ -1196,19 +1227,18 @@ static DWORD modLongData(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) static DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_midi(stddeb, "modPrepare(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize); - if (MidiOutDev[index].unixdev == 0) { + if (MidiOutDev[wDevID].unixdev == 0) { dprintf_midi(stddeb,"Linux 'modPrepare' // can't prepare !\n"); return MMSYSERR_NOTENABLED; } - if (MidiOutDev[index].lpQueueHdr != NULL) { + if (MidiOutDev[wDevID].lpQueueHdr != NULL) { dprintf_midi(stddeb,"Linux 'modPrepare' // already prepare !\n"); return MMSYSERR_NOTENABLED; } - MidiOutDev[index].dwTotalPlayed = 0; - MidiOutDev[index].lpQueueHdr = lpMidiHdr; + MidiOutDev[wDevID].dwTotalPlayed = 0; + MidiOutDev[wDevID].lpQueueHdr = PTR_SEG_TO_LIN(lpMidiHdr); if (lpMidiHdr->dwFlags & MHDR_INQUEUE) return MIDIERR_STILLPLAYING; lpMidiHdr->dwFlags |= MHDR_PREPARED; lpMidiHdr->dwFlags &= ~MHDR_DONE; @@ -1224,10 +1254,9 @@ static DWORD modPrepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) static DWORD modUnprepare(WORD wDevID, LPMIDIHDR lpMidiHdr, DWORD dwSize) { #if defined(linux) || defined(__FreeBSD__) - int index = MMSYSTEM_DevIDToIndex(wDevID); dprintf_midi(stddeb, "modUnprepare(%04X, %p, %08lX);\n", wDevID, lpMidiHdr, dwSize); - if (MidiOutDev[index].unixdev == 0) { + if (MidiOutDev[wDevID].unixdev == 0) { dprintf_midi(stddeb,"Linux 'modUnprepare' // can't unprepare !\n"); return MMSYSERR_NOTENABLED; } diff --git a/multimedia/mmaux.c b/multimedia/mmaux.c index 470c78da03..5b261d0436 100644 --- a/multimedia/mmaux.c +++ b/multimedia/mmaux.c @@ -18,9 +18,12 @@ #ifdef linux #include +#elif __FreeBSD__ +#include #endif -int MMSYSTEM_DevIDToIndex(UINT16); +#include "stddebug.h" +#include "debug.h" #define SOUND_DEV "/dev/dsp" #define MIXER_DEV "/dev/mixer" @@ -45,15 +48,15 @@ static DWORD AUX_GetDevCaps(WORD wDevID, LPAUXCAPS lpCaps, DWORD dwSize) #ifdef linux int mixer; int volume; - printf("AUX_GetDevCaps(%04X, %p, %lu);\n", wDevID, lpCaps, dwSize); + dprintf_mmaux(stddeb,"AUX_GetDevCaps(%04X, %p, %lu);\n", wDevID, lpCaps, dwSize); if (lpCaps == NULL) return MMSYSERR_NOTENABLED; if ((mixer = open(MIXER_DEV, O_RDWR)) < 0) { - printf("AUX_GetDevCaps // mixer device not available !\n"); + dprintf_mmaux(stddeb,"AUX_GetDevCaps // mixer device not available !\n"); return MMSYSERR_NOTENABLED; } if (ioctl(mixer, SOUND_MIXER_READ_LINE, &volume) == -1) { close(mixer); - printf("AUX_GetDevCaps // unable read mixer !\n"); + dprintf_mmaux(stddeb,"AUX_GetDevCaps // unable read mixer !\n"); return MMSYSERR_NOTENABLED; } close(mixer); @@ -61,7 +64,7 @@ static DWORD AUX_GetDevCaps(WORD wDevID, LPAUXCAPS lpCaps, DWORD dwSize) lpCaps->wMid = 0x0002; lpCaps->vDriverVersion = 0x0200; lpCaps->dwSupport = AUXCAPS_VOLUME | AUXCAPS_LRVOLUME; - switch (MMSYSTEM_DevIDToIndex(wDevID)) { + switch (wDevID) { case 0: lpCaps->wPid = 0x0196; strcpy(lpCaps->szPname, "SB16 Aux: Wave"); @@ -117,49 +120,50 @@ static DWORD AUX_GetVolume(WORD wDevID, LPDWORD lpdwVol) int mixer; int volume, left, right; int cmd; - printf("AUX_GetVolume(%04X, %p);\n", wDevID, lpdwVol); + + dprintf_mmaux(stddeb,"AUX_GetVolume(%04X, %p);\n", wDevID, lpdwVol); if (lpdwVol == NULL) return MMSYSERR_NOTENABLED; if ((mixer = open(MIXER_DEV, O_RDWR)) < 0) { - printf("Linux 'AUX_GetVolume' // mixer device not available !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_GetVolume' // mixer device not available !\n"); return MMSYSERR_NOTENABLED; } - switch(MMSYSTEM_DevIDToIndex(wDevID)) { + switch(wDevID) { case 0: - printf("Linux 'AUX_GetVolume' // SOUND_MIXER_READ_PCM !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_GetVolume' // SOUND_MIXER_READ_PCM !\n"); cmd = SOUND_MIXER_READ_PCM; break; case 1: - printf("Linux 'AUX_GetVolume' // SOUND_MIXER_READ_SYNTH !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_GetVolume' // SOUND_MIXER_READ_SYNTH !\n"); cmd = SOUND_MIXER_READ_SYNTH; break; case 2: - printf("Linux 'AUX_GetVolume' // SOUND_MIXER_READ_CD !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_GetVolume' // SOUND_MIXER_READ_CD !\n"); cmd = SOUND_MIXER_READ_CD; break; case 3: - printf("Linux 'AUX_GetVolume' // SOUND_MIXER_READ_LINE !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_GetVolume' // SOUND_MIXER_READ_LINE !\n"); cmd = SOUND_MIXER_READ_LINE; break; case 4: - printf("Linux 'AUX_GetVolume' // SOUND_MIXER_READ_MIC !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_GetVolume' // SOUND_MIXER_READ_MIC !\n"); cmd = SOUND_MIXER_READ_MIC; break; case 5: - printf("Linux 'AUX_GetVolume' // SOUND_MIXER_READ_VOLUME !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_GetVolume' // SOUND_MIXER_READ_VOLUME !\n"); cmd = SOUND_MIXER_READ_VOLUME; break; default: - fprintf(stderr, "Linux 'AUX_GetVolume' // invalid device id=%04X !\n", wDevID); + dprintf_mmaux(stddeb, "Linux 'AUX_GetVolume' // invalid device id=%04X !\n", wDevID); return MMSYSERR_NOTENABLED; } if (ioctl(mixer, cmd, &volume) == -1) { - printf("Linux 'AUX_GetVolume' // unable read mixer !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_GetVolume' // unable read mixer !\n"); return MMSYSERR_NOTENABLED; } close(mixer); left = volume & 0x7F; right = (volume >> 8) & 0x7F; - printf("Linux 'AUX_GetVolume' // left=%d right=%d !\n", left, right); + dprintf_mmaux(stddeb,"Linux 'AUX_GetVolume' // left=%d right=%d !\n", left, right); *lpdwVol = MAKELONG(left << 9, right << 9); return MMSYSERR_NOERROR; #else @@ -176,44 +180,44 @@ static DWORD AUX_SetVolume(WORD wDevID, DWORD dwParam) int mixer; int volume; int cmd; - printf("AUX_SetVolume(%04X, %08lX);\n", wDevID, dwParam); + dprintf_mmaux(stddeb,"AUX_SetVolume(%04X, %08lX);\n", wDevID, dwParam); volume = (LOWORD(dwParam) >> 9 & 0x7F) + ((HIWORD(dwParam) >> 9 & 0x7F) << 8); if ((mixer = open(MIXER_DEV, O_RDWR)) < 0) { - printf("Linux 'AUX_SetVolume' // mixer device not available !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_SetVolume' // mixer device not available !\n"); return MMSYSERR_NOTENABLED; } - switch(MMSYSTEM_DevIDToIndex(wDevID)) { + switch(wDevID) { case 0: - printf("Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_PCM !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_PCM !\n"); cmd = SOUND_MIXER_WRITE_PCM; break; case 1: - printf("Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_SYNTH !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_SYNTH !\n"); cmd = SOUND_MIXER_WRITE_SYNTH; break; case 2: - printf("Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_CD !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_CD !\n"); cmd = SOUND_MIXER_WRITE_CD; break; case 3: - printf("Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_LINE !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_LINE !\n"); cmd = SOUND_MIXER_WRITE_LINE; break; case 4: - printf("Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_MIC !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_MIC !\n"); cmd = SOUND_MIXER_WRITE_MIC; break; case 5: - printf("Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_VOLUME !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_SetVolume' // SOUND_MIXER_WRITE_VOLUME !\n"); cmd = SOUND_MIXER_WRITE_VOLUME; break; default: - fprintf(stderr, "Linux 'AUX_SetVolume' // invalid device id=%04X !\n", wDevID); + dprintf_mmaux(stddeb, "Linux 'AUX_SetVolume' // invalid device id=%04X !\n", wDevID); return MMSYSERR_NOTENABLED; } if (ioctl(mixer, cmd, &volume) == -1) { - printf("Linux 'AUX_SetVolume' // unable set mixer !\n"); + dprintf_mmaux(stddeb,"Linux 'AUX_SetVolume' // unable set mixer !\n"); return MMSYSERR_NOTENABLED; } close(mixer); @@ -230,21 +234,21 @@ static DWORD AUX_SetVolume(WORD wDevID, DWORD dwParam) DWORD auxMessage(WORD wDevID, WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2) { - printf("auxMessage(%04X, %04X, %08lX, %08lX, %08lX);\n", + dprintf_mmaux(stddeb,"auxMessage(%04X, %04X, %08lX, %08lX, %08lX);\n", wDevID, wMsg, dwUser, dwParam1, dwParam2); switch(wMsg) { case AUXDM_GETDEVCAPS: return AUX_GetDevCaps(wDevID, (LPAUXCAPS)PTR_SEG_TO_LIN(dwParam1), dwParam2); case AUXDM_GETNUMDEVS: - printf("AUX_GetNumDevs() return %d;\n", NumDev); + dprintf_mmaux(stddeb,"AUX_GetNumDevs() return %d;\n", NumDev); return NumDev; case AUXDM_GETVOLUME: return AUX_GetVolume(wDevID, (LPDWORD)PTR_SEG_TO_LIN(dwParam1)); case AUXDM_SETVOLUME: return AUX_SetVolume(wDevID, dwParam1); default: - fprintf(stderr,"auxMessage // unknown message !\n"); + dprintf_mmaux(stddeb,"auxMessage // unknown message !\n"); } return MMSYSERR_NOTSUPPORTED; } diff --git a/multimedia/mmsystem.c b/multimedia/mmsystem.c index 10da70036e..10d780dfd4 100644 --- a/multimedia/mmsystem.c +++ b/multimedia/mmsystem.c @@ -188,7 +188,7 @@ BOOL16 sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags) lpWaveDesc->hWave = 0; lpWaveDesc->lpFormat = (LPWAVEFORMAT) SEGPTR_GET(lpFormat); - dwRet = wodMessage( MMSYSTEM_FirstDevID(), + dwRet = wodMessage( 0, WODM_OPEN, 0, (DWORD)SEGPTR_GET(lpWaveDesc), CALLBACK_NULL); SEGPTR_FREE(lpFormat); SEGPTR_FREE(lpWaveDesc); @@ -208,7 +208,7 @@ BOOL16 sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags) lpWaveHdr->dwFlags = 0L; lpWaveHdr->dwLoops = 0L; - dwRet = wodMessage( MMSYSTEM_FirstDevID(), + dwRet = wodMessage( 0, WODM_PREPARE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR)); if (dwRet == MMSYSERR_NOERROR) { @@ -218,12 +218,12 @@ BOOL16 sndPlaySound(LPCSTR lpszSoundName, UINT16 uFlags) if (count < 1) break; lpWaveHdr->dwBufferLength = count; /* lpWaveHdr->dwBytesRecorded = count; */ - wodMessage( MMSYSTEM_FirstDevID(), WODM_WRITE, + wodMessage( 0, WODM_WRITE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR)); } - wodMessage( MMSYSTEM_FirstDevID(), - WODM_UNPREPARE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR)); - wodMessage( MMSYSTEM_FirstDevID(), + wodMessage( 0, + WODM_UNPREPARE, 0, (DWORD)spWaveHdr, sizeof(WAVEHDR)); + wodMessage( 0, WODM_CLOSE, 0, 0L, 0L); bRet = TRUE; @@ -547,17 +547,32 @@ BOOL16 mciGetErrorString (DWORD wError, LPSTR lpstrBuffer, UINT16 uLength) case MCIERR_FILE_WRITE: msgptr = "Cannot write to the specified file. Make sure you have enough disk space or are still connected to the network."; break; + case MCIERR_SEQ_DIV_INCOMPATIBLE: + msgptr = "The time formats of the \"song pointer\" and SMPTE are mutually exclusive. You can't use them together."; + break; + case MCIERR_SEQ_NOMIDIPRESENT: + msgptr = "The system has no installed MIDI devices. Use the Drivers option from the Control Panel to install a MIDI driver."; + break; + case MCIERR_SEQ_PORT_INUSE: + msgptr = "The specified MIDI port is already in use. Wait until it is free; the try again."; + break; + case MCIERR_SEQ_PORT_MAPNODEVICE: + msgptr = "The current MIDI Mapper setup refers to a MIDI device that is not installed on the system. Use the MIDI Mapper option from the Control Panel to edit the setup."; + break; + case MCIERR_SEQ_PORT_MISCERROR: + msgptr = "An error occurred with the specified port."; + break; + case MCIERR_SEQ_PORT_NONEXISTENT: + msgptr = "The specified MIDI device is not installed on the system. Use the Drivers option from the Control Panel to install a MIDI device."; + break; + case MCIERR_SEQ_PORTUNSPECIFIED: + msgptr = "The system doesnot have a current MIDI port specified."; + break; + case MCIERR_SEQ_TIMER: + msgptr = "All multimedia timers are being used by other applications. Quit one of these applications; then, try again."; + break; /* -#define MCIERR_SEQ_DIV_INCOMPATIBLE (MCIERR_BASE + 80) -#define MCIERR_SEQ_PORT_INUSE (MCIERR_BASE + 81) -#define MCIERR_SEQ_PORT_NONEXISTENT (MCIERR_BASE + 82) -#define MCIERR_SEQ_PORT_MAPNODEVICE (MCIERR_BASE + 83) -#define MCIERR_SEQ_PORT_MISCERROR (MCIERR_BASE + 84) -#define MCIERR_SEQ_TIMER (MCIERR_BASE + 85) -#define MCIERR_SEQ_PORTUNSPECIFIED (MCIERR_BASE + 86) -#define MCIERR_SEQ_NOMIDIPRESENT (MCIERR_BASE + 87) - msg# 513 : vcr msg# 514 : videodisc msg# 515 : overlay @@ -595,6 +610,7 @@ msg# 543 : tmsf break; } lstrcpyn32A(lpstrBuffer, msgptr, uLength); + dprintf_mmsys(stddeb, "mciGetErrorString // msg = %s;\n", msgptr); return TRUE; } @@ -608,7 +624,7 @@ BOOL16 mciDriverNotify(HWND16 hWndCallBack, UINT16 wDevID, UINT16 wStatus) if (!IsWindow32(hWndCallBack)) return FALSE; dprintf_mmsys(stddeb, "mciDriverNotify // before PostMessage\n"); PostMessage16( hWndCallBack, MM_MCINOTIFY, wStatus, - MAKELONG(GetDrv(wDevID)->wDeviceID, 0)); + MAKELONG(wDevID, 0)); return TRUE; } @@ -622,10 +638,12 @@ DWORD mciOpen(DWORD dwParam, LPMCI_OPEN_PARMS lp16Parms) LPMCI_OPEN_PARMS lpParms; UINT16 uDevTyp = 0; UINT16 wDevID = MMSYSTEM_FirstDevID(); + DWORD dwret; lpParms = PTR_SEG_TO_LIN(lp16Parms); dprintf_mmsys(stddeb, "mciOpen(%08lX, %p (%p))\n", dwParam, lp16Parms, lpParms); if (lp16Parms == NULL) return MCIERR_INTERNAL; + while(GetDrv(wDevID)->wType != 0) { wDevID = MMSYSTEM_NextDevID(wDevID); if (!MMSYSTEM_DevIDValid(wDevID)) { @@ -647,6 +665,7 @@ DWORD mciOpen(DWORD dwParam, LPMCI_OPEN_PARMS lp16Parms) if (t) { GetProfileString32A("mci extensions",t+1,"*",str,sizeof(str)); CharUpper32A(str); + dprintf_mmsys(stddeb, "mciOpen // str = %s \n", str); if (strcmp(str, "CDAUDIO") == 0) { uDevTyp = MCI_DEVTYPE_CD_AUDIO; } else @@ -710,32 +729,41 @@ DWORD mciOpen(DWORD dwParam, LPMCI_OPEN_PARMS lp16Parms) } } GetDrv(wDevID)->wType = uDevTyp; - GetDrv(wDevID)->wDeviceID = wDevID; + GetDrv(wDevID)->wDeviceID = 0; /* FIXME? for multiple devices */ lpParms->wDeviceID = wDevID; dprintf_mmsys(stddeb, "MCI_OPEN // mcidev=%d, uDevTyp=%04X wDeviceID=%04X !\n", wDevID, uDevTyp, lpParms->wDeviceID); switch(uDevTyp) { case MCI_DEVTYPE_CD_AUDIO: - return CDAUDIO_DriverProc( 0, 0, MCI_OPEN_DRIVER, - dwParam, (DWORD)lp16Parms); + dwret = CDAUDIO_DriverProc( 0, 0, MCI_OPEN_DRIVER, + dwParam, (DWORD)lp16Parms); + break; case MCI_DEVTYPE_WAVEFORM_AUDIO: - return WAVE_DriverProc( 0, 0, MCI_OPEN_DRIVER, - dwParam, (DWORD)lp16Parms); + dwret = WAVE_DriverProc( 0, 0, MCI_OPEN_DRIVER, + dwParam, (DWORD)lp16Parms); + break; case MCI_DEVTYPE_SEQUENCER: - return MIDI_DriverProc( 0, 0, MCI_OPEN_DRIVER, - dwParam, (DWORD)lp16Parms); + dwret = MIDI_DriverProc( 0, 0, MCI_OPEN_DRIVER, + dwParam, (DWORD)lp16Parms); + break; case MCI_DEVTYPE_ANIMATION: - return ANIM_DriverProc( 0, 0, MCI_OPEN_DRIVER, - dwParam, (DWORD)lp16Parms); + dwret = ANIM_DriverProc( 0, 0, MCI_OPEN_DRIVER, + dwParam, (DWORD)lp16Parms); + break; case MCI_DEVTYPE_DIGITAL_VIDEO: - dprintf_mmsys(stddeb, "MCI_OPEN // No DIGITAL_VIDEO yet !\n"); - return MCIERR_DEVICE_NOT_INSTALLED; + dprintf_mmsys(stddeb, "MCI_OPEN // No DIGITAL_VIDEO yet !\n"); + return MCIERR_DEVICE_NOT_INSTALLED; default: - dprintf_mmsys(stddeb, "MCI_OPEN // Invalid Device Name '%08lx' !\n", lpParms->lpstrDeviceType); - return MCIERR_INVALID_DEVICE_NAME; + dprintf_mmsys(stddeb, "MCI_OPEN // Invalid Device Name '%08lx' !\n", lpParms->lpstrDeviceType); + return MCIERR_INVALID_DEVICE_NAME; } - return MCIERR_INTERNAL; + + /* only handled devices fall through */ + dprintf_mmsys(stddeb, "MCI_OPEN // wDevID = %04X wDeviceID = %d dwret = %ld\n",wDevID, lpParms->wDeviceID, dwret); + return dwret; + +/* return MCIERR_INTERNAL; */ } @@ -745,7 +773,8 @@ DWORD mciOpen(DWORD dwParam, LPMCI_OPEN_PARMS lp16Parms) DWORD mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) { DWORD dwRet = MCIERR_INTERNAL; - dprintf_mmsys(stddeb, "mciClose(%u, %08lX, %p)\n", wDevID, dwParam, lpParms); + + dprintf_mmsys(stddeb, "mciClose(%04x, %08lX, %p)\n", wDevID, dwParam, lpParms); switch(GetDrv(wDevID)->wType) { case MCI_DEVTYPE_CD_AUDIO: dwRet = CDAUDIO_DriverProc(GetDrv(wDevID)->wDeviceID,0, @@ -768,14 +797,16 @@ DWORD mciClose(UINT16 wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms) break; default: dprintf_mmsys(stddeb, "mciClose() // unknown device type=%04X !\n", GetDrv(wDevID)->wType); + dwRet = MCIERR_DEVICE_NOT_INSTALLED; } GetDrv(wDevID)->wType = 0; + dprintf_mmsys(stddeb, "mciClose() // returns %ld\n",dwRet); return dwRet; } /************************************************************************** -* mciSound [internal] +* mciSysinfo [internal] */ DWORD mciSysInfo(DWORD dwFlags, LPMCI_SYSINFO_PARMS lpParms) { @@ -936,7 +967,7 @@ UINT16 mciGetDeviceID (LPCSTR lpstrName) return 0; wDevID = MMSYSTEM_FirstDevID(); - while(GetDrv(wDevID)->wType) { + while(MMSYSTEM_DevIDValid(wDevID) && GetDrv(wDevID)->wType) { if (GetOpenDrv(wDevID)->lpstrDeviceType && strcmp(PTR_SEG_TO_LIN(GetOpenDrv(wDevID)->lpstrDeviceType), lpstrName) == 0) return wDevID; @@ -1524,6 +1555,7 @@ UINT16 waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID, LPWAVEOPENDESC lp16Desc; DWORD dwRet = 0; BOOL32 bMapperFlg = FALSE; + dprintf_mmsys(stddeb, "waveOutOpen(%p, %d, %p, %08lX, %08lX, %08lX);\n", lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags); if (dwFlags & WAVE_FORMAT_QUERY) { @@ -1535,13 +1567,14 @@ UINT16 waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID, uDeviceID = 0; } if (lpFormat == NULL) return WAVERR_BADFORMAT; + hWaveOut = USER_HEAP_ALLOC(sizeof(WAVEOPENDESC)); if (lphWaveOut != NULL) *lphWaveOut = hWaveOut; lp16Desc = (LPWAVEOPENDESC) USER_HEAP_SEG_ADDR(hWaveOut); lpDesc = (LPWAVEOPENDESC) PTR_SEG_TO_LIN(lp16Desc); if (lpDesc == NULL) return MMSYSERR_NOMEM; lpDesc->hWave = hWaveOut; - lpDesc->lpFormat = lpFormat; + lpDesc->lpFormat = lpFormat; /* should the struct be copied iso pointer? */ lpDesc->dwCallBack = dwCallback; lpDesc->dwInstance = dwInstance; while(uDeviceID < MAXWAVEDRIVERS) { @@ -1556,6 +1589,7 @@ UINT16 waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID, dprintf_mmsys(stddeb, "waveOutOpen // End of WAVE_FORMAT_QUERY !\n"); waveOutClose(hWaveOut); } + lpDesc->uDeviceID = uDeviceID; /* save physical Device ID */ return dwRet; } @@ -1565,10 +1599,11 @@ UINT16 waveOutOpen(HWAVEOUT16 * lphWaveOut, UINT16 uDeviceID, UINT16 waveOutClose(HWAVEOUT16 hWaveOut) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveOutClose(%04X)\n", hWaveOut); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_CLOSE, lpDesc->dwInstance, 0L, 0L); + return wodMessage( lpDesc->uDeviceID, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** @@ -1578,11 +1613,12 @@ UINT16 waveOutPrepareHeader(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr, UINT16 uSize) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveOutPrepareHeader(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_PREPARE, lpDesc->dwInstance, + return wodMessage( lpDesc->uDeviceID, WODM_PREPARE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize); } @@ -1593,11 +1629,12 @@ UINT16 waveOutUnprepareHeader(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr, UINT16 uSize) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveOutUnprepareHeader(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_UNPREPARE, lpDesc->dwInstance, + return wodMessage( lpDesc->uDeviceID, WODM_UNPREPARE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize); } @@ -1607,10 +1644,11 @@ UINT16 waveOutUnprepareHeader(HWAVEOUT16 hWaveOut, UINT16 waveOutWrite(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr, UINT16 uSize) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveOutWrite(%04X, %p, %u);\n", hWaveOut, lpWaveOutHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_WRITE, lpDesc->dwInstance, + return wodMessage( lpDesc->uDeviceID, WODM_WRITE, lpDesc->dwInstance, (DWORD)lpWaveOutHdr, uSize); } @@ -1620,10 +1658,11 @@ UINT16 waveOutWrite(HWAVEOUT16 hWaveOut, WAVEHDR * lpWaveOutHdr, UINT16 uSize) UINT16 waveOutPause(HWAVEOUT16 hWaveOut) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveOutPause(%04X)\n", hWaveOut); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_PAUSE, lpDesc->dwInstance, 0L, 0L); + return wodMessage( lpDesc->uDeviceID, WODM_PAUSE, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** @@ -1632,10 +1671,11 @@ UINT16 waveOutPause(HWAVEOUT16 hWaveOut) UINT16 waveOutRestart(HWAVEOUT16 hWaveOut) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveOutRestart(%04X)\n", hWaveOut); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_RESTART, lpDesc->dwInstance, 0L, 0L); + return wodMessage( lpDesc->uDeviceID, WODM_RESTART, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** @@ -1647,7 +1687,7 @@ UINT16 waveOutReset(HWAVEOUT16 hWaveOut) dprintf_mmsys(stddeb, "waveOutReset(%04X)\n", hWaveOut); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_RESET, lpDesc->dwInstance, 0L, 0L); + return wodMessage( lpDesc->uDeviceID, WODM_RESET, lpDesc->dwInstance, 0L, 0L); } /************************************************************************** @@ -1659,7 +1699,7 @@ UINT16 waveOutGetPosition(HWAVEOUT16 hWaveOut, MMTIME * lpTime, UINT16 uSize) dprintf_mmsys(stddeb, "waveOutGetPosition(%04X, %p, %u);\n", hWaveOut, lpTime, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_GETPOS, lpDesc->dwInstance, + return wodMessage( lpDesc->uDeviceID, WODM_GETPOS, lpDesc->dwInstance, (DWORD)lpTime, (DWORD)uSize); } @@ -1672,7 +1712,7 @@ UINT16 waveOutGetPitch(HWAVEOUT16 hWaveOut, DWORD * lpdwPitch) dprintf_mmsys(stddeb, "waveOutGetPitch(%04X, %p);\n", hWaveOut, lpdwPitch); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_GETPITCH, lpDesc->dwInstance, + return wodMessage( lpDesc->uDeviceID, WODM_GETPITCH, lpDesc->dwInstance, (DWORD)lpdwPitch, 0L); } @@ -1685,7 +1725,7 @@ UINT16 waveOutSetPitch(HWAVEOUT16 hWaveOut, DWORD dwPitch) dprintf_mmsys(stddeb, "waveOutSetPitch(%04X, %08lX);\n", hWaveOut, dwPitch); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_SETPITCH, lpDesc->dwInstance, (DWORD)dwPitch, 0L); + return wodMessage( lpDesc->uDeviceID, WODM_SETPITCH, lpDesc->dwInstance, (DWORD)dwPitch, 0L); } /************************************************************************** @@ -1715,7 +1755,7 @@ UINT16 waveOutGetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD * lpdwRate) dprintf_mmsys(stddeb, "waveOutGetPlaybackRate(%04X, %p);\n", hWaveOut, lpdwRate); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_GETPLAYBACKRATE, lpDesc->dwInstance, + return wodMessage( lpDesc->uDeviceID, WODM_GETPLAYBACKRATE, lpDesc->dwInstance, (DWORD)lpdwRate, 0L); } @@ -1728,7 +1768,7 @@ UINT16 waveOutSetPlaybackRate(HWAVEOUT16 hWaveOut, DWORD dwRate) dprintf_mmsys(stddeb, "waveOutSetPlaybackRate(%04X, %08lX);\n", hWaveOut, dwRate); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), WODM_SETPLAYBACKRATE, + return wodMessage( lpDesc->uDeviceID, WODM_SETPLAYBACKRATE, lpDesc->dwInstance, (DWORD)dwRate, 0L); } @@ -1754,7 +1794,8 @@ UINT16 waveOutGetID(HWAVEOUT16 hWaveOut, UINT16 * lpuDeviceID) /* *lpuDeviceID = lpParms->wDeviceID; */ - return 0; + *lpuDeviceID = lpDesc->uDeviceID; + return 0; } /************************************************************************** @@ -1768,7 +1809,7 @@ DWORD waveOutMessage(HWAVEOUT16 hWaveOut, UINT16 uMessage, hWaveOut, uMessage, dwParam1, dwParam2); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveOut); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return wodMessage( MMSYSTEM_FirstDevID(), uMessage, lpDesc->dwInstance, dwParam1, dwParam2); + return wodMessage( lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } /************************************************************************** @@ -1857,10 +1898,11 @@ UINT16 waveInOpen(HWAVEIN16 * lphWaveIn, UINT16 uDeviceID, UINT16 waveInClose(HWAVEIN16 hWaveIn) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveInClose(%04X)\n", hWaveIn); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return widMessage(0, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L); + return widMessage(lpDesc->uDeviceID, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L); } @@ -1872,6 +1914,7 @@ UINT16 waveInPrepareHeader(HWAVEIN16 hWaveIn, { LPWAVEOPENDESC lpDesc; LPWAVEHDR lp32WaveInHdr; + dprintf_mmsys(stddeb, "waveInPrepareHeader(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); @@ -1882,7 +1925,7 @@ UINT16 waveInPrepareHeader(HWAVEIN16 hWaveIn, lp32WaveInHdr->dwBytesRecorded = 0; dprintf_mmsys(stddeb, "waveInPrepareHeader // lpData=%p size=%lu \n", lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength); - return widMessage(0, WIDM_PREPARE, lpDesc->dwInstance, + return widMessage(lpDesc->uDeviceID, WIDM_PREPARE, lpDesc->dwInstance, (DWORD)lpWaveInHdr, uSize); } @@ -1895,6 +1938,7 @@ UINT16 waveInUnprepareHeader(HWAVEIN16 hWaveIn, { LPWAVEOPENDESC lpDesc; LPWAVEHDR lp32WaveInHdr; + dprintf_mmsys(stddeb, "waveInUnprepareHeader(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); @@ -1904,7 +1948,7 @@ UINT16 waveInUnprepareHeader(HWAVEIN16 hWaveIn, USER_HEAP_FREE(HIWORD((DWORD)lp32WaveInHdr->lpData)); lp32WaveInHdr->lpData = NULL; lp32WaveInHdr->lpNext = NULL; - return widMessage(0, WIDM_UNPREPARE, lpDesc->dwInstance, + return widMessage(lpDesc->uDeviceID, WIDM_UNPREPARE, lpDesc->dwInstance, (DWORD)lpWaveInHdr, uSize); } @@ -1917,6 +1961,7 @@ UINT16 waveInAddBuffer(HWAVEIN16 hWaveIn, { LPWAVEOPENDESC lpDesc; LPWAVEHDR lp32WaveInHdr; + dprintf_mmsys(stddeb, "waveInAddBuffer(%04X, %p, %u);\n", hWaveIn, lpWaveInHdr, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; @@ -1926,7 +1971,7 @@ UINT16 waveInAddBuffer(HWAVEIN16 hWaveIn, lp32WaveInHdr->dwBytesRecorded = 0; dprintf_mmsys(stddeb, "waveInAddBuffer // lpData=%p size=%lu \n", lp32WaveInHdr->lpData, lp32WaveInHdr->dwBufferLength); - return widMessage(0, WIDM_ADDBUFFER, lpDesc->dwInstance, + return widMessage(lpDesc->uDeviceID, WIDM_ADDBUFFER, lpDesc->dwInstance, (DWORD)lpWaveInHdr, uSize); } @@ -1937,10 +1982,11 @@ UINT16 waveInAddBuffer(HWAVEIN16 hWaveIn, UINT16 waveInStart(HWAVEIN16 hWaveIn) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveInStart(%04X)\n", hWaveIn); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return widMessage(0, WIDM_START, lpDesc->dwInstance, 0L, 0L); + return widMessage(lpDesc->uDeviceID, WIDM_START, lpDesc->dwInstance, 0L, 0L); } @@ -1950,10 +1996,11 @@ UINT16 waveInStart(HWAVEIN16 hWaveIn) UINT16 waveInStop(HWAVEIN16 hWaveIn) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveInStop(%04X)\n", hWaveIn); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return widMessage(0, WIDM_STOP, lpDesc->dwInstance, 0L, 0L); + return widMessage(lpDesc->uDeviceID, WIDM_STOP, lpDesc->dwInstance, 0L, 0L); } @@ -1963,10 +2010,11 @@ UINT16 waveInStop(HWAVEIN16 hWaveIn) UINT16 waveInReset(HWAVEIN16 hWaveIn) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveInReset(%04X)\n", hWaveIn); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return widMessage(0, WIDM_RESET, lpDesc->dwInstance, 0L, 0L); + return widMessage(lpDesc->uDeviceID, WIDM_RESET, lpDesc->dwInstance, 0L, 0L); } @@ -1976,10 +2024,11 @@ UINT16 waveInReset(HWAVEIN16 hWaveIn) UINT16 waveInGetPosition(HWAVEIN16 hWaveIn, MMTIME * lpTime, UINT16 uSize) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveInGetPosition(%04X, %p, %u);\n", hWaveIn, lpTime, uSize); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return widMessage(0, WIDM_GETPOS, lpDesc->dwInstance, + return widMessage(lpDesc->uDeviceID, WIDM_GETPOS, lpDesc->dwInstance, (DWORD)lpTime, (DWORD)uSize); } @@ -1989,8 +2038,13 @@ UINT16 waveInGetPosition(HWAVEIN16 hWaveIn, MMTIME * lpTime, UINT16 uSize) */ UINT16 waveInGetID(HWAVEIN16 hWaveIn, UINT16 * lpuDeviceID) { + LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveInGetID\n"); - if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM; + if (lpuDeviceID == NULL) return MMSYSERR_INVALHANDLE; + lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); + if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; + *lpuDeviceID = lpDesc->uDeviceID; return 0; } @@ -2002,11 +2056,12 @@ DWORD waveInMessage(HWAVEIN16 hWaveIn, UINT16 uMessage, DWORD dwParam1, DWORD dwParam2) { LPWAVEOPENDESC lpDesc; + dprintf_mmsys(stddeb, "waveInMessage(%04X, %04X, %08lX, %08lX)\n", hWaveIn, uMessage, dwParam1, dwParam2); lpDesc = (LPWAVEOPENDESC) USER_HEAP_LIN_ADDR(hWaveIn); if (lpDesc == NULL) return MMSYSERR_INVALHANDLE; - return widMessage(0, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); + return widMessage(lpDesc->uDeviceID, uMessage, lpDesc->dwInstance, dwParam1, dwParam2); } diff --git a/multimedia/time.c b/multimedia/time.c index 56e4e4583e..f9fa0c50f8 100644 --- a/multimedia/time.c +++ b/multimedia/time.c @@ -86,7 +86,7 @@ static VOID TIME_MMSysTimeCallback( HWND32 hwnd, UINT32 msg, /************************************************************************** * StartMMTime [internal] */ -void StartMMTime() +static void StartMMTime() { if (!mmTimeStarted) { mmTimeStarted = TRUE; diff --git a/objects/bitmap.c b/objects/bitmap.c index 52f3ef4500..fdb59d24f2 100644 --- a/objects/bitmap.c +++ b/objects/bitmap.c @@ -201,7 +201,7 @@ LONG GetBitmapBits32( HBITMAP32 hbitmap, LONG count, LPVOID buffer ) return 0; } - widthbytes = DIB_GetImageWidthBytesX11(bmp->bitmap.bmWidth,bmp->bitmap.bmBitsPixel); + widthbytes = DIB_GetXImageWidthBytes(bmp->bitmap.bmWidth,bmp->bitmap.bmBitsPixel); tmpbuffer = (LPBYTE)xmalloc(widthbytes*height); image = XCreateImage( display, DefaultVisualOfScreen(screen), bmp->bitmap.bmBitsPixel, ZPixmap, 0, tmpbuffer, @@ -223,8 +223,10 @@ LONG GetBitmapBits32( HBITMAP32 hbitmap, LONG count, LPVOID buffer ) *tbuf = 0; for (w=0;wbitmap.bmWidth;w++) { + if ((w%8) == 0) + *tbuf = 0; *tbuf |= XGetPixel(image,w,h)<<(7-(w&7)); - if ((w&7) == 7) *(++tbuf) = 0; + if ((w&7) == 7) ++tbuf; } tbuf += pad; } @@ -348,7 +350,7 @@ LONG SetBitmapBits32( HBITMAP32 hbitmap, LONG count, LPCVOID buffer ) } sbuf = (LPBYTE)buffer; - widthbytes = DIB_GetImageWidthBytesX11(bmp->bitmap.bmWidth,bmp->bitmap.bmBitsPixel); + widthbytes = DIB_GetXImageWidthBytes(bmp->bitmap.bmWidth,bmp->bitmap.bmBitsPixel); tmpbuffer = (LPBYTE)xmalloc(widthbytes*height); image = XCreateImage( display, DefaultVisualOfScreen(screen), bmp->bitmap.bmBitsPixel, ZPixmap, 0, tmpbuffer, diff --git a/objects/color.c b/objects/color.c index 943b1da197..3442d91c01 100644 --- a/objects/color.c +++ b/objects/color.c @@ -40,6 +40,8 @@ typedef struct Colormap colorMap; UINT16 size; UINT16 flags; + INT32 monoPlane; /* bit plane different for white and black pixels */ + BOOL32 bWhiteOn; /* monoPlane bit is 1 for the white pixel */ } CSPACE; static CSPACE cSpace = {0, 0, 0}; @@ -125,6 +127,12 @@ Colormap COLOR_GetColormap(void) return cSpace.colorMap; } +BOOL32 COLOR_GetMonoPlane(INT32* plane) +{ + *plane = cSpace.monoPlane; + return (cSpace.flags & COLOR_WHITESET) ? TRUE : FALSE; +} + UINT16 COLOR_GetSystemPaletteSize(void) { return (cSpace.flags & COLOR_PRIVATE) ? cSpace.size : 256; @@ -537,10 +545,6 @@ static HPALETTE16 COLOR_InitPalette(void) memset(COLOR_freeList, 0, 256*sizeof(unsigned char)); - /* calculate max palette size */ - - cSpace.size = visual->map_entries; - if (cSpace.flags & COLOR_PRIVATE) COLOR_BuildPrivateMap( &cSpace ); else @@ -610,10 +614,20 @@ static void COLOR_Computeshifts(unsigned long maskbits, int *shift, int *max) */ HPALETTE16 COLOR_Init(void) { + int mask, white, black; + visual = DefaultVisual( display, DefaultScreen(display) ); dprintf_palette(stddeb,"COLOR_Init: initializing palette manager..."); + white = WhitePixelOfScreen( screen ); + black = BlackPixelOfScreen( screen ); + cSpace.monoPlane = 1; + for( mask = 1; !((white & mask)^(black & mask)); mask <<= 1 ) + cSpace.monoPlane++; + cSpace.flags = (white & mask) ? COLOR_WHITESET : 0; + cSpace.size = visual->map_entries; + switch(visual->class) { case DirectColor: @@ -624,18 +638,23 @@ HPALETTE16 COLOR_Init(void) { XSetWindowAttributes win_attr; - cSpace.flags |= COLOR_PRIVATE; cSpace.colorMap = XCreateColormap( display, rootWindow, visual, AllocAll ); if (cSpace.colorMap) { - if( rootWindow != DefaultRootWindow(display) ) - { + cSpace.flags |= (COLOR_PRIVATE | COLOR_WHITESET); + + cSpace.monoPlane = 1; + for( white = cSpace.size - 1; !(white & 1); white >>= 1 ) + cSpace.monoPlane++; + + if( rootWindow != DefaultRootWindow(display) ) + { win_attr.colormap = cSpace.colorMap; XChangeWindowAttributes( display, rootWindow, CWColormap, &win_attr ); - } - break; + } + break; } } cSpace.colorMap = DefaultColormapOfScreen( screen ); @@ -658,7 +677,8 @@ HPALETTE16 COLOR_Init(void) break; } - dprintf_palette(stddeb," visual class %i\n", visual->class); + dprintf_palette(stddeb," visual class %i (%i)\n", + visual->class, cSpace.monoPlane); return COLOR_InitPalette(); } diff --git a/objects/cursoricon.c b/objects/cursoricon.c index 7212085370..e8a9537b52 100644 --- a/objects/cursoricon.c +++ b/objects/cursoricon.c @@ -7,6 +7,8 @@ /* * Theory: * + * http://www.microsoft.com/win32dev/ui/icons.htm + * * Cursors and icons are stored in a global heap block, with the * following layout: * @@ -33,7 +35,6 @@ #include "win.h" #include "stddebug.h" #include "debug.h" -#include "xmalloc.h" #include "task.h" extern UINT16 COLOR_GetSystemPaletteSize(); @@ -237,14 +238,15 @@ static BOOL32 CURSORICON_LoadDirEntry( HINSTANCE32 hInstance, SEGPTR name, HGLOBAL16 CURSORICON_LoadHandler( HGLOBAL16 handle, HINSTANCE16 hInstance, BOOL32 fCursor ) { - HBITMAP32 hAndBits, hXorBits; - HDC32 hdc; - int size, sizeAnd, sizeXor; - POINT16 hotspot = { 0 ,0 }; + static char* __loadhandlerStr = "CURSORICON_LoadHandler"; + + int sizeAnd, sizeXor; + HBITMAP32 hAndBits = 0, hXorBits = 0; /* error condition for later */ BITMAPOBJ *bmpXor, *bmpAnd; - BITMAPINFO *bmi, *pInfo; + POINT16 hotspot = { 0 ,0 }; CURSORICONINFO *info; - char *bits; + BITMAPINFO *bmi; + HDC32 hdc; if (fCursor) /* If cursor, get the hotspot */ { @@ -254,87 +256,81 @@ HGLOBAL16 CURSORICON_LoadHandler( HGLOBAL16 handle, HINSTANCE16 hInstance, } else bmi = (BITMAPINFO *)LockResource16( handle ); - /* Create a copy of the bitmap header */ + /* Check bitmap header */ - size = DIB_BitmapInfoSize( bmi, DIB_RGB_COLORS ); - /* Make sure we have room for the monochrome bitmap later on */ - size = MAX( size, sizeof(BITMAPINFOHEADER) + 2*sizeof(RGBQUAD) ); - pInfo = (BITMAPINFO *)xmalloc( size ); - memcpy( pInfo, bmi, size ); - - if (pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER)) + if ( (bmi->bmiHeader.biSize != sizeof(BITMAPCOREHEADER)) && + (bmi->bmiHeader.biSize != sizeof(BITMAPINFOHEADER) || + bmi->bmiHeader.biCompression != BI_RGB) ) { - if (pInfo->bmiHeader.biCompression != BI_RGB) - { - fprintf(stderr,"Unknown size for compressed icon bitmap.\n"); - free( pInfo ); - return 0; - } - pInfo->bmiHeader.biHeight /= 2; + fprintf(stderr,"%s: invalid bitmap header.\n", __loadhandlerStr); + return 0; } - else if (pInfo->bmiHeader.biSize == sizeof(BITMAPCOREHEADER)) + + if( (hdc = GetDC32( 0 )) ) { - BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)pInfo; - core->bcHeight /= 2; + BITMAPINFO* pInfo; + INT32 size = DIB_BitmapInfoSize( bmi, DIB_RGB_COLORS ); + + /* Make sure we have room for the monochrome bitmap later on. + * Note that BITMAPINFOINFO and BITMAPCOREHEADER are the same + * up to and including the biBitCount. In-memory icon resource + * format is as follows: + * + * BITMAPINFOHEADER icHeader // DIB header + * RGBQUAD icColors[] // Color table + * BYTE icXOR[] // DIB bits for XOR mask + * BYTE icAND[] // DIB bits for AND mask + */ + + if( (pInfo = (BITMAPINFO *)HeapAlloc( GetProcessHeap(), 0, + MAX(size, sizeof(BITMAPINFOHEADER) + 2*sizeof(RGBQUAD)))) ) + { + memcpy( pInfo, bmi, size ); + pInfo->bmiHeader.biHeight /= 2; + + /* Create the XOR bitmap */ + + hXorBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT, + (char*)bmi + size, pInfo, DIB_RGB_COLORS ); + if( hXorBits ) + { + char* bits = (char *)bmi + size + bmi->bmiHeader.biHeight * + DIB_GetDIBWidthBytes(bmi->bmiHeader.biWidth, + bmi->bmiHeader.biBitCount) / 2; + + pInfo->bmiHeader.biBitCount = 1; + if (pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER)) + { + RGBQUAD *rgb = pInfo->bmiColors; + + pInfo->bmiHeader.biClrUsed = pInfo->bmiHeader.biClrImportant = 2; + rgb[0].rgbBlue = rgb[0].rgbGreen = rgb[0].rgbRed = 0x00; + rgb[1].rgbBlue = rgb[1].rgbGreen = rgb[1].rgbRed = 0xff; + rgb[0].rgbReserved = rgb[1].rgbReserved = 0; + } + else + { + RGBTRIPLE *rgb = (RGBTRIPLE *)(((BITMAPCOREHEADER *)pInfo) + 1); + + rgb[0].rgbtBlue = rgb[0].rgbtGreen = rgb[0].rgbtRed = 0x00; + rgb[1].rgbtBlue = rgb[1].rgbtGreen = rgb[1].rgbtRed = 0xff; + } + + /* Create the AND bitmap */ + + hAndBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT, + bits, pInfo, DIB_RGB_COLORS ); + if( !hAndBits ) DeleteObject32( hXorBits ); + } + HeapFree( GetProcessHeap(), 0, pInfo ); + } + ReleaseDC32( 0, hdc ); } - else + + if( !hXorBits || !hAndBits ) { - fprintf( stderr, "CURSORICON_Load: Unknown bitmap length %ld!\n", - pInfo->bmiHeader.biSize ); - free( pInfo ); - return 0; - } - - /* Create the XOR bitmap */ - - if (!(hdc = GetDC32( 0 ))) - { - free( pInfo ); - return 0; - } - - hXorBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT, - (char*)bmi + size, pInfo, DIB_RGB_COLORS ); - if (!hXorBits) { - free( pInfo ); - ReleaseDC32( 0, hdc ); - return 0; - } - - /* Fix the bitmap header to load the monochrome mask */ - - if (pInfo->bmiHeader.biSize == sizeof(BITMAPINFOHEADER)) - { - BITMAPINFOHEADER *bih = &pInfo->bmiHeader; - RGBQUAD *rgb = pInfo->bmiColors; - bits = (char *)bmi + size + - DIB_GetImageWidthBytes(bih->biWidth,bih->biBitCount)*bih->biHeight; - bih->biBitCount = 1; - bih->biClrUsed = bih->biClrImportant = 2; - rgb[0].rgbBlue = rgb[0].rgbGreen = rgb[0].rgbRed = 0x00; - rgb[1].rgbBlue = rgb[1].rgbGreen = rgb[1].rgbRed = 0xff; - rgb[0].rgbReserved = rgb[1].rgbReserved = 0; - } - else - { - BITMAPCOREHEADER *bch = (BITMAPCOREHEADER *)pInfo; - RGBTRIPLE *rgb = (RGBTRIPLE *)(bch + 1); - bits = (char *)bmi + size + - DIB_GetImageWidthBytes(bch->bcWidth,bch->bcBitCount)*bch->bcHeight; - bch->bcBitCount = 1; - rgb[0].rgbtBlue = rgb[0].rgbtGreen = rgb[0].rgbtRed = 0x00; - rgb[1].rgbtBlue = rgb[1].rgbtGreen = rgb[1].rgbtRed = 0xff; - } - - /* Create the AND bitmap */ - - hAndBits = CreateDIBitmap32( hdc, &pInfo->bmiHeader, CBM_INIT, - bits, pInfo, DIB_RGB_COLORS ); - ReleaseDC32( 0, hdc ); - if (!hAndBits) { - DeleteObject32( hXorBits ); - free( pInfo ); - return 0; + fprintf(stderr,"%s: unable to create a bitmap.\n", __loadhandlerStr ); + return 0; } /* Now create the CURSORICONINFO structure */ @@ -451,12 +447,12 @@ HCURSOR16 CURSORICON_IconToCursor(HICON16 hIcon, BOOL32 bSemiTransparent) HTASK16 hTask = GetCurrentTask(); TDB* pTask = (TDB *)GlobalLock16(hTask); - if(hIcon) + if(hIcon && pTask) if (!(ptr = (CURSORICONINFO*)GlobalLock16( hIcon ))) return FALSE; if (ptr->bPlanes * ptr->bBitsPerPixel == 1) hRet = CURSORICON_Copy( pTask->hInstance, hIcon ); else - { + { BYTE pAndBits[128]; BYTE pXorBits[128]; int x, y, ix, iy, shift; @@ -471,8 +467,6 @@ HCURSOR16 CURSORICON_IconToCursor(HICON16 hIcon, BOOL32 bSemiTransparent) COLORREF col; CURSORICONINFO cI; - if(!pTask) return 0; - memset(pXorBits, 0, 128); cI.bBitsPerPixel = 1; cI.bPlanes = 1; cI.ptHotSpot.x = cI.ptHotSpot.y = 15; @@ -519,7 +513,7 @@ HCURSOR16 CURSORICON_IconToCursor(HICON16 hIcon, BOOL32 bSemiTransparent) hRet = CURSORICON_Copy( pTask->hInstance , CURSORICON_Load(0,MAKEINTRESOURCE(OCR_DRAGOBJECT), SYSMETRICS_CXCURSOR, SYSMETRICS_CYCURSOR, 1, TRUE) ); - } + } return hRet; } @@ -1149,3 +1143,8 @@ HICON16 LoadIconHandler( HGLOBAL16 hResource, BOOL16 bNew ) } return CURSORICON_LoadHandler( hResource, 0, FALSE); } + +/********************************************************************** + * GetIconInfo (USER32.241) + */ + diff --git a/objects/dib.c b/objects/dib.c index 0eb78f0c47..a951745c43 100644 --- a/objects/dib.c +++ b/objects/dib.c @@ -18,53 +18,51 @@ extern void CLIPPING_UpdateGCRegion(DC* ); +static int bitmapDepthTable[] = { 8, 1, 32, 16, 24, 15, 4, 0 }; +static int ximageDepthTable[] = { 0, 0, 0, 0, 0, 0, 0 }; + /*********************************************************************** - * DIB_GetImageWidthBytesX11 - * - * Return the width of an X image in bytes + * DIB_Init */ -int DIB_GetImageWidthBytesX11( int width, int depth ) +BOOL32 DIB_Init() { - int wbits; - XImage *testimage; + int i; + XImage* testimage; -#define DEPTHCASE(depth) \ - case depth: { \ - static int w##depth = 0; \ - if (! w##depth ) { \ - testimage=XCreateImage(display,DefaultVisualOfScreen(screen),\ - depth,ZPixmap,0,NULL,1,1,32,20); \ - w##depth = testimage->bits_per_pixel; \ - XDestroyImage(testimage); \ - } \ - wbits = width*w##depth; \ - break; \ - } - - switch(depth) + for( i = 0; bitmapDepthTable[i]; i++ ) { - DEPTHCASE(1); - DEPTHCASE(4); - DEPTHCASE(8); - DEPTHCASE(15); - DEPTHCASE(16); - DEPTHCASE(24); - DEPTHCASE(32); - default: - fprintf(stderr, "DIB: unsupported depth %d.\n", depth ); - /* assume 32 bits/pixel */ - wbits = width*32; - break; + testimage = XCreateImage(display, DefaultVisualOfScreen(screen), + bitmapDepthTable[i], ZPixmap, 0, NULL, 1, 1, 32, 20 ); + if( testimage ) ximageDepthTable[i] = testimage->bits_per_pixel; + else return FALSE; + XDestroyImage(testimage); } - return 4 * ((wbits+31)/32); + return TRUE; } /*********************************************************************** - * DIB_GetImageWidthBytes + * DIB_GetXImageWidthBytes * * Return the width of an X image in bytes */ -int DIB_GetImageWidthBytes( int width, int depth ) +int DIB_GetXImageWidthBytes( int width, int depth ) +{ + int i; + + for( i = 0; bitmapDepthTable[i] ; i++ ) + if( bitmapDepthTable[i] == depth ) + return (4 * ((width * ximageDepthTable[i] + 31)/32)); + fprintf(stderr, "DIB: unsupported depth %d.\n", depth ); + return (4 * width); +} + +/*********************************************************************** + * DIB_GetDIBWidthBytes + * + * Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned. + * http://www.microsoft.com/msdn/sdk/platforms/doc/sdk/win32/struc/src/str01.htm + */ +int DIB_GetDIBWidthBytes( int width, int depth ) { int words; @@ -90,7 +88,7 @@ int DIB_GetImageWidthBytes( int width, int depth ) /*********************************************************************** * DIB_BitmapInfoSize * - * Return the size of the bitmap info structure. + * Return the size of the bitmap info structure including color table. */ int DIB_BitmapInfoSize( BITMAPINFO * info, WORD coloruse ) { @@ -791,6 +789,8 @@ INT16 GetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan, /*********************************************************************** * GetDIBits32 (GDI32.170) + * + * http://www.microsoft.com/msdn/sdk/platforms/doc/sdk/win32/func/src/f30_14.htm */ INT32 GetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan, UINT32 lines, LPSTR bits, BITMAPINFO * info, @@ -864,7 +864,7 @@ INT32 GetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan, switch( info->bmiHeader.biBitCount ) { case 8: - /* pad up to 32 bit (FIXME: not 16? ) */ + /* pad up to 32 bit */ pad += (4 - (info->bmiHeader.biWidth & 3)) & 3; for( y = yend - 1; (int)y >= (int)startscan; y-- ) { @@ -953,8 +953,8 @@ INT32 GetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan, info->bmiHeader.biPlanes = 1; info->bmiHeader.biBitCount = bmp->bitmap.bmBitsPixel; info->bmiHeader.biSizeImage = bmp->bitmap.bmHeight * - DIB_GetImageWidthBytes( bmp->bitmap.bmWidth, - bmp->bitmap.bmBitsPixel ); + DIB_GetDIBWidthBytes( bmp->bitmap.bmWidth, + bmp->bitmap.bmBitsPixel ); info->bmiHeader.biCompression = 0; } diff --git a/objects/gdiobj.c b/objects/gdiobj.c index 4422ed8215..89aad658d6 100644 --- a/objects/gdiobj.c +++ b/objects/gdiobj.c @@ -156,10 +156,12 @@ BOOL32 GDI_Init(void) { HPALETTE16 hpalette; extern BOOL32 X11DRV_Init(void); + extern BOOL32 DIB_Init(void); /* Initialize drivers */ if (!X11DRV_Init()) return FALSE; + if (!DIB_Init()) return FALSE; /* Create default palette */ diff --git a/objects/metafile.c b/objects/metafile.c index 402e0aabd4..5c5da99185 100644 --- a/objects/metafile.c +++ b/objects/metafile.c @@ -607,30 +607,38 @@ void PlayMetaFileRecord16( HDC16 hdc, HANDLETABLE16 *ht, METARECORD *mr, case META_EXTTEXTOUT: { LPINT16 dxx; + LPSTR sot; DWORD len; s1 = mr->rdParam[2]; /* String length */ len = sizeof(METARECORD) + (((s1 + 1) >> 1) * 2) + 2 * sizeof(short) - + sizeof(UINT16) + sizeof(RECT16); - if (mr->rdSize == len / 2) - dxx = NULL; /* No array present */ - else if (mr->rdSize == (len + s1 * sizeof(INT16)) / 2) - dxx = &mr->rdParam[8+(s1+1)/2]; /* start of array */ - else { - fprintf(stderr, - "PlayMetaFileRecord ExtTextOut mr->rdSize = %08lx, count = %x\n", - mr->rdSize, s1); - dxx = NULL; - } + + sizeof(UINT16) + (mr->rdParam[3] ? sizeof(RECT16) : 0); /* rec len without dx array */ + + sot= (LPSTR)&mr->rdParam[4]; /* start_of_text */ + if (mr->rdParam[3]) + sot+=sizeof(RECT16); /* there is a rectangle, so add offset */ + + if (mr->rdSize == len / 2) + dxx = NULL; /* determine if array present */ + else + if (mr->rdSize == (len + s1 * sizeof(INT16)) / 2) + dxx = (LPINT16)(sot+(((s1+1)>>1)*2)); + else + { + fprintf(stderr, + "Please report: PlayMetaFile/ExtTextOut len=%ld slen=%d rdSize=%ld opt=%04x\n", + len,s1,mr->rdSize,mr->rdParam[3]); + dxx = NULL; /* should't happen -- but if, we continue with NULL [for workaround] */ + } ExtTextOut16( hdc, mr->rdParam[1], /* X position */ mr->rdParam[0], /* Y position */ mr->rdParam[3], /* options */ - (LPRECT16) &mr->rdParam[4], /* rectangle */ - (char *)(mr->rdParam + 8), /* string */ + mr->rdParam[3] ? (LPRECT16) &mr->rdParam[4]:NULL, /* rectangle */ + sot, /* string */ s1, dxx); /* length, dx array */ if (dxx) - dprintf_metafile(stddeb,"EXTTEXTOUT len: %ld (%hd %hd) [%s].\n", - mr->rdSize,dxx[0],dxx[1],(char*) &(mr->rdParam[8]) ); + dprintf_metafile(stddeb,"EXTTEXTOUT: %s len: %ld dx0: %d\n", + sot,mr->rdSize,dxx[0]); } break; @@ -740,16 +748,29 @@ void PlayMetaFileRecord16( HDC16 hdc, HANDLETABLE16 *ht, METARECORD *mr, GlobalFree16(hndl); break; + case META_DIBBITBLT: + { + LPBITMAPINFO info = (LPBITMAPINFO) &(mr->rdParam[8]); + LPSTR bits = (LPSTR)info + DIB_BitmapInfoSize( info, mr->rdParam[0] ); + StretchDIBits16(hdc,mr->rdParam[7],mr->rdParam[6],mr->rdParam[5], + mr->rdParam[4],mr->rdParam[3],mr->rdParam[2], + mr->rdParam[5],mr->rdParam[4],bits,info, + DIB_RGB_COLORS,MAKELONG(mr->rdParam[0],mr->rdParam[1])); + } + break; + + case META_SETTEXTJUSTIFICATION: + SetTextJustification32(hdc, *(mr->rdParam + 1), *(mr->rdParam)); + break; + #define META_UNIMP(x) case x: fprintf(stderr,"PlayMetaFileRecord:record type "#x" not implemented.\n");break; META_UNIMP(META_SETTEXTCHAREXTRA) - META_UNIMP(META_SETTEXTJUSTIFICATION) META_UNIMP(META_FRAMEREGION) META_UNIMP(META_DRAWTEXT) META_UNIMP(META_SETDIBTODEV) META_UNIMP(META_ANIMATEPALETTE) META_UNIMP(META_SETPALENTRIES) META_UNIMP(META_RESIZEPALETTE) - META_UNIMP(META_DIBBITBLT) META_UNIMP(META_EXTFLOODFILL) META_UNIMP(META_RESETDC) META_UNIMP(META_STARTDOC) diff --git a/resources/sysres_Es.rc b/resources/sysres_Es.rc index e3b3dacc30..d7b048e8ab 100644 --- a/resources/sysres_Es.rc +++ b/resources/sysres_Es.rc @@ -1,7 +1,7 @@ SYSMENU MENU LOADONCALL MOVEABLE DISCARDABLE { - MENUITEM "&Restaurer", 61728 + MENUITEM "&Restaurar", 61728 MENUITEM "&Mover", 61456 MENUITEM "&Tamaño", 61440 MENUITEM "Mi&nimizar", 61472 @@ -20,12 +20,12 @@ EDITMENU MENU LOADONCALL MOVEABLE DISCARDABLE BEGIN MENUITEM "&Undo", EM_UNDO32 MENUITEM SEPARATOR - MENUITEM "Cu&t", WM_CUT - MENUITEM "&Copy", WM_COPY - MENUITEM "&Paste", WM_PASTE - MENUITEM "&Delete", WM_CLEAR + MENUITEM "Co&rtar", WM_CUT + MENUITEM "&Copiar", WM_COPY + MENUITEM "&Pegar", WM_PASTE + MENUITEM "&Borrar", WM_CLEAR MENUITEM SEPARATOR - MENUITEM "Select &All", EM_SETSEL32 + MENUITEM "Seleccionar &todo", EM_SETSEL32 END } @@ -148,36 +148,66 @@ FONT 8, "Helv" } -CHOOSE_FONT DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 264, 134 +CHOOSE_FONT DIALOG DISCARDABLE 13, 54, 264, 147 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU CAPTION "Fuente" FONT 8, "Helv" { - LTEXT "Fuente:", 1088, 6, 6, 40, 9 - LTEXT "", 1089, 60, 6, 150, 9 - DEFPUSHBUTTON "Aceptar", 1, 206, 6, 56, 14, BS_DEFPUSHBUTTON | WS_GROUP | WS_TABSTOP - PUSHBUTTON "Cancelar", 2, 206, 24, 56, 14, WS_GROUP | WS_TABSTOP + LTEXT "&Fuente:",1088 ,6,3,40,9 + COMBOBOX 1136 ,6,13,94,54, CBS_OWNERDRAWFIXED | CBS_HASSTRINGS | CBS_DISABLENOSCROLL | + CBS_AUTOHSCROLL | CBS_SORT | WS_VSCROLL | WS_TABSTOP | CBS_SIMPLE + LTEXT "Est&ilo de fuente:",1089 ,108,3,44,9 + COMBOBOX 1137,108,13,64,54, CBS_OWNERDRAWFIXED | CBS_HASSTRINGS | CBS_DISABLENOSCROLL | + WS_VSCROLL | WS_TABSTOP | CBS_SIMPLE + LTEXT "&Tamaño:",1090,179,3,30,9 + COMBOBOX 1138,179,13,32,54, CBS_OWNERDRAWFIXED | CBS_HASSTRINGS | CBS_DISABLENOSCROLL | + WS_VSCROLL | WS_TABSTOP | CBS_SIMPLE | CBS_SORT + DEFPUSHBUTTON "Aceptar",IDOK,218,6,40,14,WS_GROUP + PUSHBUTTON "Cancelar",IDCANCEL,218,23,40,14,WS_GROUP + PUSHBUTTON "A&plicar", 1026,218,40,40,14,WS_GROUP + PUSHBUTTON "A&yuda" , 1038,218,57,40,14,WS_GROUP + GROUPBOX "&Efectos",1072,6,72,84,34,WS_GROUP + CHECKBOX "&Rayado", 1040, 10,82,50,10, BS_AUTOCHECKBOX | WS_TABSTOP + CHECKBOX "&Subrayado", 1041, 10,94,50,10, BS_AUTOCHECKBOX + LTEXT "&Color:", 1091 ,6,110,30,9 + COMBOBOX 1139,6,120,84,100,CBS_DROPDOWNLIST | CBS_OWNERDRAWFIXED | CBS_HASSTRINGS | + CBS_AUTOHSCROLL | WS_BORDER | WS_VSCROLL | WS_TABSTOP + GROUPBOX "Ejemplo",1073,98,72,160,49,WS_GROUP + CTEXT "AaBbYyZzÑñ",1093,104,81,149,37,SS_NOPREFIX | WS_VISIBLE } -CHOOSE_COLOR DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 264, 200 +CHOOSE_COLOR DIALOG LOADONCALL MOVEABLE DISCARDABLE 36, 24, 300, 200 STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU CAPTION "Color" FONT 8, "Helv" { - LTEXT "Colores &basicos:", 1088, 6, 6, 40, 9 - LTEXT "Colores person&alizados:", 1089, 6, 126, 40, 9 - LTEXT "Color|Sól&ido", 1090, 100, 146, 40, 9 - LTEXT "&Hue:", 1091, 150, 126, 40, 9 - LTEXT "&Sat:", 1092, 150, 146, 40, 9 - LTEXT "&Lum:", 1093, 150, 166, 40, 9 - LTEXT "&Rojo:", 1094, 150, 126, 40, 9 - LTEXT "&Verde:", 1095, 150, 146, 40, 9 - LTEXT "A&zul:", 1096, 150, 166, 40, 9 - DEFPUSHBUTTON "Aceptar", 1, 6, 182, 56, 14, BS_DEFPUSHBUTTON | WS_GROUP | WS_TABSTOP - PUSHBUTTON "Agregar a los &colores personalizados", 1024, 120, 182, 100, 14, WS_GROUP | WS_TABSTOP - PUSHBUTTON "Borrar colores personalizados", 1025, 6, 164, 56, 14, WS_GROUP | WS_TABSTOP - PUSHBUTTON "Cancelar", 2, 76, 182, 56, 14, WS_GROUP | WS_TABSTOP + LTEXT "Colores &básicos:", 1088, 4, 4, 140, 10 + LTEXT "Colores person&alizados:", 1089, 4, 106, 140, 10 + LTEXT "Color|Só3l&ido", 1090, 150, 151, 48, 10 + LTEXT "&Rojo:", 726 /*1094*/,249,126,24,10 + EDITTEXT 706, 275,124,18,12, WS_BORDER | WS_GROUP | WS_TABSTOP + LTEXT "&Verde:",727/*1095*/,249,140,24,10 + EDITTEXT 707, 275,138,18,12, WS_BORDER | WS_GROUP | WS_TABSTOP + LTEXT "A&zul:",728 /*1096*/,249,154,24,10 + EDITTEXT 708, 275,152,18,12, WS_BORDER | WS_GROUP | WS_TABSTOP + LTEXT "&Tinte:" ,723 /*1091*/,202,126,22,10 + EDITTEXT 703, 226,124,18,12, WS_BORDER | WS_GROUP | WS_TABSTOP + LTEXT "&Sat.:" ,724 /*1092*/,202,140,22,10 + EDITTEXT 704, 226,138,18,12, WS_BORDER | WS_GROUP | WS_TABSTOP + LTEXT "&Lum.:" ,725 /*1093*/,202,154,22,10 + EDITTEXT 705, 226,152,18,12, WS_BORDER | WS_GROUP | WS_TABSTOP + CONTROL "" ,720,"STATIC",SS_SIMPLE|WS_TABSTOP|WS_GROUP,4,14,140,86 + CONTROL "" ,721,"STATIC",SS_SIMPLE|WS_TABSTOP|WS_GROUP,4,116,140,28 + CONTROL "" ,710,"STATIC",WS_BORDER|SS_SIMPLE|WS_TABSTOP|WS_GROUP, 152,4,118,116 CONTROL "" ,702,"STATIC",SS_SIMPLE|WS_TABSTOP|WS_GROUP, 278,4,8,116 + CONTROL "" ,702,"STATIC",SS_SIMPLE|WS_TABSTOP|WS_GROUP, 278,4,8,116 + CONTROL "" ,709,"STATIC",SS_SIMPLE|WS_TABSTOP|WS_GROUP, 152,124,40,26 + DEFPUSHBUTTON "Aceptar", 1, 4, 166, 44, 14, BS_DEFPUSHBUTTON | WS_GROUP | WS_TABSTOP + PUSHBUTTON "Cancelar", 2, 52, 166, 44, 14, WS_GROUP | WS_TABSTOP + PUSHBUTTON "A&yuda", 1038,100,166, 44, 14 + PUSHBUTTON "Agregar a los &colores personalizados", 712/*1024*/, 152, 166, 142, 14, WS_GROUP | WS_TABSTOP + PUSHBUTTON "&Definir colores personalizados >>", 719/*1025*/, 4, 150, 142, 14, WS_GROUP | WS_TABSTOP + PUSHBUTTON "&i",713,300,200,4,14 /* just a dummy: 'i' is like &i in "sol&id" */ } diff --git a/win32/cursoricon32.c b/win32/cursoricon32.c index 0a22a3882f..4ce417e860 100644 --- a/win32/cursoricon32.c +++ b/win32/cursoricon32.c @@ -339,7 +339,7 @@ static HGLOBAL32 CURSORICON32_LoadHandler( HANDLE32 handle, BITMAPINFOHEADER *bih = &pInfo->bmiHeader; RGBQUAD *rgb = pInfo->bmiColors; bits = (char *)bmi + size + - DIB_GetImageWidthBytes(bih->biWidth,bih->biBitCount)*bih->biHeight; + DIB_GetDIBWidthBytes(bih->biWidth,bih->biBitCount)*bih->biHeight; bih->biBitCount = 1; bih->biClrUsed = bih->biClrImportant = 2; rgb[0].rgbBlue = rgb[0].rgbGreen = rgb[0].rgbRed = 0x00; @@ -351,7 +351,7 @@ static HGLOBAL32 CURSORICON32_LoadHandler( HANDLE32 handle, BITMAPCOREHEADER *bch = (BITMAPCOREHEADER *)pInfo; RGBTRIPLE *rgb = (RGBTRIPLE *)(bch + 1); bits = (char *)bmi + size + - DIB_GetImageWidthBytes(bch->bcWidth,bch->bcBitCount)*bch->bcHeight; + DIB_GetDIBWidthBytes(bch->bcWidth,bch->bcBitCount)*bch->bcHeight; bch->bcBitCount = 1; rgb[0].rgbtBlue = rgb[0].rgbtGreen = rgb[0].rgbtRed = 0x00; rgb[1].rgbtBlue = rgb[1].rgbtGreen = rgb[1].rgbtRed = 0xff; diff --git a/win32/file.c b/win32/file.c index 98b4ffec30..3bb4fed5e1 100644 --- a/win32/file.c +++ b/win32/file.c @@ -25,6 +25,7 @@ #define DEBUG_WIN32 #include "debug.h" +DWORD ErrnoToLastError(int errno_num); static int TranslateCreationFlags(DWORD create_flags); static int TranslateAccessFlags(DWORD access_flags); diff --git a/win32/process.c b/win32/process.c index 54baf23e42..deb34dde1f 100644 --- a/win32/process.c +++ b/win32/process.c @@ -325,7 +325,7 @@ DWORD WaitForSingleObject(HANDLE32 h, DWORD timeout) } /*********************************************************************** - * WaitForSingleObject (USER32.399) + * WaitForMultipleObjects (USER32.399) */ DWORD MsgWaitForMultipleObjects( DWORD nCount,HANDLE32 *pHandles,BOOL32 fWaitAll,DWORD dwMilliseconds, diff --git a/windows/defwnd.c b/windows/defwnd.c index 2083d51481..1694a79b8f 100644 --- a/windows/defwnd.c +++ b/windows/defwnd.c @@ -28,6 +28,8 @@ static short iF10Key = 0; static short iMenuSysKey = 0; +extern void EndMenu(void); + /*********************************************************************** * DEFWND_HandleWindowPosChanged * @@ -328,8 +330,7 @@ static LRESULT DEFWND_DefWinProc( WND *wndPtr, UINT32 msg, WPARAM32 wParam, break; case WM_CANCELMODE: - /* EndMenu() should be called if in menu state but currently it's - impossible to detect - menu code should be updated*/ + if (wndPtr->parent == WIN_GetDesktop()) EndMenu(); if (GetCapture32() == wndPtr->hwndSelf) ReleaseCapture(); break; diff --git a/windows/driver.c b/windows/driver.c index 4eb0880651..942ecc8e7b 100644 --- a/windows/driver.c +++ b/windows/driver.c @@ -61,8 +61,8 @@ LRESULT SendDriverMessage(HDRVR16 hDriver, UINT16 msg, LPARAM lParam1, return 0; } - retval = CallDriverProc( lpdrv->lpDrvProc, 0L /* FIXME */, hDriver, msg, - lParam1, lParam2 ); + retval = CallDriverProc( (FARPROC16)lpdrv->lpDrvProc, 0L /* FIXME */, + hDriver, msg, lParam1, lParam2 ); dprintf_driver( stddeb, "SendDriverMessage // retval = %ld\n", retval ); diff --git a/windows/graphics.c b/windows/graphics.c index 3955937410..44aa69fc7e 100644 --- a/windows/graphics.c +++ b/windows/graphics.c @@ -11,6 +11,7 @@ #include #include #include "graphics.h" +#include "color.h" #include "bitmap.h" #include "gdi.h" #include "dc.h" @@ -65,7 +66,7 @@ BOOL32 GRAPH_DrawLines( HDC32 hdc, LPPOINT32 pXY, INT32 N, HPEN32 hPen ) */ BOOL32 GRAPH_DrawBitmap( HDC32 hdc, HBITMAP32 hbitmap, INT32 xdest, INT32 ydest, INT32 xsrc, INT32 ysrc, - INT32 width, INT32 height ) + INT32 width, INT32 height, BOOL32 bMono ) { BITMAPOBJ *bmp; DC *dc; @@ -73,24 +74,43 @@ BOOL32 GRAPH_DrawBitmap( HDC32 hdc, HBITMAP32 hbitmap, if (!(dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC ))) return FALSE; if (!(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC ))) return FALSE; + + xdest += dc->w.DCOrgX; ydest += dc->w.DCOrgY; + XSetFunction( display, dc->u.x.gc, GXcopy ); if (bmp->bitmap.bmBitsPixel == 1) { XSetForeground( display, dc->u.x.gc, dc->w.backgroundPixel ); XSetBackground( display, dc->u.x.gc, dc->w.textPixel ); XCopyPlane( display, bmp->pixmap, dc->u.x.drawable, dc->u.x.gc, - xsrc, ysrc, width, height, - dc->w.DCOrgX + xdest, dc->w.DCOrgY + ydest, 1 ); - return TRUE; + xsrc, ysrc, width, height, xdest, ydest, 1 ); } else if (bmp->bitmap.bmBitsPixel == dc->w.bitsPerPixel) { - XCopyArea( display, bmp->pixmap, dc->u.x.drawable, dc->u.x.gc, - xsrc, ysrc, width, height, - dc->w.DCOrgX + xdest, dc->w.DCOrgY + ydest ); - return TRUE; + if( bMono ) + { + INT32 plane; + + if( COLOR_GetMonoPlane(&plane) ) + { + XSetForeground( display, dc->u.x.gc, dc->w.backgroundPixel ); + XSetBackground( display, dc->u.x.gc, dc->w.textPixel ); + } + else + { + XSetForeground( display, dc->u.x.gc, dc->w.textPixel ); + XSetBackground( display, dc->u.x.gc, dc->w.backgroundPixel ); + } + XCopyPlane( display, bmp->pixmap, dc->u.x.drawable, dc->u.x.gc, + xsrc, ysrc, width, height, xdest, ydest, plane ); + } + else + XCopyArea( display, bmp->pixmap, dc->u.x.drawable, + dc->u.x.gc, xsrc, ysrc, width, height, xdest, ydest ); } else return FALSE; + + return TRUE; } diff --git a/windows/keyboard.c b/windows/keyboard.c index ce297aa333..d1a6b117a1 100644 --- a/windows/keyboard.c +++ b/windows/keyboard.c @@ -639,7 +639,7 @@ msg->hwnd=%04x, msg->message=%04x\n", hAccel,hWnd,msg->hwnd,msg->message); if (sendmsg) /* found an accelerator, but send a message... ? */ { INT16 iSysStat,iStat,mesg=0; - HMENU16 hSysMenu,hMenu; + HMENU16 hMenu; if (msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP) mesg=1; @@ -651,16 +651,14 @@ msg->hwnd=%04x, msg->message=%04x\n", hAccel,hWnd,msg->hwnd,msg->message); mesg=3; else { - hMenu=GetMenu32(hWnd); - hSysMenu=GetSystemMenu32(hWnd,FALSE); - if (hSysMenu) - iSysStat=GetMenuState32(hSysMenu,lpAccelTbl->tbl[i].wIDval,MF_BYCOMMAND); - else - iSysStat=-1; - if (hMenu) - iStat=GetMenuState32(hMenu,lpAccelTbl->tbl[i].wIDval,MF_BYCOMMAND); - else - iStat=-1; + WND* wndPtr = WIN_FindWndPtr(hWnd); + + hMenu = (wndPtr->dwStyle & WS_CHILD) ? 0 : (HMENU32)wndPtr->wIDmenu; + iSysStat = (wndPtr->hSysMenu) ? GetMenuState32(GetSubMenu16(wndPtr->hSysMenu, 0), + lpAccelTbl->tbl[i].wIDval, MF_BYCOMMAND) : -1 ; + iStat = (hMenu) ? GetMenuState32(hMenu, + lpAccelTbl->tbl[i].wIDval, MF_BYCOMMAND) : -1 ; + if (iSysStat!=-1) { if (iSysStat & (MF_DISABLED|MF_GRAYED)) diff --git a/windows/mdi.c b/windows/mdi.c index e08e08db6a..e301cbf212 100644 --- a/windows/mdi.c +++ b/windows/mdi.c @@ -30,6 +30,8 @@ #include "stddebug.h" #include "debug.h" +#define MDIF_NEEDUPDATE 0x0001 + static HBITMAP16 hBmpClose = 0; static HBITMAP16 hBmpRestore = 0; @@ -57,9 +59,9 @@ static HWND16 MDI_GetChildByID(WND* wndPtr,int id) static void MDI_PostUpdate(HWND16 hwnd, MDICLIENTINFO* ci, WORD recalc) { - if( !ci->sbNeedUpdate ) + if( !(ci->mdiFlags & MDIF_NEEDUPDATE) ) { - ci->sbNeedUpdate = TRUE; + ci->mdiFlags |= MDIF_NEEDUPDATE; PostMessage16( hwnd, WM_MDICALCCHILDSCROLL, 0, 0); } ci->sbRecalc = recalc; @@ -980,7 +982,6 @@ static void MDI_UpdateFrameText( WND *frameWnd, HWND16 hClient, LRESULT MDIClientWndProc(HWND16 hwnd, UINT16 message, WPARAM16 wParam, LPARAM lParam) { LPCREATESTRUCT16 cs; - LPCLIENTCREATESTRUCT16 ccs; MDICLIENTINFO *ci; RECT16 rect; WND *w = WIN_FindWndPtr(hwnd); @@ -999,17 +1000,25 @@ LRESULT MDIClientWndProc(HWND16 hwnd, UINT16 message, WPARAM16 wParam, LPARAM lP * so we have to keep track of what environment we're in. */ if( w->flags & WIN_ISWIN32 ) - ccs = (LPCLIENTCREATESTRUCT16) cs->lpCreateParams; + { +#define ccs ((LPCLIENTCREATESTRUCT32)cs->lpCreateParams) + ci->hWindowMenu = ccs->hWindowMenu; + ci->idFirstChild = ccs->idFirstChild; +#undef ccs + } else - ccs = (LPCLIENTCREATESTRUCT16) PTR_SEG_TO_LIN(cs->lpCreateParams); + { + LPCLIENTCREATESTRUCT16 ccs = (LPCLIENTCREATESTRUCT16) + PTR_SEG_TO_LIN(cs->lpCreateParams); + ci->hWindowMenu = ccs->hWindowMenu; + ci->idFirstChild = ccs->idFirstChild; + } - ci->hWindowMenu = ccs->hWindowMenu; - ci->idFirstChild = ccs->idFirstChild; ci->hwndChildMaximized = 0; ci->nActiveChildren = 0; ci->nTotalCreated = 0; ci->frameTitle = NULL; - ci->sbNeedUpdate = 0; + ci->mdiFlags = 0; ci->self = hwnd; w->dwStyle |= WS_CLIPCHILDREN; @@ -1020,7 +1029,7 @@ LRESULT MDIClientWndProc(HWND16 hwnd, UINT16 message, WPARAM16 wParam, LPARAM lP } MDI_UpdateFrameText(frameWnd, hwnd, MDI_NOFRAMEREPAINT,frameWnd->text); - AppendMenu32A( ccs->hWindowMenu, MF_SEPARATOR, 0, NULL ); + AppendMenu32A( ci->hWindowMenu, MF_SEPARATOR, 0, NULL ); GetClientRect16(frameWnd->hwndSelf, &rect); NC_HandleNCCalcSize( w, &rect ); @@ -1064,7 +1073,7 @@ LRESULT MDIClientWndProc(HWND16 hwnd, UINT16 message, WPARAM16 wParam, LPARAM lP ((LONG) (ci->hwndChildMaximized>0) << 16)); case WM_MDIICONARRANGE: - ci->sbNeedUpdate = TRUE; + ci->mdiFlags |= MDIF_NEEDUPDATE; MDIIconArrange(hwnd); ci->sbRecalc = SB_BOTH+1; SendMessage16(hwnd,WM_MDICALCCHILDSCROLL,0,0L); @@ -1090,17 +1099,17 @@ LRESULT MDIClientWndProc(HWND16 hwnd, UINT16 message, WPARAM16 wParam, LPARAM lP #endif case WM_MDITILE: - ci->sbNeedUpdate = TRUE; + ci->mdiFlags |= MDIF_NEEDUPDATE; ShowScrollBar32(hwnd,SB_BOTH,FALSE); MDITile(w, ci,wParam); - ci->sbNeedUpdate = FALSE; + ci->mdiFlags &= ~MDIF_NEEDUPDATE; return 0; case WM_VSCROLL: case WM_HSCROLL: - ci->sbNeedUpdate = TRUE; + ci->mdiFlags |= MDIF_NEEDUPDATE; ScrollChildren32(hwnd,message,wParam,lParam); - ci->sbNeedUpdate = FALSE; + ci->mdiFlags &= ~MDIF_NEEDUPDATE; return 0; case WM_SETFOCUS: @@ -1132,27 +1141,27 @@ LRESULT MDIClientWndProc(HWND16 hwnd, UINT16 message, WPARAM16 wParam, LPARAM lP return 0; case WM_SIZE: - if( ci->hwndChildMaximized ) - { - WND* child = WIN_FindWndPtr(ci->hwndChildMaximized); - RECT16 rect = { 0, 0, LOWORD(lParam), HIWORD(lParam) }; + if( ci->hwndChildMaximized ) + { + WND* child = WIN_FindWndPtr(ci->hwndChildMaximized); + RECT16 rect = { 0, 0, LOWORD(lParam), HIWORD(lParam) }; - AdjustWindowRectEx16(&rect, child->dwStyle, 0, child->dwExStyle); - MoveWindow16(ci->hwndChildMaximized, rect.left, rect.top, - rect.right - rect.left, rect.bottom - rect.top, 1); - } + AdjustWindowRectEx16(&rect, child->dwStyle, 0, child->dwExStyle); + MoveWindow16(ci->hwndChildMaximized, rect.left, rect.top, + rect.right - rect.left, rect.bottom - rect.top, 1); + } else MDI_PostUpdate(hwnd, ci, SB_BOTH+1); break; case WM_MDICALCCHILDSCROLL: - if( ci->sbNeedUpdate ) - if( ci->sbRecalc ) - { - CalcChildScroll(hwnd, ci->sbRecalc-1); - ci->sbRecalc = ci->sbNeedUpdate = 0; - } + if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc ) + { + CalcChildScroll(hwnd, ci->sbRecalc-1); + ci->sbRecalc = 0; + ci->mdiFlags &= ~MDIF_NEEDUPDATE; + } return 0; } @@ -1236,20 +1245,20 @@ LRESULT DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient, UINT16 message, if( !(wndPtr->parent->dwStyle & WS_MINIMIZE) && ci->hwndActiveChild && !ci->hwndChildMaximized ) - { + { /* control menu is between the frame system menu and * the first entry of menu bar */ - if( wParam == VK_LEFT ) - { if( wndPtr->parent->wIDmenu != LOWORD(lParam) ) break; } - else if( wParam == VK_RIGHT ) - { if( GetSystemMenu16( wndPtr->parent->hwndSelf, 0) - != LOWORD(lParam) ) break; } - else break; - - return MAKELONG( GetSystemMenu16(ci->hwndActiveChild, 0), - ci->hwndActiveChild ); - } + if( (wParam == VK_LEFT && + wndPtr->parent->wIDmenu == LOWORD(lParam)) || + (wParam == VK_RIGHT && + GetSubMenu16(wndPtr->parent->hSysMenu, 0) == LOWORD(lParam)) ) + { + wndPtr = WIN_FindWndPtr(ci->hwndActiveChild); + return MAKELONG( GetSubMenu16(wndPtr->hSysMenu, 0), + ci->hwndActiveChild); + } + } break; } } @@ -1405,8 +1414,7 @@ LRESULT DefMDIChildProc16( HWND16 hwnd, UINT16 message, return 0; case WM_SETVISIBLE: - if( ci->hwndChildMaximized) - ci->sbNeedUpdate = 0; + if( ci->hwndChildMaximized) ci->mdiFlags &= ~MDIF_NEEDUPDATE; else MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1); break; @@ -1469,7 +1477,7 @@ LRESULT DefMDIChildProc16( HWND16 hwnd, UINT16 message, case WM_NEXTMENU: if( wParam == VK_LEFT ) /* switch to frame system menu */ - return MAKELONG( GetSystemMenu16(clientWnd->parent->hwndSelf, 0), + return MAKELONG( GetSubMenu16(clientWnd->parent->hSysMenu, 0), clientWnd->parent->hwndSelf ); if( wParam == VK_RIGHT ) /* to frame menu bar */ return MAKELONG( clientWnd->parent->wIDmenu, @@ -1598,42 +1606,49 @@ BOOL32 TranslateMDISysAccel32( HWND32 hwndClient, LPMSG32 msg ) */ BOOL16 TranslateMDISysAccel16( HWND16 hwndClient, LPMSG16 msg ) { - WND* clientWnd = WIN_FindWndPtr( hwndClient); - WND* wnd; - MDICLIENTINFO *ci = NULL; - WPARAM16 wParam = 0; + WND* clientWnd = WIN_FindWndPtr( hwndClient); + WND* wnd; + MDICLIENTINFO *ci = NULL; + WPARAM16 wParam = 0; - if( (msg->message != WM_KEYDOWN && msg->message != WM_SYSKEYDOWN) || !clientWnd ) - return 0; + if( clientWnd && (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)) + { + MDICLIENTINFO *ci = NULL; + WND* wnd; - ci = (MDICLIENTINFO*) clientWnd->wExtra; - wnd = WIN_FindWndPtr(ci->hwndActiveChild); - - if( !wnd ) return 0; + ci = (MDICLIENTINFO*) clientWnd->wExtra; + wnd = WIN_FindWndPtr(ci->hwndActiveChild); + if( wnd && !(wnd->dwStyle & WS_DISABLED) ) + { + WPARAM16 wParam = 0; + + /* translate if the Ctrl key is down and Alt not. */ - if( wnd->dwStyle & WS_DISABLED ) return 0; - - if ((GetKeyState32(VK_CONTROL) & 0x8000) && !(GetKeyState32(VK_MENU) & 0x8000)) - switch( msg->wParam ) - { - case VK_F6: - case VK_SEPARATOR: - wParam = ( GetKeyState32(VK_SHIFT) & 0x8000 )? SC_NEXTWINDOW: SC_PREVWINDOW; - break; - case VK_F4: - case VK_RBUTTON: - wParam = SC_CLOSE; - break; - default: - return 0; - } - else - return 0; - - dprintf_mdi(stddeb,"TranslateMDISysAccel: wParam = %04x\n", wParam); - - SendMessage16(ci->hwndActiveChild,WM_SYSCOMMAND, wParam, (LPARAM)msg->wParam); - return 1; + if( (GetKeyState32(VK_CONTROL) & 0x8000) && + !(GetKeyState32(VK_MENU) & 0x8000)) + { + switch( msg->wParam ) + { + case VK_F6: + case VK_SEPARATOR: + wParam = ( GetKeyState32(VK_SHIFT) & 0x8000 ) + ? SC_NEXTWINDOW : SC_PREVWINDOW; + break; + case VK_F4: + case VK_RBUTTON: + wParam = SC_CLOSE; + break; + default: + return 0; + } + dprintf_mdi(stddeb,"TranslateMDISysAccel: wParam = %04x\n", wParam); + SendMessage16( ci->hwndActiveChild, WM_SYSCOMMAND, + wParam, (LPARAM)msg->wParam); + return 1; + } + } + } + return 0; /* failure */ } diff --git a/windows/message.c b/windows/message.c index 751212ce4a..80c3e5c0ae 100644 --- a/windows/message.c +++ b/windows/message.c @@ -1055,7 +1055,7 @@ LRESULT SendMessage16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam) fprintf( stderr, "SendMessage16: invalid hwnd %04x\n", hwnd ); return 0; } - if (QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ)) + if (QUEUE_IsExitingQueue(wndPtr->hmemTaskQ)) return 0; /* Don't send anything if the task is dying */ if (wndPtr->hmemTaskQ != GetTaskQueue(0)) return MSG_SendMessage( wndPtr->hmemTaskQ, hwnd, msg, wParam, lParam ); @@ -1120,7 +1120,7 @@ LRESULT SendMessage32A(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam) return 0; } - if (QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ)) + if (QUEUE_IsExitingQueue(wndPtr->hmemTaskQ)) return 0; /* Don't send anything if the task is dying */ if (wndPtr->hmemTaskQ != GetTaskQueue(0)) @@ -1168,7 +1168,7 @@ LRESULT SendMessage32W(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam) fprintf( stderr, "SendMessage32W: invalid hwnd %08x\n", hwnd ); return 0; } - if (QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ)) + if (QUEUE_IsExitingQueue(wndPtr->hmemTaskQ)) return 0; /* Don't send anything if the task is dying */ if (wndPtr->hmemTaskQ != GetTaskQueue(0)) { diff --git a/windows/nonclient.c b/windows/nonclient.c index e0c6412c02..08ff98ba9e 100644 --- a/windows/nonclient.c +++ b/windows/nonclient.c @@ -465,11 +465,11 @@ static void NC_DrawMaxButton( HWND32 hwnd, HDC16 hdc, BOOL32 down ) if( !(wndPtr->flags & WIN_MANAGED) ) { NC_GetInsideRect( hwnd, &rect ); - GRAPH_DrawBitmap( hdc, (IsZoomed32(hwnd) ? - (down ? hbitmapRestoreD : hbitmapRestore) : - (down ? hbitmapMaximizeD : hbitmapMaximize)), + GRAPH_DrawBitmap( hdc, (IsZoomed32(hwnd) + ? (down ? hbitmapRestoreD : hbitmapRestore) + : (down ? hbitmapMaximizeD : hbitmapMaximize)), rect.right - SYSMETRICS_CXSIZE - 1, rect.top, - 0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE ); + 0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE, FALSE ); } } @@ -488,7 +488,7 @@ static void NC_DrawMinButton( HWND32 hwnd, HDC16 hdc, BOOL32 down ) if (wndPtr->dwStyle & WS_MAXIMIZEBOX) rect.right -= SYSMETRICS_CXSIZE+1; GRAPH_DrawBitmap( hdc, (down ? hbitmapMinimizeD : hbitmapMinimize), rect.right - SYSMETRICS_CXSIZE - 1, rect.top, - 0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE ); + 0, 0, SYSMETRICS_CXSIZE+1, SYSMETRICS_CYSIZE, FALSE ); } } @@ -927,19 +927,18 @@ static void NC_TrackSysMenu( HWND32 hwnd, POINT16 pt ) * Initialisation of a move or resize, when initiatied from a menu choice. * Return hit test code for caption or sizing border. */ -static LONG NC_StartSizeMove( HWND32 hwnd, WPARAM16 wParam, +static LONG NC_StartSizeMove( WND* wndPtr, WPARAM16 wParam, POINT16 *capturePoint ) { LONG hittest = 0; POINT16 pt; MSG16 msg; - WND * wndPtr = WIN_FindWndPtr( hwnd ); if ((wParam & 0xfff0) == SC_MOVE) { /* Move pointer at the center of the caption */ RECT32 rect; - NC_GetInsideRect( hwnd, &rect ); + NC_GetInsideRect( wndPtr->hwndSelf, &rect ); if (wndPtr->dwStyle & WS_SYSMENU) rect.left += SYSMETRICS_CXSIZE + 1; if (wndPtr->dwStyle & WS_MINIMIZEBOX) @@ -948,20 +947,21 @@ static LONG NC_StartSizeMove( HWND32 hwnd, WPARAM16 wParam, rect.right -= SYSMETRICS_CXSIZE + 1; pt.x = wndPtr->rectWindow.left + (rect.right - rect.left) / 2; pt.y = wndPtr->rectWindow.top + rect.top + SYSMETRICS_CYSIZE/2; + hittest = HTCAPTION; + *capturePoint = pt; + if (wndPtr->dwStyle & WS_CHILD) ClientToScreen16( wndPtr->parent->hwndSelf, &pt ); - hittest = HTCAPTION; } else /* SC_SIZE */ { - SetCapture32(hwnd); while(!hittest) { MSG_InternalGetMessage( &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE ); switch(msg.message) { case WM_MOUSEMOVE: - hittest = NC_HandleNCHitTest( hwnd, msg.pt ); + hittest = NC_HandleNCHitTest( wndPtr->hwndSelf, msg.pt ); pt = msg.pt; if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT)) hittest = 0; @@ -998,10 +998,11 @@ static LONG NC_StartSizeMove( HWND32 hwnd, WPARAM16 wParam, } } } + *capturePoint = pt; } - *capturePoint = pt; - SetCursorPos32( capturePoint->x, capturePoint->y ); - NC_HandleSetCursor( hwnd, (WPARAM16)hwnd, MAKELONG( hittest, WM_MOUSEMOVE )); + SetCursorPos32( pt.x, pt.y ); + NC_HandleSetCursor( wndPtr->hwndSelf, + wndPtr->hwndSelf, MAKELONG( hittest, WM_MOUSEMOVE )); return hittest; } @@ -1030,17 +1031,18 @@ static void NC_DoSizeMove( HWND32 hwnd, WORD wParam, POINT16 pt ) if ((wParam & 0xfff0) == SC_MOVE) { if (!(wndPtr->dwStyle & WS_CAPTION)) return; - if (!hittest) hittest = NC_StartSizeMove( hwnd, wParam, &capturePoint ); + if (!hittest) + hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint ); if (!hittest) return; } else /* SC_SIZE */ { if (!thickframe) return; - if (hittest) hittest += HTLEFT-1; + if ( hittest && hittest != HTSYSMENU ) hittest += 2; else { SetCapture32(hwnd); - hittest = NC_StartSizeMove( hwnd, wParam, &capturePoint ); + hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint ); if (!hittest) { ReleaseCapture(); @@ -1055,7 +1057,8 @@ static void NC_DoSizeMove( HWND32 hwnd, WORD wParam, POINT16 pt ) sizingRect = wndPtr->rectWindow; if (wndPtr->dwStyle & WS_CHILD) GetClientRect16( wndPtr->parent->hwndSelf, &mouseRect ); - else SetRect16(&mouseRect, 0, 0, SYSMETRICS_CXSCREEN, SYSMETRICS_CYSCREEN); + else + SetRect16(&mouseRect, 0, 0, SYSMETRICS_CXSCREEN, SYSMETRICS_CYSCREEN); if (ON_LEFT_BORDER(hittest)) { mouseRect.left = MAX( mouseRect.left, sizingRect.right-maxTrack.x ); @@ -1361,7 +1364,8 @@ LONG NC_HandleNCLButtonDown( HWND32 hwnd, WPARAM16 wParam, LPARAM lParam ) case HTBOTTOM: case HTBOTTOMLEFT: case HTBOTTOMRIGHT: - SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - HTLEFT+1, lParam); + /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */ + SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam); break; case HTBORDER: @@ -1416,14 +1420,15 @@ LONG NC_HandleSysCommand( HWND32 hwnd, WPARAM16 wParam, POINT16 pt ) { WND *wndPtr = WIN_FindWndPtr( hwnd ); POINT32 pt32; + UINT16 uCommand = wParam & 0xFFF0; dprintf_nonclient(stddeb, "Handling WM_SYSCOMMAND %x %d,%d\n", wParam, pt.x, pt.y ); - if (wndPtr->dwStyle & WS_CHILD && wParam != SC_KEYMENU ) + if (wndPtr->dwStyle & WS_CHILD && uCommand != SC_KEYMENU ) ScreenToClient16( wndPtr->parent->hwndSelf, &pt ); - switch (wParam & 0xfff0) + switch (uCommand) { case SC_SIZE: case SC_MOVE: diff --git a/windows/queue.c b/windows/queue.c index a74945c0e5..9845c1a839 100644 --- a/windows/queue.c +++ b/windows/queue.c @@ -19,7 +19,7 @@ #define MAX_QUEUE_SIZE 120 /* Max. size of a message queue */ static HQUEUE16 hFirstQueue = 0; -static HQUEUE16 hDoomedQueue = 0; +static HQUEUE16 hExitingQueue = 0; static HQUEUE16 hmemSysMsgQueue = 0; static MESSAGEQUEUE *sysMsgQueue = NULL; @@ -94,20 +94,20 @@ void QUEUE_WalkQueues(void) /*********************************************************************** - * QUEUE_IsDoomedQueue + * QUEUE_IsExitingQueue */ -BOOL32 QUEUE_IsDoomedQueue( HQUEUE16 hQueue ) +BOOL32 QUEUE_IsExitingQueue( HQUEUE16 hQueue ) { - return (hDoomedQueue && (hQueue == hDoomedQueue)); + return (hExitingQueue && (hQueue == hExitingQueue)); } /*********************************************************************** - * QUEUE_SetDoomedQueue + * QUEUE_SetExitingQueue */ -void QUEUE_SetDoomedQueue( HQUEUE16 hQueue ) +void QUEUE_SetExitingQueue( HQUEUE16 hQueue ) { - hDoomedQueue = hQueue; + hExitingQueue = hQueue; } diff --git a/windows/user.c b/windows/user.c index b20670f951..231761a387 100644 --- a/windows/user.c +++ b/windows/user.c @@ -21,7 +21,7 @@ WORD USER_HeapSel = 0; -extern BOOL32 MENU_SwitchTPWndTo(HTASK16); +extern BOOL32 MENU_PatchResidentPopup( HQUEUE16, WND* ); extern void QUEUE_FlushMessages(HQUEUE16); /*********************************************************************** @@ -108,7 +108,7 @@ INT16 InitApp( HINSTANCE16 hInstance ) } /********************************************************************** - * USER_AppExit + * USER_AppExit */ void USER_AppExit( HTASK16 hTask, HINSTANCE16 hInstance, HQUEUE16 hQueue ) { @@ -123,16 +123,16 @@ void USER_AppExit( HTASK16 hTask, HINSTANCE16 hInstance, HQUEUE16 hQueue ) desktop->hmemTaskQ = GetTaskQueue(TASK_GetNextTask(hTask)); /* Patch resident popup menu window */ - MENU_SwitchTPWndTo(0); + MENU_PatchResidentPopup( hQueue, NULL ); TIMER_RemoveQueueTimers( hQueue ); QUEUE_FlushMessages( hQueue ); HOOK_FreeQueueHooks( hQueue ); - QUEUE_SetDoomedQueue( hQueue ); + QUEUE_SetExitingQueue( hQueue ); WIN_ResetQueueWindows( desktop->child, hQueue, (HQUEUE16)0); - QUEUE_SetDoomedQueue( 0 ); + QUEUE_SetExitingQueue( 0 ); /* Free the message queue */ diff --git a/windows/win.c b/windows/win.c index e5be6f436b..f093af1569 100644 --- a/windows/win.c +++ b/windows/win.c @@ -43,6 +43,7 @@ static HWND32 hwndSysModal = 0; static WORD wDragWidth = 4; static WORD wDragHeight= 3; +extern BOOL32 MENU_PatchResidentPopup( HQUEUE16, WND* ); extern HCURSOR16 CURSORICON_IconToCursor(HICON16, BOOL32); extern HWND32 CARET_GetHwnd(void); extern BOOL32 WINPOS_ActivateOtherWindow(WND* pWnd); @@ -569,8 +570,9 @@ static HWND32 WIN_CreateWindowEx( CREATESTRUCT32A *cs, ATOM classAtom, wndPtr->pVScroll = NULL; wndPtr->pHScroll = NULL; wndPtr->pProp = NULL; - wndPtr->hSysMenu = MENU_GetDefSysMenu(); wndPtr->userdata = 0; + wndPtr->hSysMenu = (wndPtr->dwStyle & WS_SYSMENU) + ? MENU_GetSysMenu( hwnd, 0 ) : 0; if (classPtr->cbWndExtra) memset( wndPtr->wExtra, 0, classPtr->cbWndExtra); @@ -1000,7 +1002,7 @@ BOOL32 DestroyWindow32( HWND32 hwnd ) /* FIXME: clean up palette - see "Internals" p.352 */ } - if( !QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ) ) + if( !QUEUE_IsExitingQueue(wndPtr->hmemTaskQ) ) WIN_SendParentNotify( hwnd, WM_DESTROY, wndPtr->wIDmenu, (LPARAM)hwnd ); if (!IsWindow32(hwnd)) return TRUE; @@ -1012,7 +1014,7 @@ BOOL32 DestroyWindow32( HWND32 hwnd ) { SetWindowPos32( hwnd, 0, 0, 0, 0, 0, SWP_HIDEWINDOW | SWP_NOACTIVATE|SWP_NOZORDER|SWP_NOMOVE|SWP_NOSIZE| - ((QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ))?SWP_DEFERERASE:0) ); + ((QUEUE_IsExitingQueue(wndPtr->hmemTaskQ))?SWP_DEFERERASE:0) ); if (!IsWindow32(hwnd)) return TRUE; } @@ -1020,6 +1022,9 @@ BOOL32 DestroyWindow32( HWND32 hwnd ) if( !(wndPtr->dwStyle & WS_CHILD) ) { + /* make sure top menu popup doesn't get destroyed */ + MENU_PatchResidentPopup( TRUE, wndPtr ); + for (;;) { WND *siblingPtr = wndPtr->parent->child; /* First sibling */ diff --git a/windows/winpos.c b/windows/winpos.c index d588de496f..9b90564d2c 100644 --- a/windows/winpos.c +++ b/windows/winpos.c @@ -1181,7 +1181,7 @@ BOOL32 WINPOS_ActivateOtherWindow(WND* pWnd) hwndPrevActive = 0; if( hwndActive != pWnd->hwndSelf && - ( hwndActive || QUEUE_IsDoomedQueue(pWnd->hmemTaskQ)) ) + ( hwndActive || QUEUE_IsExitingQueue(pWnd->hmemTaskQ)) ) return 0; if( pWnd->dwStyle & WS_POPUP &&