MRESULT EXPENTRY NewFrameProc( HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2 ) { PFNWP oldFrameProc ; /* ------- get original frame procedure --------- */ oldFrameProc = (PFNWP) WinQueryWindowULong( hwnd, QWL_USER ); switch (msg) { case WM_QUERYFRAMECTLCOUNT : { USHORT itemCount ; /* ---- get count of original frame controls --- */ itemCount = SHORT1FROMMR( oldFrameProc( hwnd, msg, mp1, mp2 )); /* ------- add 1 for new toolbar control ------ */ return ( (MRESULT) ++itemCount ); } case WM_FORMATFRAME : { PSWP pSWP ; PRECTL pFrameRect ; USHORT itemCount ; pFrameRect = PVOIDFROMMP( mp2 ); pSWP = PVOIDFROMMP( mp1 ); /* ---- run regular processing on original controls --- */ itemCount = SHORT1FROMMR( oldFrameProc( hwnd, msg, mp1, mp2 )); /* ---- get size values for 2nd menu bar -------- */ pSWP[ itemCount ].fl = SWP_SIZE; pSWP[ itemCount ].cy = pSWP[(itemCount-1)].cy ; /* set some */ pSWP[ itemCount ].cx = pSWP[(itemCount-1)].cx ; /* defaults */ pSWP[ itemCount ].hwndInsertBehind = HWND_TOP ; pSWP[ itemCount ].hwnd = hwndMenuBar ; WinSendMsg( hwndMenuBar, /* let the menu code make */ WM_ADJUSTWINDOWPOS, /* the actual size */ MPFROMP( pSWP+itemCount ), /* adjustments */ (MPARAM) 0L ); /* ------ position menu directly below other menu ------- */ pSWP[itemCount].x = pSWP[(itemCount-2)].x ; pSWP[itemCount].y = pSWP[(itemCount-2)].y - pSWP[itemCount].cy ; pSWP[itemCount].fl = pSWP[(itemCount-2)].fl ; /* -------- adjust client window size for 2nd menu ------- */ pSWP[(itemCount-1)].cy -= pSWP[itemCount].cy ; /* -------- return total count of frame controls ------- */ return( MRFROMSHORT( ++itemCount ) ); } break; default: return oldFrameProc(hwnd,msg,mp1,mp2); } /* end of switch () */ return( FALSE ); } /* end of NewFrameProc */
static MRESULT APIENTRY InitDlg ( HWND Window, ULONG msg, MPARAM mp1, MPARAM mp2 ) { /************************************************************************** * Get parameters from initialization message. * **************************************************************************/ PDATEFMT_PARMS Parms = PDATEFMT_PARMS ( PVOIDFROMMP ( mp2 ) ) ; Sys_SetWindowData ( Window, Parms ) ; /************************************************************************** * Fill the entry field. * **************************************************************************/ Sys_SendMessage ( CHILD(Window,IDD_DATEFMT_ENTRY), EM_SETTEXTLIMIT, MPFROMLONG(sizeof(Parms->Format)-1), 0 ) ; char Local [sizeof(Parms->Format)] ; LocalDateFormat ( Local, Parms->Format ) ; Sys_SetWindowText ( CHILD(Window,IDD_DATEFMT_ENTRY), Local ) ; /************************************************************************** * Return no error. * **************************************************************************/ return ( Dialog_Processor ( Window, msg, mp1, mp2 ) ) ; }
static MRESULT EXPENTRY ControllerValueSetSubclassWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { switch (msg) { case DM_DRAGOVER: { USHORT usIndicator; PDRAGITEM pditem; PDRAGINFO pdinfo = (PDRAGINFO) PVOIDFROMMP (mp1); pfnwpValueSet (hwnd, msg, mp1, mp2); assert (DrgAccessDraginfo(pdinfo)); pditem = DrgQueryDragitemPtr (pdinfo, 0); if (DrgVerifyRMF (pditem, 0, "DRF_AIRCRAFT")) { usIndicator = (pdinfo->usOperation == DO_DEFAULT || pdinfo->usOperation == DO_MOVE) ? DOR_DROP : DOR_NODROP; } else usIndicator = DOR_NEVERDROP; return MRFROM2SHORT(usIndicator, DO_MOVE); } } return pfnwpValueSet (hwnd, msg, mp1, mp2); }
/**************************************************************************** SysMenu Dialog Procedure *****************************************************************************/ MRESULT EXPENTRY SysMenuProc (HWND hWnd, ULONG msg, MPARAM mp1, MPARAM mp2) { BOOL Handled = TRUE; MRESULT mReturn = 0; RECTL Rectl; POINTL Pointl; ULONG temp; HPS hps; HBITMAP hbm; switch (msg) { case WM_PAINT: hps = WinBeginPaint(hWnd, 0, 0); WinQueryWindowRect(hWnd,&Rectl); WinFillRect(hps, &Rectl, CLR_BLACK); hbm = PointerInfo.hbmMiniColor; WinInflateRect(hab, &Rectl, -1L, -1L); WinDrawBitmap(hps, hbm, NULL, (PPOINTL)&Rectl, 0L, 0L, DBM_NORMAL); WinEndPaint(hps); break; case WM_ERASEBACKGROUND: WinFillRect((HPS)LONGFROMMP(mp1),PVOIDFROMMP(mp2),CLR_BLACK); mReturn = MRFROMLONG(1L); break; default: Handled = FALSE; break; } if (!Handled) mReturn = (*SysMenuDefProc)(hWnd, msg, mp1, mp2); return (mReturn); }
static MRESULT APIENTRY InitDlg ( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) { /*************************************************************************** * Get parameters from initialization message. * ***************************************************************************/ PPROFILE_PARMS Parms = (PPROFILE_PARMS) ( PVOIDFROMMP ( mp2 ) ) ; WinSetWindowPtr ( hwnd, QWL_USER, Parms ) ; /*************************************************************************** * Set the dialog help instance. * ***************************************************************************/ WinSetWindowUShort ( hwnd, QWS_ID, Parms->id ) ; if ( Parms->hwndHelp ) { WinAssociateHelpInstance ( Parms->hwndHelp, hwnd ) ; } /*************************************************************************** * Set the entry field contents. * ***************************************************************************/ WinSetDlgItemText ( hwnd, Parms->id+ENTRY, Parms->Path ) ; /*************************************************************************** * Return no error. * ***************************************************************************/ return ( MRFROMSHORT ( FALSE ) ) ; }
MRESULT EXPENTRY fnwpCOMeventStatesDlg(HWND hwnd,USHORT msg, MPARAM mp1,MPARAM mp2) { WORD *pwEvent; WORD wEvent; switch (msg) { case WM_INITDLG: // CenterDlgBox(hwnd); WinSetFocus(HWND_DESKTOP,hwnd); pwEvent = PVOIDFROMMP(mp2); if (*pwEvent & 0x0001) CheckButton(hwnd,CEV_BIT0,TRUE); if (*pwEvent & 0x0002) CheckButton(hwnd,CEV_BIT1,TRUE); if (*pwEvent & 0x0004) CheckButton(hwnd,CEV_BIT2,TRUE); if (*pwEvent & 0x0008) CheckButton(hwnd,CEV_BIT3,TRUE); if (*pwEvent & 0x0010) CheckButton(hwnd,CEV_BIT4,TRUE); if (*pwEvent & 0x0020) CheckButton(hwnd,CEV_BIT5,TRUE); if (*pwEvent & 0x0040) CheckButton(hwnd,CEV_BIT6,TRUE); if (*pwEvent & 0x0080) CheckButton(hwnd,CEV_BIT7,TRUE); if (*pwEvent & 0x0100) CheckButton(hwnd,CEV_BIT8,TRUE); break; // case WM_BUTTON1DOWN: // WinDismissDlg(hwnd,TRUE); // return(FALSE); case WM_COMMAND: switch(SHORT1FROMMP(mp1)) { case DID_HELP: DisplayHelpPanel(HLPP_COM_EVENT_BITS); return((MRESULT)FALSE); case DID_CLEAR: if (GetCOMevent(&stIOctl,hCom,&wEvent) != NO_ERROR) { WinPostMsg(hwndStatAll,UM_KILL_MONITOR,(MPARAM)0L,(MPARAM)0L); WinPostMsg(hwndStatDev,UM_KILL_MONITOR,(MPARAM)0L,(MPARAM)0L); } case DID_OK: case DID_CANCEL: break; default: return WinDefDlgProc(hwnd,msg,mp1,mp2); } WinDismissDlg(hwnd,TRUE); return((MRESULT)TRUE); default: return(WinDefDlgProc(hwnd,msg,mp1,mp2)); } return FALSE; }
// Top-level notebook dialog procedure -- for WM_INITDLG, expects mp2 to be a // pointer to a notebook header structure which defines the notebook MRESULT EXPENTRY NotebookDlgProc(HWND hDlg, ULONG msg, MPARAM mp1, MPARAM mp2) { int nPage; PNBHDR pNotebookHdr; if (msg != WM_INITDLG) pNotebookHdr = (PNBHDR)WinQueryWindowULong(hDlg, QWL_USER); switch(msg) { case WM_INITDLG: pNotebookHdr = (PNBHDR)(PVOIDFROMMP(mp2)); pNotebookHdr->hwndNB = WinWindowFromID(hDlg, pNotebookHdr->ulNotebookID); // Save upper-level dialog handle for use by page dialog code pNotebookHdr->hwndNBDlg = hDlg; // Save header pointer in window data so WM_SIZE code can use it WinSetWindowULong(hDlg, QWL_USER, (ULONG)pNotebookHdr); // Create the notebook if (!CreateNotebook(pNotebookHdr)) { WinDismissDlg(hDlg, 0); return 0; } // Post a message to open the notebook after initialization is complete WinPostMsg(hDlg, WM_OPEN_NOTEBOOK, MP0, MP0); break; case WM_OPEN_NOTEBOOK: // Select the first page, and set the notebook size TurnToFirstPage(pNotebookHdr->hwndNB); SetNotebookSize(pNotebookHdr); break; case WM_CONTROL: // If user selected a new page, switch to it if (((ULONG)pNotebookHdr != 0L) && (SHORT1FROMMP(mp1) == pNotebookHdr->ulNotebookID) && (SHORT2FROMMP(mp1) == BKN_PAGESELECTED)) SetNBPage(hDlg, (PPAGESELECTNOTIFY)mp2); break; case WM_CLOSE_NOTEBOOK: // clear the notebook page array dialog handles to show the pages are no longer in use for (nPage = 0; (nPage < pNotebookHdr->nPages); nPage++) pNotebookHdr->PageArray[nPage].hwndPageDlg = (HWND)0L; WinDismissDlg(hDlg, 0); break; default: return WinDefDlgProc(hDlg, msg, mp1, mp2); } return 0; }
MRESULT EXPENTRY OS2Factory::OS2FrameProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) { // Get pointer to thread info: should only work with the parent window intf_thread_t *p_intf = (intf_thread_t *)WinQueryWindowPtr( hwnd, 0 ); OS2Factory *pFactory = (OS2Factory*)OS2Factory::instance( p_intf ); if( msg == WM_ADJUSTWINDOWPOS ) { PSWP pswp = ( PSWP )PVOIDFROMMP( mp1 ); if( pswp->fl & ( SWP_MINIMIZE | SWP_RESTORE )) { // propagate to all the owned windows HENUM henum = WinBeginEnumWindows( HWND_DESKTOP ); HWND hwndNext; while(( hwndNext = WinGetNextWindow( henum )) != NULLHANDLE ) { if( WinQueryWindow( hwndNext, QW_OWNER ) == pFactory->m_hParentClientWindow ) WinSetWindowPos( hwndNext, 0, 0, 0, 0, 0, pswp->fl & ( SWP_MINIMIZE | SWP_RESTORE )); } } } else if( msg == WM_SYSCOMMAND ) { // If closing parent window if( SHORT1FROMMP(mp1) == SC_CLOSE ) { libvlc_Quit( p_intf->p_libvlc ); return 0; } else if( SHORT1FROMMP(mp1) == SC_MINIMIZE ) { pFactory->minimize(); return 0; } else if( SHORT1FROMMP(mp1) == SC_RESTORE ) { pFactory->restore(); return 0; } else { msg_Dbg( p_intf, "WM_SYSCOMMAND %i", (SHORT1FROMMP(mp1))); } } return pFactory->m_pfnwpOldFrameProc( hwnd, msg, mp1, mp2 ); }
/* ** dialog to set read/write timeouts */ MRESULT EXPENTRY fnwpHdwTimeoutDlg(HWND hwnd,USHORT msg,MPARAM mp1,MPARAM mp2) { static DCB stComDCB; static bAllowClick; static COMCTL *pstComCtl; switch (msg) { case WM_INITDLG: // CenterDlgBox(hwnd); // WinSetFocus(HWND_DESKTOP,hwnd); bAllowClick = FALSE; pstComCtl = PVOIDFROMMP(mp2); if (GetDCB(pstComCtl->pstIOctl,pstComCtl->hCom,&stComDCB)) { WinDismissDlg(hwnd,FALSE); return(FALSE); } if (pstComCtl->pszPortName != NULL) WinSetWindowText(hwnd,pstComCtl->pszPortName); WinPostMsg(hwnd,UM_INITLS,(MPARAM)0L,(MPARAM)0L); break; case UM_INITLS: FillHdwTimeoutDlg(hwnd,&stComDCB); bAllowClick = TRUE; break; case WM_CONTROL: if (SHORT2FROMMP(mp1) == BN_CLICKED) if (bAllowClick) if (!TCHdwTimeoutDlg(hwnd,SHORT1FROMMP(mp1))) return(FALSE); break; case WM_COMMAND: switch(SHORT1FROMMP(mp1)) { case DID_OK: UnloadHdwTimeoutDlg(hwnd,&stComDCB); SendDCB(pstComCtl->pstIOctl,pstComCtl->hCom,&stComDCB); WinDismissDlg(hwnd,TRUE); break; case DID_CANCEL: WinDismissDlg(hwnd,FALSE); break; case DID_HELP: DisplayHelpPanel(pstComCtl); break; default: return WinDefDlgProc(hwnd,msg,mp1,mp2); } break; default: return(WinDefDlgProc(hwnd,msg,mp1,mp2)); } return FALSE; }
/* * FUNCTION: DragWndProc * * DESCRIPTION: * * Window procedure for drag window * */ MRESULT EXPENTRY DragWndProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) { PDRAGSTRUCT pDragData; PDRAGTRANSFER pDragTrans; ULONG cbLength; PSZ pBuffer; PSZ pBufferEnd; M_SrcTransient *somSelfClass; switch (msg) { case WM_CREATE: // Set the window pointer to our data structure WinSetWindowPtr(hwnd, QWL_USER, (PVOID)mp1); break; case DM_RENDER: // Retrieve the window pointer pDragData = (PDRAGSTRUCT) WinQueryWindowPtr(hwnd, QWL_USER); if (pDragData == NULL) { break; } // Get the DRAGTRANSFER structure pDragTrans = (PDRAGTRANSFER) PVOIDFROMMP(mp1); // Extract the target foldername and perform a copy // ****************************************************** // The following few lines seem to be a bit dodgy. If you are // reading this (and you are!!), and you know a better way of // getting object pointers to class objects etc., please send // me some info on CIS - 100241,1425. I do a lot of that stuff // and would appreciate it if anyone could tell me how to do // it "cleaner" cbLength = DrgQueryStrName(pDragTrans->hstrRenderToName, cbLength, pBuffer); pBuffer = new char[cbLength+1]; cbLength = DrgQueryStrName(pDragTrans->hstrRenderToName, cbLength, pBuffer); pBuffer[cbLength] = '\0'; pBufferEnd = strrchr(pBuffer, '\\'); pBufferEnd[0] = '\0'; somSelfClass = (M_SrcTransient *)pDragData->somSelf->somGetClass(); pDragData->somSelf->wpCopyObject( somSelfClass->wpclsQueryFolder(pBuffer, FALSE), FALSE); delete pBuffer; break; } /* end switch(msg) */ return (WinDefWindowProc(hwnd, msg, mp1, mp2) ); }
MRESULT EXPENTRY fnwpCOMstatusStatesDlg(HWND hwnd,USHORT msg, MPARAM mp1,MPARAM mp2) { WORD *pwEvent; switch (msg) { case WM_INITDLG: // CenterDlgBox(hwnd); WinSetFocus(HWND_DESKTOP,hwnd); pwEvent = PVOIDFROMMP(mp2); if (*pwEvent & 0x0001) CheckButton(hwnd,CST_BIT0,TRUE); if (*pwEvent & 0x0002) CheckButton(hwnd,CST_BIT1,TRUE); if (*pwEvent & 0x0004) CheckButton(hwnd,CST_BIT2,TRUE); if (*pwEvent & 0x0008) CheckButton(hwnd,CST_BIT3,TRUE); if (*pwEvent & 0x0010) CheckButton(hwnd,CST_BIT4,TRUE); if (*pwEvent & 0x0020) CheckButton(hwnd,CST_BIT5,TRUE); if (*pwEvent & 0x0040) CheckButton(hwnd,CST_BIT6,TRUE); if (*pwEvent & 0x0080) CheckButton(hwnd,CST_BIT7,TRUE); break; // case WM_BUTTON1DOWN: // WinDismissDlg(hwnd,TRUE); // return(FALSE); case WM_COMMAND: switch(SHORT1FROMMP(mp1)) { case DID_HELP: DisplayHelpPanel(HLPP_COM_STATUS_BITS); return((MRESULT)FALSE); case DID_OK: case DID_CANCEL: break; default: return WinDefDlgProc(hwnd,msg,mp1,mp2); } WinDismissDlg(hwnd,TRUE); return((MRESULT)TRUE); default: return(WinDefDlgProc(hwnd,msg,mp1,mp2)); } return FALSE; }
static MRESULT APIENTRY SetRuler ( HWND Window, MESG, MPARAM1 mp1, MPARAM2 ) { /************************************************************************** * Find the instance data. * **************************************************************************/ PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ; /************************************************************************** * If ruler parameters have changed, save them and invalidate the window. * **************************************************************************/ PHORZRULER_SETPARMS Parms = PHORZRULER_SETPARMS ( PVOIDFROMMP ( mp1 ) ) ; if ( ( Data->Metric != Parms->Metric ) OR ( Data->fxZoom != Parms->fxZoom ) OR ( Data->TopLeft != Parms->TopLeft ) OR ( Data->PageWidth != Parms->PageWidth ) OR ( Data->LeftMargin != Parms->LeftMargin ) OR ( Data->RightMargin != Parms->RightMargin ) OR ( Data->TabCount != Parms->TabCount ) OR memcmp ( Data->Tabs, Parms->Tabs, sizeof(Data->Tabs) ) ) { #ifdef DEBUG Log ( "HRuler::SetRuler: Setting Margins to %i, %i.", Parms->LeftMargin, Parms->RightMargin ) ; #endif Data->Metric = Parms->Metric ; Data->fxZoom = Parms->fxZoom ; Data->TopLeft = Parms->TopLeft ; Data->PageWidth = Parms->PageWidth ; Data->LeftMargin = Parms->LeftMargin ; Data->RightMargin = Parms->RightMargin ; Data->TabCount = Parms->TabCount ; memcpy ( Data->Tabs, Parms->Tabs, sizeof(Data->Tabs) ) ; Sys_InvalidateWindow ( Window ) ; } /* endif */ /********************************h***************************************** * We're done. * **************************************************************************/ return ( MRFROMSHORT ( 0 ) ) ; }
MRESULT drawSlider(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2, USHORT id) { POWNERITEM poi; RECTL rcl; POINTL ptl= {0}; poi=(POWNERITEM)PVOIDFROMMP(mp2); switch(poi->idItem) { case SDA_SLIDERARM: WinFillRect(poi->hps,&poi->rclItem, CLR_RED); WinDrawBorder(poi->hps,&poi->rclItem, 2, 2, 0, 0 ,0x0400); return (MRESULT) TRUE; break; case SDA_BACKGROUND: { HPS hps; WinFillRect(poi->hps,&poi->rclItem, CLR_WHITE); return (MRESULT) TRUE; } case SDA_SLIDERSHAFT: { HPS hps; RECTL rcl; MRESULT mr; WinFillRect(poi->hps,&poi->rclItem, CLR_BLUE); return (MRESULT)TRUE; } default: return (MRESULT)TRUE; } /* Done */ return (MRESULT)TRUE; }
MRESULT EXPENTRY GenDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { static PPREF_GEN pgen; switch (msg) { case WM_INITDLG: pgen = (PPREF_GEN)PVOIDFROMMP(mp2); InitGeneralPage(hwnd, pgen); break; case WM_CONTROL: if (SHORT1FROMMP(mp1) == CBOX_DEF_LEN && SHORT2FROMMP(mp1) == BN_CLICKED) WinEnableControl(hwnd, SPIN_SUBJ_LEN, !WinQueryButtonCheckstate(hwnd, CBOX_DEF_LEN)); break; case WM_COMMAND: switch (LOUSHORT(mp1)) { case BTN_FONT: { char achFont[FACESIZE]; // buffer usato per i dati del nuovo font if (ShowFontDlg(hwnd, achFont)) WinSetDlgItemText(hwnd, TXT_FONT, achFont); } break; case BTTN_UNDO: InitGeneralPage(hwnd, pgen); break; case BTTN_DEFAULT: SetGeneralDefault(hwnd, pgen); break; default: break; } /* endswitch */ break; default: return WinDefDlgProc(hwnd, msg, mp1, mp2); break; } /* endswitch */ return (MRESULT) FALSE; }
MRESULT EXPENTRY SelDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { static PPREF_SEL psel; switch (msg) { case WM_INITDLG: psel = (PPREF_SEL)PVOIDFROMMP(mp2); InitSelectionPage(hwnd, psel); break; case WM_CONTROL: if (SHORT1FROMMP(mp1) == CBOX_EXT_SEL && SHORT2FROMMP(mp1) == BN_CLICKED) { WinEnableControl(hwnd, CBOX_SEL_ALL_INDIR, WinQueryButtonCheckstate(hwnd, CBOX_EXT_SEL)); } else if (SHORT1FROMMP(mp1) == CBOX_FILE_WIN && SHORT2FROMMP(mp1) == BN_CLICKED) { WinEnableControl(hwnd, CBOX_ONLY_DIR, WinQueryButtonCheckstate(hwnd, CBOX_FILE_WIN)); } /* endif */ break; case WM_COMMAND: switch (LOUSHORT(mp1)) { case BTTN_UNDO: InitSelectionPage(hwnd, psel); break; case BTTN_DEFAULT: SetSelectionDefault(hwnd); break; default: break; } /* endswitch */ break; default: return WinDefDlgProc(hwnd, msg, mp1, mp2); break; } /* endswitch */ return (MRESULT) FALSE; }
static MRESULT APIENTRY InitDlg ( HWND Window, MESG msg, MPARAM1 mp1, MPARAM2 mp2 ) { /************************************************************************** * Get parameters from initialization message. * **************************************************************************/ PTABS_PARMS Parms = PTABS_PARMS ( PVOIDFROMMP ( mp2 ) ) ; Sys_SetWindowData ( Window, Parms ) ; /************************************************************************** * Set the current measurement units. * **************************************************************************/ ResourceString English ( Parms->Library, IDS_UNITS_ENGLISH ) ; ResourceString Metric ( Parms->Library, IDS_UNITS_METRIC ) ; Sys_SetWindowText ( CHILD(Window,IDD_TABS_UNITS), Parms->Metric ? PSZ(Metric) : PSZ(English) ) ; /************************************************************************** * Set the page size. * **************************************************************************/ ResourceString Margins ( Parms->Library, IDS_TABS_MARGINS ) ; char String1 [20] ; FormatDecimal ( String1, Parms->LeftMargin, 1000, 3 ) ; char String2 [20] ; FormatDecimal ( String2, Parms->RightMargin, 1000, 3 ) ; char Text [100] ; sprintf ( Text, PCHAR(Margins), String1, String2 ) ; Sys_SetWindowText ( CHILD(Window,IDD_TABS_SIZE), Text ) ; /************************************************************************** * Return no error. * **************************************************************************/ return ( Dialog_Processor ( Window, msg, mp1, mp2 ) ) ; }
//Called before the default wnd procedure if you wish to provide additional // functionality. (i.e. modify what happens with mouse clicks, drag/drop, etc... BOOL CBZPluginWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2, PVOID pData, PFNWP pfnOrigWndProc, MRESULT *rc) { USHORT mId; PLUGINSHARE *pPluginData = (PLUGINSHARE *)pData; switch (msg) { case WM_PAINT: { PLUGINSHARE *pCBZData = (PLUGINSHARE *)pData; BOOL bActive = FALSE; PSPAINT psP; mId = WinQueryWindowUShort(hwnd, QWS_ID); //paint the MinMax menu! if (mId == FID_MINMAX) { HPS hps; RECTL rcl; hps = WinBeginPaint(hwnd, NULLHANDLE,&rcl); if(WinSendMsg(hwnd,MM_QUERYITEMRECT,MPFROM2SHORT(SC_CLOSE,FALSE),&rcl)) { if(pPluginData->hbmActiveClose==NULLHANDLE) if (!CreateImages(pPluginData)) return FALSE; // rcl.yBottom-=1; memset(&psP,0,sizeof(psP)); psP.hwnd=hwnd; psP.hps=hps; psP.hpsWin=hps; psP.rectlWindow=rcl; psP.rectlUpdate=rcl; DrawImage(&psP, pPluginData->hbmActiveClose, 0, pPluginData); } if(WinSendMsg(hwnd,MM_QUERYITEMRECT,MPFROM2SHORT(SC_MINIMIZE,FALSE),&rcl)) { //draw MinimizeButton if(pPluginData->hbmActiveMinimize==NULLHANDLE) if (!CreateImages(pPluginData)) return FALSE; memset(&psP,0,sizeof(psP)); psP.hwnd=hwnd; psP.hps=hps; psP.hpsWin=hps; psP.rectlWindow=rcl; psP.rectlUpdate=rcl; DrawImage(&psP, pPluginData->hbmActiveMinimize, 0, pPluginData); } if(WinSendMsg(hwnd,MM_QUERYITEMRECT,MPFROM2SHORT(SC_MAXIMIZE,FALSE),&rcl)) { //draw MaximizeButton if(pPluginData->hbmActiveMaximize==NULLHANDLE) if (!CreateImages(pPluginData)) return FALSE; // rcl.yBottom-=1; memset(&psP,0,sizeof(psP)); psP.hwnd=hwnd; psP.hps=hps; psP.hpsWin=hps; psP.rectlWindow=rcl; psP.rectlUpdate=rcl; DrawImage(&psP, pPluginData->hbmActiveMaximize, 0, pPluginData); } if(WinSendMsg(hwnd,MM_QUERYITEMRECT,MPFROM2SHORT(SC_RESTORE,FALSE),&rcl)) { //draw RestoreButton if(pPluginData->hbmActiveRestore==NULLHANDLE) if (!CreateImages(pPluginData)) return FALSE; // rcl.yBottom-=1; memset(&psP,0,sizeof(psP)); psP.hwnd=hwnd; psP.hps=hps; psP.hpsWin=hps; psP.rectlWindow=rcl; psP.rectlUpdate=rcl; DrawImage(&psP, pPluginData->hbmActiveRestore, 0, pPluginData); } if(WinSendMsg(hwnd,MM_QUERYITEMRECT,MPFROM2SHORT(SC_HIDE,FALSE),&rcl)) { //draw HideButton if(pPluginData->hbmActiveHide==NULLHANDLE) if (!CreateImages(pPluginData)) return FALSE; // rcl.yBottom-=1; memset(&psP,0,sizeof(psP)); psP.hwnd=hwnd; psP.hps=hps; psP.hpsWin=hps; psP.rectlWindow=rcl; psP.rectlUpdate=rcl; DrawImage(&psP, pPluginData->hbmActiveHide, 0, pPluginData); } WinEndPaint(hps); return TRUE; } } return FALSE; case MM_INSERTITEM: { PMENUITEM pmi; MENUITEM mi; pmi=(PMENUITEM) PVOIDFROMMP(mp1); *rc = pfnOrigWndProc(hwnd, msg, mp1, mp2); if (pmi->id == SC_RESTORE) { if (pPluginData->hbmActiveRestore != NULLHANDLE) { pmi->afStyle|=MIS_OWNERDRAW; WinSendMsg(hwnd,MM_SETITEM,MPFROM2SHORT(0,FALSE),pmi); } } else if (pmi->id == SC_MAXIMIZE) { if (pPluginData->hbmActiveMaximize != NULLHANDLE) { pmi->afStyle|=MIS_OWNERDRAW; WinSendMsg(hwnd,MM_SETITEM,MPFROM2SHORT(0,FALSE),pmi); } } else if (pmi->id == SC_HIDE) { if (pPluginData->hbmActiveHide != NULLHANDLE) { pmi->afStyle|=MIS_OWNERDRAW; WinSendMsg(hwnd,MM_SETITEM,MPFROM2SHORT(0,FALSE),pmi); } } else if (pmi->id == SC_MINIMIZE) { if (pPluginData->hbmActiveMinimize != NULLHANDLE) { pmi->afStyle|=MIS_OWNERDRAW; WinSendMsg(hwnd,MM_SETITEM,MPFROM2SHORT(0,FALSE),pmi); } } else if (pmi->id == SC_CLOSE) { if (pPluginData->hbmActiveClose != NULLHANDLE) { pmi->afStyle|=MIS_OWNERDRAW; WinSendMsg(hwnd,MM_SETITEM,MPFROM2SHORT(0,FALSE),pmi); } } return TRUE; } break; default: break; } return FALSE; //false indicates that we haven't processed the message! }
MRESULT EXPENTRY DetailsDllWndProc (HWND hDlg, USHORT Msg, MPARAM mp1, MPARAM mp2) { static PSHORT pDetailEntry; CHAR TitleStr[41]; switch (Msg) { case WM_INITDLG: pDetailEntry = PVOIDFROMMP (mp2); strcpy (TitleStr, "Details "); strcat (TitleStr, pShowTableData[*pDetailEntry].Name); WinSetWindowText (hDlg, TitleStr); /*--- get current libpath --*/ if (!GetLibPath (Libpath, MAX_LIBPATH_SIZE, ErrorStr)) { WinMessageBox (HWND_DESKTOP, hWndFrame, ErrorStr, ApplTitle, 0, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL); WinDismissDlg (hDlg, FALSE); break; } /*--- fill exported procedures ---*/ if (!_FillExportedProcedures (hDlg, *pDetailEntry, ErrorStr)) { WinMessageBox (HWND_DESKTOP, hWndFrame, ErrorStr, ApplTitle, 0, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL); WinDismissDlg (hDlg, FALSE); break; } /*--- fill imported modules ---*/ if (!_FillImportedModules (hDlg, *pDetailEntry, ErrorStr)) { WinMessageBox (HWND_DESKTOP, hWndFrame, ErrorStr, ApplTitle, 0, MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL); WinDismissDlg (hDlg, FALSE); break; } CenterDialog (HWND_DESKTOP, hDlg); WinSetFocus (HWND_DESKTOP, WinWindowFromID (hDlg, LID_DETAILS_DLL_EXP_RES)); return ((MRESULT) TRUE); case WM_COMMAND: switch (SHORT1FROMMP(mp1)) { case DID_CANCEL: WinDismissDlg (hDlg, FALSE); break; } break; default: return WinDefDlgProc (hDlg, Msg, mp1, mp2); } return NULL; }
// --------------------------------------------------------------------------- // Main Frame window proc // --------------------------------------------------------------------------- MRESULT EXPENTRY wxFrameMainWndProc( HWND hWnd, ULONG ulMsg, MPARAM wParam, MPARAM lParam ) { MRESULT rc = (MRESULT)0; bool bProcessed = false; wxFrame* pWnd = NULL; pWnd = (wxFrame*) wxFindWinFromHandle((WXHWND) hWnd); switch (ulMsg) { case WM_QUERYFRAMECTLCOUNT: if(pWnd && pWnd->m_fnOldWndProc) { USHORT uItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam)); rc = MRFROMSHORT(uItemCount); } break; case WM_FORMATFRAME: ///////////////////////////////////////////////////////////////////////////////// // Applications that subclass frame controls may find that the frame is already // subclassed the number of frame controls is variable. // The WM_FORMATFRAME and WM_QUERYFRAMECTLCOUNT messages must always be // subclassed by calling the previous window procedure and modifying its result. //////////////////////////////////////////////////////////////////////////////// { int nItemCount; int i; PSWP pSWP = NULL; RECTL vRectl; RECTL vRstb; RECTL vRtlb; int nHeight = 0; int nHeight2 = 0; int nWidth = 0; pSWP = (PSWP)PVOIDFROMMP(wParam); nItemCount = SHORT1FROMMR(pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam)); if(pWnd->m_frameStatusBar) { ::WinQueryWindowRect(pWnd->m_frameStatusBar->GetHWND(), &vRstb); pWnd->m_frameStatusBar->GetSize(NULL, &nHeight); } if(pWnd->m_frameToolBar) { ::WinQueryWindowRect(pWnd->m_frameToolBar->GetHWND(), &vRtlb); pWnd->m_frameToolBar->GetSize(&nWidth, &nHeight2); } ::WinQueryWindowRect(pWnd->m_hFrame, &vRectl); ::WinMapWindowPoints(pWnd->m_hFrame, HWND_DESKTOP, (PPOINTL)&vRectl, 2); ::WinCalcFrameRect(pWnd->m_hFrame, &vRectl, TRUE); ::WinMapWindowPoints(HWND_DESKTOP, pWnd->m_hFrame, (PPOINTL)&vRectl, 2); for(i = 0; i < nItemCount; i++) { if(pWnd->m_hWnd && pSWP[i].hwnd == pWnd->m_hWnd) { if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_TOP) { pSWP[i].x = vRectl.xLeft; pSWP[i].y = vRectl.yBottom + nHeight; pSWP[i].cx = vRectl.xRight - vRectl.xLeft; pSWP[i].cy = vRectl.yTop - vRectl.yBottom - (nHeight + nHeight2); } else if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_BOTTOM) { pSWP[i].x = vRectl.xLeft; pSWP[i].y = vRectl.yBottom + nHeight + nHeight2; pSWP[i].cx = vRectl.xRight - vRectl.xLeft; pSWP[i].cy = vRectl.yTop - vRectl.yBottom - (nHeight + nHeight2); } else if (pWnd->m_frameToolBar && pWnd->m_frameToolBar->GetWindowStyleFlag() & wxTB_LEFT) { pSWP[i].x = vRectl.xLeft + nWidth; pSWP[i].y = vRectl.yBottom + nHeight; pSWP[i].cx = vRectl.xRight - (vRectl.xLeft + nWidth); pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight; } else { pSWP[i].x = vRectl.xLeft; pSWP[i].y = vRectl.yBottom + nHeight; pSWP[i].cx = vRectl.xRight - (vRectl.xLeft + nWidth); pSWP[i].cy = vRectl.yTop - vRectl.yBottom - nHeight; } pSWP[i].fl = SWP_SIZE | SWP_MOVE | SWP_SHOW; pSWP[i].hwndInsertBehind = HWND_TOP; } } bProcessed = true; rc = MRFROMSHORT(nItemCount); } break; default: if(pWnd && pWnd->m_fnOldWndProc) rc = pWnd->m_fnOldWndProc(hWnd, ulMsg, wParam, lParam); else rc = ::WinDefWindowProc(hWnd, ulMsg, wParam, lParam); } return rc; } // end of wxFrameMainWndProc
MRESULT EXPENTRY ToolBarProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { if (msg == WM_CREATE) { WinSetWindowPtr(hwnd, QWL_USER, PVOIDFROMMP(mp1)); } else { ToolBarData *td = (ToolBarData *)WinQueryWindowPtr(hwnd, QWL_USER); ToolBarItem *items = td->pItems; switch (msg) { case WM_DESTROY: free(td); free(items); break; case WM_PAINT: { HPS hps; RECTL rcl; POINTL ptl; SWP swp; int xpos, ypos, item; WinQueryWindowPos(hwnd, &swp); hps = WinBeginPaint(hwnd, 0, &rcl); /* top outside 3D border */ if (rcl.yBottom < 1) { GpiSetColor(hps, CLR_DARKGRAY); ptl.x = rcl.xLeft; ptl.y = 0; GpiMove(hps, &ptl); ptl.x = Min(rcl.xRight, swp.cx - 2); GpiLine(hps, &ptl); } /* bottom outside 3D border */ if (rcl.yTop >= swp.cy - 1 - 1) { GpiSetColor(hps, CLR_WHITE); ptl.x = Max(rcl.xLeft, 1); ptl.y = swp.cy - 1; GpiMove(hps, &ptl); ptl.x = rcl.xRight; GpiLine(hps, &ptl); } /* 3D corners */ GpiSetColor(hps, CLR_PALEGRAY); ptl.x = 0; ptl.y = 0; GpiSetPel(hps, &ptl); ptl.x = swp.cx - 1; ptl.y = swp.cy - 1; GpiSetPel(hps, &ptl); /* bottom space */ if (rcl.yBottom < TYBORDER - 1) { for (ptl.y = 1; ptl.y < TYBORDER - 2; ptl.y++) { ptl.x = Max(rcl.xLeft, 1); GpiMove(hps, &ptl); ptl.x = Min(rcl.xRight, swp.cx - 1); GpiLine(hps, &ptl); } } /* top space */ if (rcl.yTop >= swp.cy - TYBORDER + 2) { for (ptl.y = swp.cy - TYBORDER + 2; ptl.y < swp.cy - 1; ptl.y++) { ptl.x = Max(rcl.xLeft, 1); GpiMove(hps, &ptl); ptl.x = Min(rcl.xRight, swp.cx - 1); GpiLine(hps, &ptl); } } /* left outside 3D border */ if (rcl.xLeft < 1) { GpiSetColor(hps, CLR_WHITE); ptl.y = Max(1, rcl.yBottom); ptl.x = 0; GpiMove(hps, &ptl); ptl.y = rcl.yTop; GpiLine(hps, &ptl); } /* right outside 3D border */ if (rcl.xRight >= swp.cx - 1) { GpiSetColor(hps, CLR_DARKGRAY); ptl.y = rcl.yBottom; ptl.x = swp.cx - 1; GpiMove(hps, &ptl); ptl.y = Min(swp.cy - 2, rcl.yTop); GpiLine(hps, &ptl); } /* left border */ if (rcl.xLeft < TXBORDER - 2) { GpiSetColor(hps, CLR_PALEGRAY); for (ptl.x = 1; ptl.x < TXBORDER - 2; ptl.x++) { ptl.y = Max(1, rcl.yBottom); GpiMove(hps, &ptl); ptl.y = Min(swp.cy - 2, rcl.yTop); GpiLine(hps, &ptl); } } /* draw toolbar items */ xpos = TXBORDER; ypos = TYBORDER; for (item = 0; item < td->ulCount; item++) { if (items[item].ulType == tiBITMAP) { if (rcl.xRight >= xpos - 2 && rcl.xLeft <= xpos + TXICON + 1) { GpiSetColor(hps, CLR_BLACK); ptl.x = xpos - 2; ptl.y = ypos - 2; GpiMove(hps, &ptl); ptl.x = xpos + TXICON + 1; ptl.y = ypos + TYICON + 1; GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0); if (item == td->ulDepressed && (items[item].ulFlags & tfDEPRESSED)) { ptl.x = xpos + 1; ptl.y = ypos - 1; WinDrawBitmap(hps, items[item].hBitmap, 0, &ptl, 0, 0, (items[item].ulFlags & tfDISABLED) ? DBM_INVERT: DBM_NORMAL); GpiSetColor(hps, CLR_DARKGRAY); ptl.x = xpos - 1; ptl.y = ypos - 1; GpiMove(hps, &ptl); ptl.y = ypos + TYICON; GpiLine(hps, &ptl); ptl.x = xpos + TXICON; GpiLine(hps, &ptl); ptl.y--; GpiMove(hps, &ptl); ptl.x = xpos; GpiLine(hps, &ptl); ptl.y = ypos - 1; GpiLine(hps, &ptl); } else { ptl.x = xpos; ptl.y = ypos; WinDrawBitmap(hps, items[item].hBitmap, 0, &ptl, 0, 0, (items[item].ulFlags & tfDISABLED) ? DBM_INVERT: DBM_NORMAL); GpiSetColor(hps, CLR_PALEGRAY); ptl.x = xpos - 1; ptl.y = ypos - 1; GpiSetPel(hps, &ptl); GpiSetColor(hps, CLR_WHITE); ptl.y++; GpiMove(hps, &ptl); ptl.y = ypos + TYICON; GpiLine(hps, &ptl); ptl.x = xpos + TXICON - 1; GpiLine(hps, &ptl); GpiSetColor(hps, CLR_PALEGRAY); ptl.x++; GpiSetPel(hps, &ptl); ptl.y--; GpiSetColor(hps, CLR_DARKGRAY); GpiMove(hps, &ptl); ptl.y = ypos - 1; GpiLine(hps, &ptl); ptl.x = xpos; GpiLine(hps, &ptl); } } xpos += TXICON + 3; } else if (items[item].ulType == tiSEPARATOR) { if (rcl.xRight >= xpos - 1 && rcl.xLeft <= xpos + TXSEPARATOR + 1) { GpiSetColor(hps, CLR_PALEGRAY); ptl.x = xpos - 1; ptl.y = ypos - 2; GpiMove(hps, &ptl); ptl.x = xpos + TXSEPARATOR + 1; ptl.y = ypos + TYICON + 1; GpiBox(hps, DRO_FILL, &ptl, 0, 0); } xpos += TXSEPARATOR + 3; } } GpiSetColor(hps, CLR_PALEGRAY); ptl.x = xpos - 1; ptl.y = ypos - 2; GpiMove(hps, &ptl); ptl.x = swp.cx - 2; ptl.y = swp.cy - TYBORDER + 1; GpiBox(hps, DRO_FILL, &ptl, 0, 0); WinEndPaint(hps); } break; case WM_ADJUSTWINDOWPOS: { PSWP pswp = (PSWP)PVOIDFROMMP(mp1); pswp->cy = TYBORDER + TYICON + TYBORDER; } break; case WM_BUTTON1DOWN: case WM_BUTTON1DBLCLK: { int item; POINTL ptl; RECTL rcl; ptl.x = (LONG) SHORT1FROMMP(mp1); ptl.y = (LONG) SHORT2FROMMP(mp1); rcl.yBottom = TYBORDER - 1; rcl.yTop = TYBORDER + TYICON + 1; rcl.xLeft = TXBORDER - 1; rcl.xRight = TXBORDER + TXICON + 1; for (item = 0; item < td->ulCount; item++) { if (rcl.xLeft <= ptl.x && rcl.yBottom <= ptl.y && rcl.xRight >= ptl.x && rcl.yTop >= ptl.y && td->pItems[item].ulType == tiBITMAP && (td->pItems[item].ulFlags & tfDISABLED) == 0) { td->ulDepressed = item; td->pItems[item].ulFlags |= tfDEPRESSED; WinInvalidateRect(hwnd, &rcl, FALSE); WinSetCapture(HWND_DESKTOP, hwnd); break; } if (td->pItems[item].ulType == tiBITMAP) { rcl.xLeft += TXICON + 3; rcl.xRight += TXICON + 3; } else if (td->pItems[item].ulType == tiSEPARATOR) { rcl.xLeft += TXSEPARATOR + 3; rcl.xRight += TXSEPARATOR + 3; } } } break; case WM_MOUSEMOVE: { STARTFUNC("ToolBarProc[WM_MOUSEMOVE]"); int item; POINTL ptl; RECTL rcl; if (td->ulDepressed == -1) break; ptl.x = (LONG) SHORT1FROMMP(mp1); ptl.y = (LONG) SHORT2FROMMP(mp1); rcl.yBottom = TYBORDER - 1; rcl.yTop = TYBORDER + TYICON + 1; rcl.xLeft = TXBORDER - 1; rcl.xRight = TXBORDER + TXICON + 1; LOG << "Depressed: " << td-> ulDepressed << ENDLINE; for (item = 0; item < td->ulCount; item++) { LOG << "Checking item " << item << ENDLINE; LOG << " pItem -> " << (void*)(td->pItems + item) << ENDLINE; if (item == td->ulDepressed) { if (rcl.xLeft <= ptl.x && rcl.yBottom <= ptl.y && rcl.xRight >= ptl.x && rcl.yTop >= ptl.y) { if ((td->pItems[item].ulFlags & tfDEPRESSED) == 0) { td->pItems[item].ulFlags |= tfDEPRESSED; WinInvalidateRect(hwnd, &rcl, FALSE); } } else { if (td->pItems[item].ulFlags & tfDEPRESSED) { td->pItems[item].ulFlags &= ~tfDEPRESSED; WinInvalidateRect(hwnd, &rcl, FALSE); } } break; } if (td->pItems[item].ulType == tiBITMAP) { rcl.xLeft += TXICON + 3; rcl.xRight += TXICON + 3; } else if (td->pItems[item].ulType == tiSEPARATOR) { rcl.xLeft += TXSEPARATOR + 3; rcl.xRight += TXSEPARATOR + 3; } } } break; case WM_BUTTON1UP: { int item; POINTL ptl; RECTL rcl; if (td->ulDepressed == -1) break; ptl.x = (LONG) SHORT1FROMMP(mp1); ptl.y = (LONG) SHORT2FROMMP(mp1); rcl.yBottom = TYBORDER - 1; rcl.yTop = TYBORDER + TYICON + 1; rcl.xLeft = TXBORDER - 1; rcl.xRight = TXBORDER + TXICON + 1; for (item = 0; item < td->ulCount; item++) { if (item == td->ulDepressed) { WinSetCapture(HWND_DESKTOP, (HWND)0); if (rcl.xLeft <= ptl.x && rcl.yBottom <= ptl.y && rcl.xRight >= ptl.x && rcl.yTop >= ptl.y && td->pItems[item].ulFlags & tfDEPRESSED) { td->pItems[item].ulFlags &= ~tfDEPRESSED; WinInvalidateRect(hwnd, &rcl, FALSE); // message WinPostMsg(WinQueryWindow(hwnd, QW_OWNER), WM_COMMAND, MPFROM2SHORT(td->pItems[item].ulCommand, 0), MPFROM2SHORT(CMDSRC_OTHER, TRUE)); break; } } if (td->pItems[item].ulType == tiBITMAP) { rcl.xLeft += TXICON + 3; rcl.xRight += TXICON + 3; } else if (td->pItems[item].ulType == tiSEPARATOR) { rcl.xLeft += TXSEPARATOR + 3; rcl.xRight += TXSEPARATOR + 3; } } td->ulDepressed = -1; } break; } } return WinDefWindowProc(hwnd, msg, mp1, mp2); }
MRESULT EXPENTRY NewFrameProc( HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2 ) { PFNWP pfnwpOldFrameProc ; /* ------- get original frame procedure --------- */ pfnwpOldFrameProc = (PFNWP) WinQueryWindowULong( hwnd, QWL_USER ); switch (msg) { case WM_QUERYFRAMECTLCOUNT : { USHORT usItemCount ; /* ---- get count of original frame controls --- */ usItemCount = SHORT1FROMMR( pfnwpOldFrameProc( hwnd, msg, mp1, mp2 )); /* ------- add 1 for new toolbar control ------ */ return ( (MRESULT) ++usItemCount ); } case WM_FORMATFRAME : { PSWP pSWP ; // pointer to array of frame ctl SWPs USHORT usItemCount ; // count of original frame controls USHORT usNewMenuIndex ; // index of new menu SWP USHORT usToolBarIndex ; // index of Tool Bar menu SWP USHORT usClientIndex ; // index of client window SWP USHORT usVertScrollIndex ; // index of vertical scrollbar SWP HWND hwndVertScroll ; // hwnd of vertical scrollbar /* ------- get a pointer to the SWP array ---------- */ pSWP = PVOIDFROMMP( mp1 ); /* ---- run regular processing for original controls --- */ /* * Note that the original frame proc will setup all * the SWP sturctures for the standard frame window * controls starting at the beginning of the array. * A count of how many SWP structures were initialized * is returned. * All SWP structures for new controls that are to be * added ( in our case, 1 ) will be uninitialized and * at the end of the array. The start of the uninitialied * SWP structure start at an index equal to the returned * count. */ usItemCount = SHORT1FROMMR( pfnwpOldFrameProc( hwnd, msg, mp1, mp2 )); /* ------------- locate SWP for 1st menu ---------- */ /* * We will use the settings of the 1st menu to help initialize * the SWP for the second menu. We look for the proper SWP * by scanning the array for the matching hwnd. */ for ( usToolBarIndex = 0; usToolBarIndex < usItemCount; usToolBarIndex++) { if (pSWP[usToolBarIndex].hwnd == hwndToolBar){ break; } } // end of for( usToolBarIndex... /* ------------- locate SWP for client window ---------- */ /* * We will need to adjust the vertical height of the client * window to make room for the second menu. We look for the * proper SWP by scanning the array for a matching hwnd. */ for ( usClientIndex = 0; usClientIndex < usItemCount; usClientIndex++){ if (pSWP[usClientIndex].hwnd == hwndClient ){ break; } } // end of for ( usClientIndex... /* --- locate SWP for vert scroll (if exists) --- */ /* * First we will check if this window has a vert. scroll bar. * We will need to adjust the vertical height of the scroll * bar to make room for the second menu. We look for the * proper SWP by scanning the array for a matching hwnd. */ if ( ( hwndVertScroll = WinWindowFromID( hwnd, FID_VERTSCROLL)) != NULLHANDLE ){ for ( usVertScrollIndex = 0; usVertScrollIndex < usItemCount; usVertScrollIndex++){ if (pSWP[usVertScrollIndex].hwnd == hwndVertScroll ){ break; } } // end of for ( usClientIndex... } // end of if (( hwndVertScroll... /* ------ the new SWP starts after standard control SWPs ----- */ usNewMenuIndex = usItemCount ; /* ---- get size values for 2nd menu bar -------- */ pSWP[ usNewMenuIndex ].fl = SWP_SIZE; pSWP[ usNewMenuIndex ].cx = pSWP[usToolBarIndex].cx ; // set some pSWP[ usNewMenuIndex ].cy = pSWP[usToolBarIndex].cy ; // defaults pSWP[ usNewMenuIndex ].hwndInsertBehind = HWND_TOP ; pSWP[ usNewMenuIndex ].hwnd = hwndMenuBar ; /* -- get the menu code to make the actual size adjustments -- */ WinSendMsg( hwndMenuBar, WM_ADJUSTWINDOWPOS, MPFROMP( pSWP+usNewMenuIndex ), (MPARAM) 0L ); /* ------ position menu directly below other menu ------- */ pSWP[usNewMenuIndex].x = pSWP[usToolBarIndex].x ; pSWP[usNewMenuIndex].y = pSWP[usToolBarIndex].y - pSWP[usNewMenuIndex].cy ; pSWP[usNewMenuIndex].fl = pSWP[usToolBarIndex].fl ; /* -------- adjust client window size for 2nd menu ------- */ pSWP[usClientIndex].cy -= pSWP[usNewMenuIndex].cy ; /* -------- adjust vertical scroll size for 2nd menu ----- */ if ( hwndVertScroll != NULLHANDLE ){ pSWP[usVertScrollIndex].cy -= pSWP[usNewMenuIndex].cy ; } /* --- return total count of controls ( +1 for 2nd menu ) --- */ return( MRFROMSHORT( ++usItemCount ) ); } break; default: return( pfnwpOldFrameProc(hwnd,msg,mp1,mp2) ); } /* end of switch () */ return( FALSE ); } /* end of NewFrameProc */
static MRESULT APIENTRY Create ( HWND Window, MESG, MPARAM1 mp1, MPARAM2 ) { /************************************************************************** * Allocate instance data. * **************************************************************************/ PDATA Data = PDATA ( malloc ( sizeof(DATA) ) ) ; if ( Data == NULL ) { Log ( "ERROR: Unable to allocate instance memory for horizontal ruler." ) ; return ( MRFROMSHORT ( 1 ) ) ; } /* endif */ Sys_SetWindowData ( Window, Data ) ; /************************************************************************** * Grab any parameters from the WM_CREATE message. * **************************************************************************/ PHORZRULER_PARMS Parms = PHORZRULER_PARMS ( PVOIDFROMMP ( mp1 ) ) ; Data->IniData = Parms->IniData ; Data->MainWindow = Parms->MainWindow ; /************************************************************************** * Create the device context object for the window. * **************************************************************************/ WinOpenWindowDC ( Window ) ; Data->pDevice = new DeviceContext ( "HRuler", Window ) ; /************************************************************************** * Load the pointers. * **************************************************************************/ Data->MarginPtr = WinLoadPointer ( HWND_DESKTOP, 0, ID_MARGIN ) ; Data->TabstopPtr = WinLoadPointer ( HWND_DESKTOP, 0, ID_TABSTOP ) ; /************************************************************************** * Perform all other instance initializations. * **************************************************************************/ Data->Metric = FALSE ; Data->fxZoom = MAKEFIXED ( 1, 0 ) ; Data->PageWidth = 9000 ; Data->TopLeft = 9000 ; Data->LeftMargin = 0 ; Data->RightMargin = 9000 ; Data->TabCount = 0 ; memset ( Data->Tabs, 0, sizeof(Data->Tabs) ) ; Data->Tick = 0 ; Data->Capture = FALSE ; Data->Mode = NOTMOVING ; Data->SettingFont = FALSE ; /************************************************************************** * Success? Return no error. * **************************************************************************/ return ( MRFROMSHORT ( 0 ) ) ; }
/*--------------------------------------------------------------------------------------*\ * Procedure to write to logfile. * * Req: * * ulMsg ......... Message ID * * mpParam ....... Pointer to parameter * * Ref: * * pucSD2Logfile . Pointer to name of logfile * * Returns: * * TRUE/FALSE .... If called sucessfully/unsucessfully * \*--------------------------------------------------------------------------------------*/ BOOL UPS_LogfileIO(ULONG ulMsg, MPARAM mpParam) { FILE *Logfile; DATETIME *pDT=PVOIDFROMMP(mpParam); if((Logfile=fopen(pucSD2Logfile, "a"))==NULL) return(FALSE); /* Error, couldn't open logfile */ switch(ulMsg) { case LF_POWERFAILED: { /* Line power failed */ fprintf(Logfile, "*********************************************************************\n"); fprintf(Logfile, "*** SD/2 detected: Line power failed at: %4d/%02d/%02d at %02d:%02d:%02d ***\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); fprintf(Logfile, "*********************************************************************\n"); break; } case LF_POWERRETURNED: { /* Line power returned */ fprintf(Logfile, "*********************************************************************\n"); fprintf(Logfile, "*** SD/2 detected: Line power returned at: %4d/%02d/%02d at %02d:%02d:%02d ***\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); fprintf(Logfile, "*********************************************************************\n\n"); break; } case LF_UPS_ALERTSTARTTIME: { /* Planned Alert will start at... */ fprintf(Logfile, " Planning Alert start at: %4d/%02d/%02d at %02d:%02d:%02d\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); break; } case LF_UPS_ALERTSHUTDOWNTIME: { /* Planned user configurable program will be started at...*/ fprintf(Logfile, " Planning User-Application start at: %4d/%02d/%02d at %02d:%02d:%02d\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); break; } case LF_UPS_SHUTDOWNTIME: { /* Planned OS/2 DosShutdown will be called at...*/ fprintf(Logfile, " Planning OS/2 ShutDown at: %4d/%02d/%02d at %02d:%02d:%02d\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); break; } case LF_UPS_ALERTSTART: { /* Alert will start at...*/ fprintf(Logfile, " Alert started at: %4d/%02d/%02d at %02d:%02d:%02d\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); break; } case LF_UPS_ALERTSHUTDOWN: { /* The user configurable program will be started at...*/ fprintf(Logfile, " User-Application started at: %4d/%02d/%02d at %02d:%02d:%02d\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); break; } case LF_UPS_SHUTDOWN: { /* OS/2 DosShutdown will be called at...*/ fprintf(Logfile, " OS/2 ShutDown started at: %4d/%02d/%02d at %02d:%02d:%02d\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); break; } case LF_INIFILE_MISSING: { /* SD/2 profile is missing or defective */ fprintf(Logfile, "\n+-------------------------------------------------------------------+\n"); fprintf(Logfile, "| ! SD/2 detected: Profile defective at: %4d/%02d/%02d at %02d:%02d:%02d ! |\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); fprintf(Logfile, "| ! Creating default SHUTDOWN.INI - please adjust immediately! ! |\n"); fprintf(Logfile, "+-------------------------------------------------------------------+\n\n"); break; } case LF_INIFILE_PROBLEM: { /* SD/2 profile can't be accessed */ fprintf(Logfile, "\n+-------------------------------------------------------------------+\n"); fprintf(Logfile, "| ! SD/2 detected: Profile defective at: %4d/%02d/%02d at %02d:%02d:%02d ! |\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); fprintf(Logfile, "| ! Can't access SHUTDOWN.INI - Serious problem, please correct! ! |\n"); fprintf(Logfile, "+-------------------------------------------------------------------+\n\n"); break; } case LF_PARALLEL_INITIALIZED: { /* UPS <-> SD/2 interface at parallel port */ fprintf(Logfile, "\n*********************************************************************\n"); fprintf(Logfile, "*** Parallel port initialized for UPS <-> SD/2 communication ***\n"); fprintf(Logfile, "*** Current System Date & Time is: %4d/%02d/%02d at %02d:%02d:%02d ***\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); fprintf(Logfile, "*********************************************************************\n\n"); break; } case LF_SERIAL_INITIALIZED: { /* UPS <-> SD/2 interface at serial port */ fprintf(Logfile, "\n*********************************************************************\n"); fprintf(Logfile, "*** Serial port initialized for UPS <-> SD/2 communication ***\n"); fprintf(Logfile, "*** Current System Date & Time is: %4d/%02d/%02d at %02d:%02d:%02d ***\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); fprintf(Logfile, "*********************************************************************\n\n"); break; } case LF_UPS_PASSWORD_USED: { /* The program was invoked with the undocumented commandline option [-|/]IBMSERVICE */ fprintf(Logfile, "\n+-------------------------------------------------------------------+\n"); fprintf(Logfile, "| ! SD/2 detected: Service applied at: %4d/%02d/%02d at %02d:%02d:%02d ! |\n", pDT->year, pDT->month, pDT->day, pDT->hours, pDT->minutes, pDT->seconds); fprintf(Logfile, "| ! ! |\n"); fprintf(Logfile, "| ! The configuration service option is used. Please be sure that ! |\n"); fprintf(Logfile, "| ! all changes of the configuration correspond to their equiva- ! |\n"); fprintf(Logfile, "| ! lent settings of the UPS control logic. ! |\n"); fprintf(Logfile, "| ! Warning! SD/2 and the UPS control logic may not operate ! |\n"); fprintf(Logfile, "| ! correctly, if this service isn't performed by IBM! ! |\n"); fprintf(Logfile, "+-------------------------------------------------------------------+\n\n"); break; } } fclose(Logfile); return(TRUE); }
MRESULT EXPENTRY MaskDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { static PMASKSEL pmask; static BOOL flag = FALSE; // TRUE se Š stato aggiunto o tolto un elemento static int idx; // posizione item selezionato o di inserzione switch (msg) { case WM_INITDLG: { CHAR buf[FACESIZE]; PSZ pszCur; int len; pmask = (PMASKSEL)PVOIDFROMMP(mp2); // recupera indirizzo dati // imposta il font della barra del titolo: PrfQueryProfileString(HINI_USERPROFILE, "PM_SystemFonts", "WindowTitles", "9.WarpSans", buf, FACESIZE); WinSetPresParam(WinWindowFromID(hwnd, FID_TITLEBAR), PP_FONTNAMESIZE, sstrlen(buf) + 1, (PVOID)(buf)); WinSetWindowPos(hwnd, HWND_BOTTOM, pmask->pos.x, pmask->pos.y, 0, 0, SWP_MOVE | SWP_SHOW); // visualizza la finestra pszCur = pmask->pszExt; DlgEFSetTxtLimit(hwnd, COMBO_MASK, 63); // riempie la listbox while (len = sstrlen(pszCur)) { DlgLboxInsertItem(hwnd, COMBO_MASK, LIT_SORTASCENDING, pszCur); pszCur += len + 1; } /* endwhile */ } // end case WM_INITDLG: break; case WM_CONTROL: switch (SHORT2FROMMP(mp1)) { case CBN_EFCHANGE: { // cambiamento testo BOOL enable; // pulsante OK abilitato se c'e' testo nell' entrifield enable = WinQueryDlgItemTextLength(hwnd, COMBO_MASK); WinEnableControl(hwnd, MASK_OK, enable); // pulsante ADD abilitato se c'Š testo non gi… presente WinQueryDlgItemText(hwnd, COMBO_MASK, 64, pmask->achSel); idx = isInListBox(hwnd, pmask->achSel, COMBO_MASK); WinEnableControl(hwnd, MASK_STORE, enable && (idx < 0)); // pulsante REMOVE abilitato se testo EF == item lista WinEnableControl(hwnd, MASK_DEL, idx >= 0); } // end case CBN_EFCHANGE: break; case CBN_LBSELECT: // selezione item idx = isInListBox(hwnd, pmask->achSel, COMBO_MASK); WinEnableControl(hwnd, MASK_DEL, idx >= 0); break; default: break; } /* endswitch */ break; case WM_COMMAND: switch (LOUSHORT(mp1)) { case MASK_OK: WinQueryDlgItemText(hwnd, COMBO_MASK, 64, pmask->achSel); if (flag) // eventualmente aggiorna lista filespec ProcMaskDlgExit(hwnd, pmask); SaveMaskDlgPos(hwnd, pmask); WinDismissDlg(hwnd, TRUE); break; case MASK_STORE: flag = TRUE; DlgLboxInsertItem(hwnd, COMBO_MASK, LIT_SORTASCENDING, pmask->achSel); DlgLboxSelectItem(hwnd, COMBO_MASK, -idx - 1); WinEnableControl(hwnd, MASK_STORE, FALSE); break; case MASK_DEL: flag = TRUE; idx = DlgLboxQuerySelectedItem(hwnd, COMBO_MASK); DlgLboxDeleteItem(hwnd, COMBO_MASK, idx); WinSetDlgItemText(hwnd, COMBO_MASK, ""); break; default: if (flag) // eventualmente aggiorna lista filespec ProcMaskDlgExit(hwnd, pmask); SaveMaskDlgPos(hwnd, pmask); WinDismissDlg(hwnd, FALSE); break; } /* endswitch */ break; case WM_CLOSE: if (flag) // eventualmente aggiorna lista filespec ProcMaskDlgExit(hwnd, pmask); SaveMaskDlgPos(hwnd, pmask); WinDismissDlg(hwnd, FALSE); break; default: return WinDefDlgProc(hwnd, msg, mp1, mp2); } // end switch return (MRESULT) FALSE; }
MRESULT EXPENTRY newProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { switch (msg) { case WM_CREATE: { PCREATESTRUCT pCreate=PVOIDFROMMP(mp2); /* Initialize the slider data */ WinSetWindowUShort(hwnd, SLIDERARMWITH,20); WinSetWindowUShort(hwnd, SLIDERARMHEIGHT,10); /* Dimensions of slider. The slider active area is smaller than the window to allow drawing of active state. */ WinSetWindowULong(hwnd, SLIDERCX,pCreate->cx-4); WinSetWindowULong(hwnd, SLIDERCY,pCreate->cy-4); WinSetWindowULong(hwnd, SLIDERX,2); WinSetWindowULong(hwnd, SLIDERY,2); WinSetWindowULong(hwnd, SLIDERARMPOS, 0); WinSetWindowULong(hwnd, SLDRAGGING,FALSE); return (MRESULT)0; } case WM_SIZE: WinSetWindowULong(hwnd, SLIDERCX, SHORT1FROMMP(mp2)-4); WinSetWindowULong(hwnd, SLIDERCY, SHORT2FROMMP(mp2)-4); WinInvalidateRect(hwnd, NULLHANDLE,TRUE); return (MRESULT)0; case WM_BUTTON1DOWN: { SHORT x=SHORT1FROMMP( mp1); SHORT y=SHORT2FROMMP( mp1); LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS); USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH); if(x<lPos+usWidth && y<WinQueryWindowUShort(hwnd, SLIDERY)+WinQueryWindowUShort(hwnd, SLIDERCY) && y>WinQueryWindowUShort(hwnd, SLIDERY)) { WinSetWindowUShort(hwnd, PTRPOSINSLARM, x-lPos); } WinSetFocus(HWND_DESKTOP, hwnd); break; } case WM_FOCUSCHANGE: { HPS hps; RECTL rcl; POINTL ptl; if(SHORT1FROMMP(mp2)) { hps=WinGetPS(hwnd); WinQueryWindowRect(hwnd, &rcl); GpiSetLineType(hps, LINETYPE_DOT); ptl.x=rcl.xLeft; ptl.y=rcl.yBottom; GpiMove(hps,&ptl); ptl.x=rcl.xRight-1; GpiLine(hps,&ptl); ptl.y=rcl.yTop-1; GpiLine(hps,&ptl); ptl.x=rcl.xLeft; GpiLine(hps,&ptl); ptl.y=rcl.yBottom; GpiLine(hps,&ptl); WinReleasePS(hps); } else { WinInvalidateRect(hwnd, NULLHANDLE,TRUE); } break; } case WM_CHAR: if(WinQueryFocus(HWND_DESKTOP)==hwnd) { /* We have the focus */ if((SHORT1FROMMP(mp1) & (KC_VIRTUALKEY))==(KC_VIRTUALKEY)) { LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS); USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH); ULONG ulCx=WinQueryWindowULong(hwnd, SLIDERCX); #if 0 FILE* file; file=fopen("d:\\md.log","a"); fprintf(file,"0x%x 0x%x \n",SHORT1FROMMP(mp1),SHORT2FROMMP(mp1) ); fclose(file); #endif /*(KC_KEYUP|KC_PREVDOWN|KC_VIRTUALKEY)*/ switch(SHORT2FROMMP(mp2)) { case VK_RIGHT: if(SHORT1FROMMP(mp1) & (KC_KEYUP|KC_PREVDOWN)) { lPos+=2; if(lPos>ulCx-usWidth) lPos=ulCx-usWidth; else { WinPostMsg( hwnd, SLM_SETSLIDERINFO, MPFROM2SHORT(SMA_SLIDERARMPOSITION, SMA_RANGEVALUE), MPFROMLONG( (LONG) lPos )); if(SHORT1FROMMP(mp1) & KC_LONEKEY) /* Post SLN_CHANGE notification */ WinPostMsg( WinQueryWindow(hwnd, QW_PARENT),WM_CONTROL, MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_CHANGE), MPFROMLONG(lPos)); else /* Post SLN_SLIDERTRACK notification */ WinPostMsg(WinQueryWindow(hwnd, QW_PARENT),WM_CONTROL, MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_SLIDERTRACK), MPFROMLONG(lPos)); } WinSetWindowULong(hwnd, SLIDERARMPOS, lPos); } return (MRESULT)TRUE; case VK_LEFT: if(SHORT1FROMMP(mp1) & (KC_KEYUP|KC_PREVDOWN)) { lPos-=2; if(lPos<0) { lPos=0; } else { WinPostMsg( hwnd, SLM_SETSLIDERINFO, MPFROM2SHORT(SMA_SLIDERARMPOSITION, SMA_RANGEVALUE), MPFROMLONG( (LONG) lPos )); /* Post SLN_CHANGE notification */ WinPostMsg(WinQueryWindow(hwnd, QW_PARENT), WM_CONTROL, MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_CHANGE), MPFROMLONG(WinQueryWindowULong(hwnd, SLIDERARMPOS))); } WinSetWindowULong(hwnd, SLIDERARMPOS, lPos); } return (MRESULT)TRUE; default: break; } } } break; case WM_BUTTON1MOTIONSTART: { SHORT x=SHORT1FROMMP( mp1); SHORT y=SHORT2FROMMP( mp1); LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS); USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH); if(x<lPos+usWidth && y<WinQueryWindowUShort(hwnd, SLIDERY)+WinQueryWindowUShort(hwnd, SLIDERCY) && y>WinQueryWindowUShort(hwnd, SLIDERY)) { WinSetWindowULong(hwnd, SLDRAGGING, TRUE); WinSetCapture(HWND_DESKTOP, hwnd); } break; } case WM_BUTTON1MOTIONEND: if(WinQueryWindowULong(hwnd, SLDRAGGING)) { WinSetWindowULong(hwnd, SLDRAGGING,FALSE); WinSetCapture(HWND_DESKTOP, NULLHANDLE); /* Post SLN_CHANGE notification */ WinPostMsg(WinQueryWindow(hwnd, QW_PARENT),WM_CONTROL, MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_CHANGE), MPFROMLONG(WinQueryWindowULong(hwnd, SLIDERARMPOS))); } break; case SLM_SETSLIDERINFO: switch(SHORT1FROMMP(mp1)) { case SMA_SLIDERARMPOSITION: /* SMA_RANGEVALUE only for now !! */ if(SHORT2FROMMP(mp1)==SMA_RANGEVALUE) { WinSetWindowULong(hwnd, SLIDERARMPOS, LONGFROMMP(mp2)); WinInvalidateRect(hwnd, NULLHANDLE,TRUE); return (MRESULT)0; } break; default: break; } break; case WM_MOUSEMOVE: if(WinQueryWindowULong(hwnd, SLDRAGGING)) { HPS hps; RECTL rcl, rcl2, rcl3; LONG lTemp; SHORT x=SHORT1FROMMP(mp1); LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS); USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH); lTemp=lPos; rcl.xLeft=WinQueryWindowULong(hwnd, SLIDERX); rcl.yBottom=WinQueryWindowULong(hwnd, SLIDERY); rcl.xRight=rcl.xLeft+WinQueryWindowULong(hwnd, SLIDERCX); rcl.yTop=rcl.yBottom+WinQueryWindowULong(hwnd, SLIDERCY); rcl2=rcl3=rcl; rcl.xLeft=x-WinQueryWindowUShort(hwnd, PTRPOSINSLARM); if(rcl.xLeft<rcl2.xLeft)/* Make sure we stop at the left border */ rcl.xLeft=rcl2.xLeft; rcl.xRight=rcl.xLeft+usWidth; if(rcl.xRight>rcl2.xRight) {/* Make sure we stop at the right border */ rcl.xRight=rcl2.xRight; rcl.xLeft=rcl.xRight-usWidth; } lPos=rcl.xLeft-WinQueryWindowULong(hwnd, SLIDERX);/* Save position zero based */ WinSetWindowULong(hwnd, SLIDERARMPOS, lPos); if(lPos!=lTemp) { BOOL rc; hps=WinGetPS(hwnd); /* Paint Background not necessary here */ /* Shaft */ /* Left part */ rcl3.xRight=rcl.xLeft; rc=FALSE; if(USERSLIDER) { OWNERITEM oi={0}; oi.hwnd=hwnd; oi.hps=hps; oi.fsState=SLS_OWNERDRAW;/* More to come */ oi.rclItem=rcl3; oi.idItem=SDA_SLIDERSHAFT; rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)), MPFROMP(&oi) ); } if(!rc) WinFillRect(hps, &rcl3, CLR_GREEN); /* Right part */ rcl3.xRight=rcl2.xRight; rcl3.xLeft=rcl.xRight; rc=FALSE; if(USERSLIDER) { OWNERITEM oi={0}; oi.hwnd=hwnd; oi.hps=hps; oi.fsState=SLS_OWNERDRAW;/* More to come */ oi.rclItem=rcl3; oi.idItem=SDA_SLIDERSHAFT; rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)), MPFROMP(&oi) ); } if(!rc) WinFillRect(hps, &rcl3, CLR_WHITE); /* Paint Slider */ rc=FALSE; if(USERSLIDER) { OWNERITEM oi={0}; oi.hwnd=hwnd; oi.hps=hps; oi.fsState=SLS_OWNERDRAW;/* More to come */ oi.rclItem=rcl; oi.idItem=SDA_SLIDERARM; rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)), MPFROMP(&oi) ); } if(!rc) { WinFillRect(hps,&rcl, CLR_BLUE); WinDrawBorder(hps, &rcl, 2, 2, 0, 0 ,0x0400); } WinReleasePS(hps); /* Post SLN_SLIDERTRACK notification */ WinPostMsg(WinQueryWindow(hwnd, QW_PARENT),WM_CONTROL, MPFROM2SHORT(WinQueryWindowUShort(hwnd, QWS_ID), SLN_SLIDERTRACK), MPFROMLONG(lPos)); } } break; case WM_PAINT: { HPS hps, hps2; RECTL rcl, rcl2, rcl3; POINTL ptl; LONG lPos=WinQueryWindowULong(hwnd, SLIDERARMPOS); USHORT usWidth=WinQueryWindowUShort(hwnd, SLIDERARMWITH); BOOL rc; WinQueryWindowRect(hwnd, &rcl); /* Shaft */ rcl2.xLeft=WinQueryWindowULong(hwnd, SLIDERX); rcl2.yBottom=WinQueryWindowULong(hwnd, SLIDERY); rcl2.xRight=rcl2.xLeft+WinQueryWindowULong(hwnd, SLIDERCX)-1; rcl2.yTop=rcl2.yBottom+WinQueryWindowULong(hwnd, SLIDERCY)-1; /* Background */ hps2=WinGetPS(hwnd); GpiExcludeClipRectangle(hps2,&rcl2); WinFillRect(hps2, &rcl, CLR_PALEGRAY); WinReleasePS(hps2); rcl2.yTop+=1; rcl2.xRight+=1; hps=WinBeginPaint(hwnd, NULLHANDLE, NULLHANDLE); /* Focus */ if(WinQueryFocus(HWND_DESKTOP)==hwnd) { GpiSetLineType(hps, LINETYPE_DOT); ptl.x=rcl.xLeft; ptl.y=rcl.yBottom; GpiMove(hps,&ptl); ptl.x=rcl.xRight-1; GpiLine(hps,&ptl); ptl.y=rcl.yTop-1; GpiLine(hps,&ptl); ptl.x=rcl.xLeft; GpiLine(hps,&ptl); ptl.y=rcl.yBottom; GpiLine(hps,&ptl); } rcl3=rcl=rcl2; /* Arm pos */ rcl2.xLeft+=lPos; /* Arm size */ rcl2.xRight=rcl2.xLeft+usWidth; /* Shaft */ /* Left part */ rcl3.xRight=rcl2.xLeft; rc=FALSE; if(USERSLIDER) { OWNERITEM oi={0}; oi.hwnd=hwnd; oi.hps=hps; oi.fsState=SLS_OWNERDRAW;/* More to come */ oi.rclItem=rcl3; oi.idItem=SDA_SLIDERSHAFT; rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)), MPFROMP(&oi) ); } if(!rc) WinFillRect(hps, &rcl3, CLR_GREEN); /* Right part */ rcl3.xRight=rcl.xRight; rcl3.xLeft=rcl2.xRight; rc=FALSE; if(USERSLIDER) { OWNERITEM oi={0}; oi.hwnd=hwnd; oi.hps=hps; oi.fsState=SLS_OWNERDRAW;/* More to come */ oi.rclItem=rcl3; oi.idItem=SDA_SLIDERSHAFT; rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)), MPFROMP(&oi) ); } if(!rc) WinFillRect(hps, &rcl3, CLR_WHITE); rc=FALSE; if(USERSLIDER) { OWNERITEM oi={0}; oi.hwnd=hwnd; oi.hps=hps; oi.fsState=SLS_OWNERDRAW;/* More to come */ oi.rclItem=rcl2; oi.idItem=SDA_SLIDERARM; rc=(BOOL)WinSendMsg(WinQueryWindow(hwnd, QW_PARENT), WM_DRAWITEM, MPFROMSHORT(WinQueryWindowUShort(hwnd, QWS_ID)), MPFROMP(&oi) ); } if(!rc) { WinFillRect(hps,&rcl2, CLR_BLUE); WinDrawBorder(hps, &rcl2, 2, 2, 0, 0 ,0x0400); } WinEndPaint(hps); return (MRESULT)0; } break; default: break; } return WinDefWindowProc(hwnd, msg, mp1, mp2); }
/****************************************************************\ * Main client window procedure *-------------------------------------------------------------- * * Name: MainWndProc(hwnd, msg, mp1, mp2) * * Purpose: Processes the messages sent to the main client * window. This routine processes the basic * messages all client windows should process * and passes all others onto WinDefWindowProc. * * Usage: Called for each message placed in the main * window's message queue * * Method: a switch statement branches to the routines to be * performed for each message processed. * * Returns: Return values are determined by each message * \****************************************************************/ MRESULT EXPENTRY MainWndProc(HWND hwnd, /* handle of window */ ULONG msg, /* id of message */ MPARAM mp1, /* first message parameter */ MPARAM mp2) /* second message parameter */ { QDATA *pqdataQ; switch(msg) { case WM_CREATE: return InitMainWindow(hwnd, mp1, mp2); break; case WM_PAINT: MainPaint(hwnd, SvrQMsgs, iIndex, sTotalMsgs); break; case WM_SIZE: MainSize(hwnd, sTotalMsgs, mp1, mp2); break; case WM_HSCROLL: MainHorizScroll(hwnd, mp2); break; case WM_VSCROLL: MainVertScroll(hwnd, mp2); break; case WM_CHAR: switch (SHORT2FROMMP(mp2)) { case VK_LEFT: case VK_RIGHT: return MainCharHScroll (hwnd, msg, mp1, mp2) ; case VK_UP: case VK_DOWN: case VK_PAGEUP: case VK_PAGEDOWN: return MainCharVScroll (hwnd, msg, mp1, mp2) ; } break ; case WM_COMMAND: MainCommand(mp1, mp2); break; case HM_QUERY_KEYS_HELP: return (MRESULT)PANEL_HELPKEYS; /* return id of key help panel */ break ; case WM_NEWQMSG: /* copy message into circular array, with index being next free spot in array */ pqdataQ = (QDATA *)PVOIDFROMMP(mp1); sprintf(SvrQMsgs[iIndex], "Process ID: %03lu, Priority: %02hu, Message: %s", pqdataQ->pidProcess, pqdataQ->usPriority, pqdataQ->pszMsg); /* increment index, or reset to 0 as appropriate */ iIndex = (iIndex < MAX_MESSAGES - 1) ? iIndex + 1 : 0; /* increment total message count until buffer is filled */ sTotalMsgs = min(MAX_MESSAGES, sTotalMsgs + 1); MainUpdateMsg(hwnd, SvrQMsgs, iIndex, sTotalMsgs); break; case WM_MSG: MessageBox(hwndMain, (ULONG)SHORT1FROMMP(mp1), MB_OK | MB_ICONEXCLAMATION | MB_APPLMODAL, TRUE); break; case WM_CLOSE: DosWriteQueue(hqQ, WM_CLOSE, 0UL, NULL, 15UL); /* process the WM_CLOSE */ /*--------------------------------------------------*\ * Any messages not processed are passed on * to WinDefWindowProc. \*--------------------------------------------------*/ default: return WinDefWindowProc(hwnd, msg, mp1, mp2); break; } return MRFROMLONG(0L); /* all window procedures should return 0 as a default */ } /* MainWndProc() */
MRESULT EXPENTRY scbProcedure(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { switch(msg) { case WM_CREATE: create(hwnd,PVOIDFROMMP(mp2)); return WinDefWindowProc(hwnd, msg, mp1, mp2); case 0x041E: selectBitmap(hwnd, BITMAP_MOUSEOVER); return WinDefWindowProc(hwnd, msg, mp1, mp2); case 0x041F: selectBitmap(hwnd, BITMAP_NORMAL); return WinDefWindowProc(hwnd, msg, mp1, mp2); case WM_BUTTON1DOWN: selectBitmap(hwnd, BITMAP_PRESS); break; case WM_BUTTON1UP: selectBitmap(hwnd, BITMAP_MOUSEOVER); break; case WM_DESTROY: destroy(hwnd); /* Limpa bitmaps */ return WinDefWindowProc(hwnd, msg, mp1, mp2); case WM_PAINT: paint(hwnd); break; case WM_WINDOWPOSCHANGED: ajustBackground(hwnd,PVOIDFROMMP(mp1)); return WinDefWindowProc(hwnd, msg, mp1, mp2); case WMSKN_AJUSTSIZEPOS: sizePos(hwnd,SHORT1FROMMP(mp1),SHORT2FROMMP(mp1),SHORT1FROMMP(mp2),SHORT2FROMMP(mp2)); break; case WMSKN_QUERYPOS: return getpos(hwnd); case WMSKN_QUERYSIZE: return getsize(hwnd); case WMSKN_AJUSTPOS: reposic(hwnd,SHORT1FROMMP(mp1),SHORT2FROMMP(mp1)); break; case WMSKN_SETIMAGE: /* MP1=XBITMAP, MP2=ID */ loadImage(hwnd,SHORT1FROMMP(mp2),PVOIDFROMMP(mp1)); break; case WMSKN_SETLIMITS: setLimits(hwnd,LONGFROMMP(mp1),LONGFROMMP(mp2)); break; case WMSKN_SETVALUE: setValue(hwnd,LONGFROMMP(mp1)); break; case WMSKN_UP: moveCursor(hwnd, -1); break; case WMSKN_DOWN: moveCursor(hwnd, 1); break; case WMSKN_CONNECT: doConnect(hwnd,LONGFROMMP(mp1),LONGFROMMP(mp2)); break; case WM_BEGINDRAG: DBGMessage("Iniciou drag&drop"); ((SLIDERDATA *) WinQueryWindowPtr(hwnd,0))->drag = TRUE; WinSetCapture(HWND_DESKTOP,hwnd); break; case WM_ENDDRAG: DBGMessage("Terminou drag&drop"); ((SLIDERDATA *) WinQueryWindowPtr(hwnd,0))->drag = FALSE; WinSetCapture(HWND_DESKTOP,NULLHANDLE); break; case WM_MOUSEMOVE: if(((SLIDERDATA *) WinQueryWindowPtr(hwnd,0))->drag) mouseMove(hwnd, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1)); break; default: return WinDefWindowProc(hwnd, msg, mp1, mp2); } return 0; }
/*����������������������������������������������������������������������������*/ MRESULT FilterDlgProc( HWND hwnd, register ULONG message, MPARAM lParam1, MPARAM lParam2 ) { /*���������������������������������������������������������������������Ŀ*/ /*� Local Variables �*/ /*�����������������������������������������������������������������������*/ MRESULT dpResult = NULL; register USHORT pbSelected; CHAR sFilterItem[128]; PMSG_ITEM pMsg; static PSPY_DATA pSpyData = NULL; HWND hwndLB; /* HWND of message listbox */ /*����������������������������������������������������������������������Ŀ*/ /*� Process the message �*/ /*������������������������������������������������������������������������*/ switch (message) /* Switch off of the message ID */ { /*������������������������������������������������������������������Ŀ*/ /*� One of our pushbuttons was pressed... �*/ /*��������������������������������������������������������������������*/ case WM_COMMAND: switch( pbSelected = LOUSHORT( lParam1 ) ) { /*������������������������������������������������������������Ŀ*/ /*� Process selected items �*/ /*��������������������������������������������������������������*/ default: { USHORT curItem, /* current list item */ nSelected; /* Number of items selected */ MSG_COLOR color = GetColor( hwnd, pSpyData); /*����������������������������������������������������������Ŀ*/ /*� Obtain HWND of message listbox once for performance �*/ /*������������������������������������������������������������*/ hwndLB = WinWindowFromID(hwnd, IDD_FILTER); /************************************************************ * "Lock" the ListBox to minimize performance impact ************************************************************/ WinLockWindowUpdate(HWND_DESKTOP, /* Desktop */ hwndLB); /* Lockee */ /************************************************************ * Process the "selected" ListBox items ************************************************************/ for(nSelected = 0, /* Initialize */ curItem = SHORT1FROMMR(WinSendMsg(hwndLB, LM_QUERYSELECTION, MPFROMSHORT(LIT_FIRST), NULL) ); curItem != (USHORT)LIT_NONE; /* While */ nSelected++, /* Iterate */ curItem = SHORT1FROMMR(WinSendMsg(hwndLB, LM_QUERYSELECTION, MPFROMSHORT(curItem), NULL) ) ) { /*��������������������������������������������������������Ŀ*/ /*� Locate specific MSG item for this selected item �*/ /*����������������������������������������������������������*/ pMsg = PVOIDFROMMR( WinSendMsg(hwndLB, LM_QUERYITEMHANDLE, MPFROMSHORT(curItem), NULL) ); /*��������������������������������������������������������Ŀ*/ /*� Perform action on this selected item �*/ /*����������������������������������������������������������*/ switch( pbSelected ) { /********************************************************* * Delete this MSG's definition **********************************************************/ case ID_PB_F_DELETE: DeleteMsg(pSpyData, pMsg->Msg); WinSendMsg(hwndLB, LM_DELETEITEM, MPFROMSHORT(curItem), MPFROMP(NULL)); curItem = (USHORT)( (curItem == 0) ? LIT_FIRST : (curItem - 1) ); break; /********************************************************* * Mark that this MSG can NOT be "spied" / act as "trigger" **********************************************************/ case ID_PB_F_EXCLUDE: IncludeMsg(pSpyData, pMsg->Msg, BOOL_FALSE, color); WinSendMsg(hwndLB, LM_SETITEMTEXT, MPFROMSHORT(curItem), MPFROMP(FormatMSG(pMsg, sFilterItem))); break; /********************************************************* * Mark that this MSG can be "spied" / act as "trigger" **********************************************************/ case ID_PB_F_INCLUDE: IncludeMsg(pSpyData, pMsg->Msg, BOOL_TRUE, color); WinSendMsg(hwndLB, LM_SETITEMTEXT, MPFROMSHORT(curItem), MPFROMP(FormatMSG(pMsg, sFilterItem))); break; /********************************************************* * Set FREEZE "trigger" **********************************************************/ case ID_PB_F_FREEZE: pMsg->TriggerFreeze = BOOL_TRUE; pMsg->TriggerThaw = BOOL_FALSE; WinSendMsg(hwndLB, LM_SETITEMTEXT, MPFROMSHORT(curItem), MPFROMP(FormatMSG(pMsg, sFilterItem))); if (color != Color_Asis) pMsg->ClrFG = color; break; /********************************************************* * Set THAW "trigger" **********************************************************/ case ID_PB_F_THAW: pMsg->TriggerThaw = BOOL_TRUE; pMsg->TriggerFreeze = BOOL_FALSE; WinSendMsg(hwndLB, LM_SETITEMTEXT, MPFROMSHORT(curItem), MPFROMP(FormatMSG(pMsg, sFilterItem))); if (color != Color_Asis) pMsg->ClrFG = color; break; /********************************************************* * Remove FREEZE and THAW "triggers" **********************************************************/ case ID_PB_F_NO_TRIGGER: pMsg->TriggerFreeze = pMsg->TriggerThaw = BOOL_FALSE; WinSendMsg(hwndLB, LM_SETITEMTEXT, MPFROMSHORT(curItem), MPFROMP(FormatMSG(pMsg, sFilterItem))); if (color != Color_Asis) pMsg->ClrFG = color; break; /********************************************************* * Reset MSG unique data **********************************************************/ case ID_PB_F_RESET: pMsg->aulTimes[MSG_TIMES_SINCE] = 0; if (color != Color_Asis) pMsg->ClrFG = color; break; } } /************************************************************ * Finally, "unlock" the ListBox so it is only redrawn once ************************************************************/ WinLockWindowUpdate(HWND_DESKTOP, NULLHANDLE); /************************************************************ * Make "noise" if no items were selected... ************************************************************/ if (nSelected == 0) WinAlarm(HWND_DESKTOP, WA_ERROR); } break; /*������������������������������������������������������������Ŀ*/ /*� User cancelled dialog �*/ /*��������������������������������������������������������������*/ case DID_CANCEL: WinDismissDlg(hwnd, 0); /* Close dialog */ break; } break; /* Break WM_COMMAND */ /*������������������������������������������������������������������Ŀ*/ /*� WM_CLOSE: �*/ /*� - Call WinDismissDlg to close the dialog box �*/ /*��������������������������������������������������������������������*/ case WM_CLOSE: /* Close Dialog Box. */ WinDismissDlg( hwnd, 0); break; /*������������������������������������������������������������������Ŀ*/ /*� WM_INITDLG: �*/ /*� - Init pointer to data pointed to by WinDlgBox �*/ /*� - Init global handle of this dlg �*/ /*� �*/ /*� - MP2 = PSPY_DATA �*/ /*��������������������������������������������������������������������*/ case WM_INITDLG: { register USHORT list_index; /*�����������������������������������������������������������Ŀ*/ /*� Locate "SPY" data to utilize �*/ /*�������������������������������������������������������������*/ pSpyData = PVOIDFROMMP(lParam2); /*�����������������������������������������������������������Ŀ*/ /*� Obtain HWND of message listbox once for performance �*/ /*�������������������������������������������������������������*/ hwndLB = WinWindowFromID(hwnd, IDD_FILTER); /*������������������������������������������������������������Ŀ*/ /*� Set listbox FONT to current non-proportional value �*/ /*��������������������������������������������������������������*/ SetListboxFont(hwndLB, (PSZ) pSpyData->pfnLB); /************************************************************ * "Lock" the ListBox to minimize performance impact ************************************************************/ WinLockWindowUpdate(HWND_DESKTOP, /* Desktop */ hwndLB); /* Lockee */ /*�����������������������������������������������������������Ŀ*/ /*� Add all Messages to list box �*/ /*�������������������������������������������������������������*/ for( /* Initialize */ pMsg = ProcessFirstMsg(pSpyData); /* start @ first MSG */ /* Terminate */ pMsg != NULL; /* stop at End-Of-Table */ /* Iterate */ pMsg = ProcessNextMsg(pSpyData) /* try the next MSG */ ) { list_index = (USHORT) WinSendMsg(hwndLB, LM_INSERTITEM, MPFROMSHORT(LIT_SORTASCENDING), MPFROMP(FormatMSG(pMsg, sFilterItem)) ); WinSendMsg(hwndLB, /* Window Handle */ LM_SETITEMHANDLE, /* Message */ MPFROMSHORT(list_index), /* Index of list item */ MPFROMP(pMsg)); /* Handle of list item */ } /************************************************************ * Finally, "unlock" the ListBox so it is only redrawn once ************************************************************/ WinLockWindowUpdate(HWND_DESKTOP, NULLHANDLE); /************************************************************ * Other dialog set-up ************************************************************/ SetColors( hwnd, pSpyData ); /* load colors */ CenterDialog(hwnd); /* Center the Dialog */ } break; /*������������������������������������������������������������������Ŀ*/ /*� We don't need to handle any other messages... �*/ /*� �*/ /*� If this isn't an IPF message, let PM do it's default "thing" �*/ /*��������������������������������������������������������������������*/ default: if ( !HandleIPF(hwnd, message, lParam1, lParam2, &dpResult) ) dpResult = WinDefDlgProc(hwnd, /* Dialog Handle */ message, /* Message */ lParam1, /* First parameter for message. */ lParam2); /* Second parameter for message.*/ } /* End MSG switch */ /*�����������������������������������������������������������������������Ŀ*/ /*� Exit �*/ /*�������������������������������������������������������������������������*/ return( dpResult ); }
BOOL NextBar::OCommand(ULONG msg, MPARAM mp1, MPARAM mp2) { switch(msg) { case WM_CREATE: if (setup.floating) floatTimer.setNotify(hwnd).start(); break; case WM_TOOLBAR_RESET: resetToolBar(); break; case WM_CFG_CANCELED: { pNextBarEvent actual = (pNextBarEvent) PVOIDFROMMP(mp1); if (actual) events.del(actual); break; } case WM_SAVE_BUTTONS: saveProfile(); resetToolBar(); break; case WM_CONTROL: switch(SHORT1FROMMP(mp1)) { case OBUTTONBAR_MOVEOVER: selectedButton = SHORT2FROMMP(mp1); break; case OBUTTONBAR_BUTTON2DOWN: selectedButton = SHORT2FROMMP(mp1); WinSendMsg(menu, MM_SETITEMATTR, MPFROM2SHORT(NHX_DEL_BUTTON, FALSE), MPFROM2SHORT(MIA_DISABLED, (selectedButton == NHX_MAIN) ? MIA_DISABLED : ~MIA_DISABLED)); WinSendMsg(menu, MM_SETITEMATTR, MPFROM2SHORT(NHX_CFG_BUTTON, FALSE), MPFROM2SHORT(MIA_DISABLED, (selectedButton == NHX_MAIN) ? MIA_DISABLED : ~MIA_DISABLED)); WinPopupMenu(frame, frame, menu, SHORT1FROMMP(mp2), SHORT2FROMMP(mp2), NHX_CFG_BUTTON, PU_NONE | PU_KEYBOARD | PU_MOUSEBUTTON1 | PU_POSITIONONITEM | PU_HCONSTRAIN | PU_VCONSTRAIN); break; } break; case WM_TIMER: if (setup.floating) WinSetWindowPos(WinQueryWindow(hwnd,QW_PARENT), HWND_TOP, 0, 0, 0, 0, SWP_ZORDER); break; case WM_COMMAND: { ULONG command = SHORT1FROMMP(mp1); pNextBarEvent actual = events.getItem(selectedButton - NHX_FIRST_BUTTON); switch(command) { case NHX_MAIN: closeFolders(TRUE); break; case NHX_INFOMNU: { pNextBarInfoDlg dlg = new NextBarInfoDlg; dlg->createDlg(); break; } case NHX_FLOAT: if (setup.floating) { setup.floating = FALSE; floatTimer.stop(); } else { setup.floating = TRUE; floatTimer.setNotify(hwnd).start(); } WinCheckMenuItem(menu, NHX_FLOAT, setup.floating); break; case NHX_QUIT: WinPostMsg(hwnd, WM_CLOSE, NULL, NULL); break; case NHX_MOVE: trackButtons(); break; case NHX_SENKRECHT: setNewStyle(OButtonBar::up2down); break; case NHX_WAAGERECHT: setNewStyle(OButtonBar::left2right); break; case NHX_NORMICONS: setup.large = FALSE; setNewStyle(setup.style); break; case NHX_LARGEICONS: setup.large = TRUE; setNewStyle(setup.style); break; case NHX_ADD_BUTTON: { pNextBarEvent aNew = new NextBarEvent; pNextBarDlg dlg = new NextBarDlg(aNew, NULL, TRUE); events.addAfter(actual, aNew); dlg->createDlg(); break; } case NHX_DEL_BUTTON: events.del(actual); resetToolBar(); break; case NHX_CFG_BUTTON: { pOGraphicsButton button = nxButtons->buttons.getItem(selectedButton - NHX_FIRST_BUTTON + 1); pNextBarDlg dlg = new NextBarDlg(actual, button, FALSE); dlg->createDlg(); break; } case NHX_HELP: helpRequest(PANEL_MAIN); break; default: if (actual) actual->startEvent(); break; } break; } case WM_SIZE: if (nxButtons) WinSetWindowPos(nxButtons->frame, HWND_TOP, 0, 0, (setup.style == OButtonBar::left2right) ? SHORT1FROMMP(mp2) : buttonSize, (setup.style == OButtonBar::left2right) ? buttonSize : SHORT2FROMMP(mp2), SWP_MOVE | SWP_SIZE); break; case WM_CLOSE: WinQueryWindowPos(frame, &setup.position); strcpy(setup.bubbleFont, nxButtons->bubbleHelpWin.pparms.Font); ini->write("NextHand", "NextInfo 1.5", &setup, sizeof(NextInfo)); ini->close(); hideFrame(); OApp::currentOApp->forceQuit(); break; default: return(FALSE); } return(TRUE); }
MRESULT EXPENTRY icqFrameWindow(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { switch(msg) { case WM_DDE_INITIATEACK: return (MRESULT) icqDDEInitiateAck(hwnd, (HWND)mp1, (PDDEINIT)mp2); case WM_DDE_DATA: DBGMessage("WM_DDE_DATA"); icqDDEData(hwnd, (PDDESTRUCT) mp2); break; case WM_CLOSE: DBGMessage("WM_CLOSE"); close(hwnd); break; case WM_CREATE: icqskin_cfgWindow(hwnd,ICQFRAME,0); break; case WM_DESTROY: destroy(hwnd); break; case WM_ERASEBACKGROUND: erase(hwnd,(HPS) mp1, (PRECTL) mp2); break; case WM_SIZE: resize(hwnd,SHORT1FROMMP(mp2),SHORT2FROMMP(mp2)); broadcast(hwnd,WMICQ_AUTOSIZE,0,0); break; case WM_PAINT: paint(hwnd); break; case WM_SETICON: WinSendMsg(WinQueryWindow(hwnd,QW_PARENT),msg,mp1,mp2); break; case WM_COMMAND: action(hwnd,SHORT1FROMMP(mp1), SHORT1FROMMP(mp2)); break; case WM_PRESPARAMCHANGED: ppchanged(hwnd,LONGFROMMP(mp1)); break; case WM_SETWINDOWPARAMS: return setparm(hwnd, PVOIDFROMMP(mp1), mp2); case WMICQ_SETNAME: // strncpy( ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->name, (const char *) mp1, 19); ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->name = (const char *) mp1; break; case WMICQ_SETICQHANDLE: DBGTracex(mp1); ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq = (HICQ) mp1; break; case WMICQ_GETICQHANDLE: return (MRESULT) ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq; case WMICQ_SETBUTTONTBL: setbuttons(hwnd,(const struct icqButtonTable *) mp1, (int) mp2); break; case WMICQ_QUERYPALLETE: return (MRESULT) ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->pal; case WMICQ_EVENT: // MP1 = type,code,user MP2 = parm event(hwnd,CHAR3FROMMP(mp1),CHAR4FROMMP(mp1),SHORT1FROMMP(mp1),(ULONG) mp2); break; case WMICQ_SELECTPAL: icqskin_loadPallete( (HPS) mp1, 0, ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->pal); break; case 0x041E: return WinDefWindowProc(hwnd, msg, mp1, mp2); case 0x041F: return WinDefWindowProc(hwnd, msg, mp1, mp2); case WM_BEGINDRAG: return beginDrag(hwnd, (POINTS *) &mp1); case WM_ENDDRAG: return endDrag(hwnd); case WM_TIMER: timer(hwnd); break; #ifdef SKINNED_GUI case WMICQ_QUERYBGIMAGE: return (MRESULT) ((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->bg; #else case WMICQ_QUERYBGIMAGE: return (MRESULT) NO_IMAGE; #endif case WM_OWNERPOSCHANGE: DBGMessage("WM_OWNERPOSCHANGE"); return WinDefWindowProc(hwnd,msg,mp1,mp2); case WM_MOUSEMOVE: if(WinQueryCapture(HWND_DESKTOP) == hwnd); saveMouse(hwnd,SHORT1FROMMP(mp1),SHORT2FROMMP(mp1)); return WinDefWindowProc(hwnd,msg,mp1,mp2); case WMICQ_CLEAR: clearSkin( (ICQFRAME *) WinQueryWindowPtr(hwnd,0)); break; case WMICQ_LOADSKIN: loadSkin(hwnd,(const char *) mp1, (SKINFILESECTION *) mp2); break; case WMICQ_SKINCHILDS: loadSkin4Childs(hwnd,(const char *) mp1, (SKINFILESECTION *) mp2); break; case WMICQ_RESTORE: restoreWindow(hwnd,(const char *) mp1,SHORT1FROMMP(mp2),SHORT2FROMMP(mp2)); break; case WMICQ_STORE: storeWindow(hwnd,(const char *) mp1); break; case WMICQ_CONFIGURE: configure(hwnd,(int) mp1); break; case WMICQ_SETMSGCHILD: createchild(hwnd, (const MSGCHILD *) mp1, SHORT1FROMMP(mp2)); break; case WMICQ_SKINELEMENT: skinElement(hwnd,(HWND) mp1, (const char **) mp2); break; case WMICQ_DRAWCONTENTS: break; case WMICQ_AUTOSIZE: autoSize(hwnd); break; case WMICQ_SIZEBUTTONS: return (MRESULT) sizeButtonBar(hwnd,SHORT1FROMMP(mp1),SHORT2FROMMP(mp1),(const USHORT *) mp2); case WMICQ_INVALIDATE: DBGMessage("WMICQ_INVALIDATE"); WinInvalidateRect(hwnd,NULL,TRUE); break; /*---[ SysTray ]--------------------------------------------*/ case WM_BUTTON2CLICK | 0x2000: icqShowPopupMenu(((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq, 0, ICQMNU_MODES, 0, 0); return (MRESULT) TRUE; case WM_BUTTON1CLICK | 0x2000: openMessage(((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq); return (MRESULT) TRUE; case WM_TRAYEXIT: // When tray exits/crashes, it posts WM_TRAYEXIT (0xCD20) to all tray windows. icqDisableSysTray(((ICQFRAME *) WinQueryWindowPtr(hwnd,0))->icq); return (MRESULT) TRUE; /*---[ Default window processing ]--------------------------*/ default: return WinDefWindowProc(hwnd,msg,mp1,mp2); } return 0; }