BOOL EXPENTRY HookInit(void) { if (!loaded) { /* find desktop anchor */ mainhab = WinQueryAnchorBlock(HWND_DESKTOP); /* setting hook */ if(DosQueryModuleHandle("numcomma", &hmDll)) return FALSE; return WinSetHook(mainhab, NULLHANDLE, HK_INPUT, (PFN)WinHookProc, hmDll); } return FALSE; }
// try loading each plugin module. // if opened sucessfully, call the plugin's CBZParseAttributes(hIni, keyValue, count) function // the plugin is responsible for writing data to the ini file. BOOL ApplyPreviewTheme(HWND hwndPreview, char themeFile[]) { HINI hIni; int count = 0; char szProfile[CCHMAXPATH + 1]; char szPluginBase[CCHMAXPATH]; // get profile name if (!PrfQueryProfileString(HINI_USERPROFILE, "CandyBarZ", "Profile", NULL, szProfile, CCHMAXPATH)) { PSUTErrorFunc(NULLHANDLE, "Error", "ApplyPreviewTheme", "Failed to Get Profile Filename", 0UL); return FALSE; } // get profile name if (!PrfQueryProfileString(HINI_USERPROFILE, "CandyBarZ", "BasePath", NULL, szPluginBase, CCHMAXPATH)) { PSUTErrorFunc(NULLHANDLE, "Error", "ApplyPreviewTheme", "Failed to Get BasePath", 0UL); return FALSE; } if ((hIni = PrfOpenProfile(WinQueryAnchorBlock(hwndPreview), szProfile)) == NULLHANDLE) { PSUTErrorFunc(NULLHANDLE, "Error", "ApplyPreviewTheme", "Failed to Open Profile", 0UL); return FALSE; } count = ApplyPreviewBlock(hwndPreview, themeFile, "TITLEBAR", szPluginBase, hIni, 0); count = ApplyPreviewBlock(hwndPreview, themeFile, "FRAME", szPluginBase, hIni, count); count = ApplyPreviewBlock(hwndPreview, themeFile, "FRAMEBRDR", szPluginBase, hIni, count); count = ApplyPreviewBlock(hwndPreview, themeFile, "PUSHBUTTON", szPluginBase, hIni, count); count = ApplyPreviewBlock(hwndPreview, themeFile, "RADIOBUTTON", szPluginBase, hIni, count); count = ApplyPreviewBlock(hwndPreview, themeFile, "CHECKBOX", szPluginBase, hIni, count); count = ApplyPreviewBlock(hwndPreview, themeFile, "MINMAX", szPluginBase, hIni, count); count = ApplyPreviewBlock(hwndPreview, themeFile, "MENU", szPluginBase, hIni, count); //insert here!!!! PrfCloseProfile(hIni); return TRUE; }
/* * Modified by Chris Wohlgemuth 2001 for use with CandyFolder */ BOOL winhAssertWarp4Notebook(HWND hwndDlg, USHORT usIdThreshold, // in: ID threshold ULONG ulDownUnits) // in: dialog units or 0 { BOOL brc = FALSE; POINTL ptl; HAB hab = WinQueryAnchorBlock(hwndDlg); BOOL fIsVisible = WinIsWindowVisible(hwndDlg); if (ulDownUnits) { ptl.x = 0; ptl.y = ulDownUnits; WinMapDlgPoints(hwndDlg, &ptl, 1, TRUE); } WinEnableWindowUpdate(hwndDlg, FALSE); if (cwQueryOSRelease()>=40) { HENUM henum = WinBeginEnumWindows(hwndDlg); HWND hwndItem; while ((hwndItem = WinGetNextWindow(henum))!=NULLHANDLE) { USHORT usId = WinQueryWindowUShort(hwndItem, QWS_ID); if (usId <= usIdThreshold) { // pushbutton to change: WinSetWindowBits(hwndItem, QWL_STYLE, BS_NOTEBOOKBUTTON, BS_NOTEBOOKBUTTON); brc = TRUE; } else // no pushbutton to change: move downwards // if desired if (ulDownUnits) { SWP swp; WinQueryWindowPos(hwndItem, &swp); WinSetWindowPos(hwndItem, 0, swp.x, swp.y - ptl.y, 0, 0, SWP_MOVE); } } WinEndEnumWindows(henum); } if (fIsVisible) WinShowWindow(hwndDlg, TRUE); return (brc); }
// tiles an image across preview window BOOL DrawImage(PSPAINT * pPaint, HBITMAP hbm, short sState, PLUGINSHARE* pPluginData) { SIZEL slHps; POINTL aptl[4]; HDC hdc; HPS hps; HAB hab = WinQueryAnchorBlock(pPaint->hwnd); // setup source bitmap hdc = DevOpenDC(hab, OD_MEMORY, "*", 0L, (PDEVOPENDATA) NULL, NULLHANDLE); // create source hps slHps.cx = pPluginData->ulCx/2; slHps.cy = pPluginData->ulCy/5; hps = GpiCreatePS(hab, hdc, &slHps, PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC); // set bmp into hps GpiSetBitmap(hps, hbm); // initial blt location aptl[0].x = pPaint->rectlWindow.xLeft; //aptl[0].y = pPaint->rectlWindow.yBottom; aptl[0].y = pPaint->rectlWindow.yBottom-1; aptl[1].x = pPaint->rectlWindow.xRight; //aptl[1].y = pPaint->rectlWindow.yTop; aptl[1].y = pPaint->rectlWindow.yTop-1; aptl[2].x = 0; aptl[2].y = 0; aptl[3].x = slHps.cx; aptl[3].y = slHps.cy; // blt GpiBitBlt(pPaint->hps, hps, 4L, aptl, ROP_SRCCOPY, BBO_IGNORE); // clean up GpiSetBitmap(hps, NULLHANDLE); GpiDestroyPS(hps); DevCloseDC(hdc); return (TRUE); }
/**************************************************************** DefaultOutlineFont: Set an outline font which is sizeable. ****************************************************************/ void SetOutlineFont(HPS hps, short height) {FONTMETRICS fm[80]; static FATTRS fat; static LONG cFonts=0; LONG ltemp=0; SIZEF size; int i; if (height<=2) return; if (cFonts==0) { GpiLoadFonts(WinQueryAnchorBlock(HWND_DESKTOP),"helv"); cFonts= GpiQueryFonts(hps,QF_PUBLIC|QF_PRIVATE,"Helv",<emp, sizeof(FONTMETRICS),(PFONTMETRICS)0); if (cFonts>sizeof(fm)/sizeof(FONTMETRICS)) cFonts=sizeof(fm)/sizeof(FONTMETRICS); GpiQueryFonts(hps,QF_PUBLIC|QF_PRIVATE,"Helv",&cFonts, sizeof(FONTMETRICS),fm); for (i=0; (!(fm[i].fsDefn&FM_DEFN_OUTLINE)) && //find outline and (!(fm[i].fsType&FM_TYPE_KERNING)) && //kerned if can (i<cFonts); i++); if (i==cFonts) for (i=0; (!(fm[i].fsDefn&FM_DEFN_OUTLINE))&& // Find outline atleast (i<cFonts); i++); if (i==cFonts) i=0; fat.usRecordLength =sizeof(FATTRS); fat.lMatch =fm[i].lMatch; fat.lMatch =0; fat.fsFontUse = FATTR_FONTUSE_OUTLINE; strcpy(fat.szFacename,fm[i].szFacename); } GpiCreateLogFont(hps,(PSTR8)0,1,&fat); GpiSetBackMix(hps,(LONG)BM_LEAVEALONE); GpiSetCharSet(hps,1); size.cx = MAKEFIXED(height,0); size.cy = MAKEFIXED(height,0); GpiSetCharBox(hps,&size); GpiSetTextAlignment(hps,TA_NORMAL_HORIZ,TA_BOTTOM); }
// Window - окно, которое надо проверить. BYTE WindowTypes_WindowIsPresent( HWND Window ) { // Проверяем, есть ли вообще такое окно. if( Window == NULLHANDLE ) return 0; if( !WinIsWindow( WinQueryAnchorBlock( Window ), Window ) ) return 0; // Проверяем, видимо ли оно. if( !WinIsWindowVisible( Window ) ) return 0; // Узнаем размер окна. RECT Rectangle = {0}; WinQueryWindowRect( Window, &Rectangle ); // Проверяем его. if( Rectangle.yTop <= 1 || Rectangle.xRight <= 1 ) return 0; // Возврат. return 1; }
void InitRecorder(PRECORDER_PARM prec) { SWP swp; CHAR szTemp[CCHMAXPATH]; ULONG dummy = errAEBadParm; if(prec->pmp->Profile.testrec_cx != 0) { WinSetWindowPos(prec->hwnd, HWND_TOP, prec->pmp->Profile.testrec_x, prec->pmp->Profile.testrec_y, prec->pmp->Profile.testrec_cx, prec->pmp->Profile.testrec_cy, SWP_MOVE | SWP_SIZE); WinSetWindowPos(prec->hwndStatus, HWND_TOP, prec->pmp->Profile.testrecStat_x, prec->pmp->Profile.testrecStat_y, prec->pmp->Profile.testrecStat_cx, prec->pmp->Profile.testrecStat_cy, SWP_MOVE | SWP_SIZE); } else { WinQueryTaskSizePos(WinQueryAnchorBlock(prec->hwnd),0,&swp); WinSetWindowPos(prec->hwnd, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy, SWP_MOVE ); } WinSetWindowULong(prec->hwnd, QWL_USER, (ULONG) prec ); prec->pmp->hwndRecordEvent = prec->hwnd; prec->hwndStatus = WinWindowFromID(prec->hwnd, IDD_ODRECSTATUS); WinSetWindowText(prec->hwndStatus, "idle"); prec->recording = FALSE; WinShowWindow(prec->hwnd,TRUE); }
extern MRESULT EXPENTRY EntryField_Processor ( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) { static PWINDOWPROC DefaultProcessor = 0 ; switch ( msg ) { case WM_CREATE: { CLASSINFO ClassInfo ; WinQueryClassInfo ( WinQueryAnchorBlock(hwnd), WC_ENTRYFIELD, &ClassInfo ) ; DefaultProcessor = ClassInfo.pfnWindowProc ; break; } case WM_SETFOCUS: { Sys_SendMessage( hwnd, EM_SETSEL, MPFROM2SHORT(0,9999), 0 ) ; break; } } /* endswitch */ return ( DefaultProcessor ? DefaultProcessor ( hwnd, msg, mp1, mp2 ) : 0 ) ; }
BOOL EXPENTRY PGPDLLInit(HWND hwnd) { hwndPGPClient = hwnd; /* save client hwnd so we can post msgs to it */ if (!Hooked) { /* create unique message ids (can't use WM_USER in hooks) */ hAtomTblSystem = WinQuerySystemAtomTable(); srand((UINT)hwnd); sprintf(Global.szFloatToTop,"PGPToolsFloatToTop%d",rand()); Global.wmu_FloatToTop = WinAddAtom(hAtomTblSystem, Global.szFloatToTop); if(DosQueryModuleHandle("pgptools", &hRessourceModule)) return FALSE; hab = WinQueryAnchorBlock(hwnd); WinSetHook(hab, hmqType, HK_SENDMSG, (PFN)PGPHookSendMsg, hRessourceModule); Hooked = TRUE; } return TRUE; }
SOM_Scope void SOMLINK WPSamFM_wpclsInitData (M_WPSamF *somSelf) { /* M_WPSamFData *somThis = M_WPSamFGetData (somSelf); */ M_WPSamFMethodDebug ("M_WPSamF","WPSamFM_wpclsInitData"); parent_wpclsInitData (somSelf); _clsQueryModuleHandle (somSelf); /* Get Class Title */ if (!WinLoadString (WinQueryAnchorBlock (HWND_DESKTOP), _clsQueryModuleHandle (somSelf), IDS_TITLE_WPSAMF, sizeof (szSamFClassTitle), szSamFClassTitle)) strcpy (szSamFClassTitle, _wpclsQueryTitle (somSelf)); M_WPSamFMethodDebug ("M_WPSamF","WPSamFM_wpclsInitData Ende"); return; }
SOM_Scope BOOL SOMLINK WPSamFolder_wpAddSettingsPages (WPSamF *somSelf, HWND hwndNotebook) { PAGEINFO pageinfo; CHAR szPageName[CCHMAXPGNAME]; /* WPSamFData *somThis = WPSamFGetData (somSelf); */ WPSamFMethodDebug ("WPSamF","WPSamFolder_wpAddSettingsPages"); memset ((PCH)&pageinfo,0,sizeof (PAGEINFO)); WinLoadString (WinQueryAnchorBlock (HWND_DESKTOP), hmod, IDS_WPSAMF_PG1, CCHMAXPGNAME, szPageName); pageinfo.cb = sizeof (PAGEINFO); pageinfo.hwndPage = NULLHANDLE; pageinfo.usPageStyleFlags = BKA_MAJOR; pageinfo.usPageInsertFlags = BKA_FIRST; pageinfo.usSettingsFlags = SETTINGS_PAGE_NUMBERS; pageinfo.pfnwp = CtxtDlgProc; pageinfo.resid = hmod; pageinfo.dlgid = IDD_CONTEXTMENU; pageinfo.pszName = szPageName; pageinfo.pCreateParams = somSelf; pageinfo.idDefaultHelpPanel = PANEL_CONTEXTMENU; pageinfo.pszHelpLibraryName = HELPFILE; if (!_wpInsertSettingsPage (somSelf, hwndNotebook, &pageinfo)) { DebugE (D_SOM, "_wpAddSettingsPages", "Failed to add Context_Menu settings page"); return (FALSE); } if (!parent_wpAddSettingsPages (somSelf, hwndNotebook)) { DebugE (D_SOM, "_wpAddSettingsPages", " Failed to add parent's settings pages"); return (FALSE); } return TRUE; }
//=========================================================================== // // Parameters -------------------------------------------------------------- // HWND hwnd : window handle // VOID // Return value ------------------------------------------------------------ // BOOL : TRUE/FALSE (success/error) // VOID //=========================================================================== static HWND initHelp(HWND hwnd) { HWND hHlp; CHAR buf[256]; HELPINIT hi; memset(&hi, 0, sizeof(HELPINIT)); hi.cb = sizeof(HELPINIT); hi.phtHelpTable = PHLPTBLFROMID(HLP_MAIN); hi.pszHelpWindowTitle = SZ_TITLE; hi.fShowPanelId = CMIC_HIDE_PANEL_ID; hi.pszHelpLibraryName = SZFILE_HLP; if (!(hHlp = WinCreateHelpInstance(WinQueryAnchorBlock(hwnd), &hi))) return NULLHANDLE; if (hi.ulReturnCode) { WinDestroyHelpInstance(hHlp); hHlp = NULLHANDLE; } else { WinAssociateHelpInstance(hHlp, hwnd); } /* endif */ return hHlp; }
static HWND GetDesktopHWND() { HAB hab; HWND hwnd; hab = WinQueryAnchorBlock(HWND_DESKTOP); if ( hab == NULLHANDLE ) { debug( "WinQueryAnchorBlock failed."); return FALSE; } hwnd = WinQueryDesktopWindow( hab, 0 ); if ( hwnd == NULLHANDLE ) { debug( "WinQueryDesktopWindow failed." ); return FALSE; } return hwnd; }
// Returns the top level parent of given window //-------------------------------------------------------------------------------- HWND GetTopLevelWindow( HWND hwnd ) { HWND parent; HWND hDesktopWindow; HAB hab; hab = WinQueryAnchorBlock( hwnd ); hDesktopWindow = WinQueryDesktopWindow( hab, NULLHANDLE ); while( TRUE ) { parent = WinQueryWindow( hwnd, QW_PARENT ); if ( parent == hDesktopWindow || parent == NULLHANDLE ) // this is a frame (top level) window break; hwnd = parent; } return hwnd; }
BOOL clbCreateProc(HWND hwnd, PCLBOXCDATA pclcd, PCREATESTRUCT pc, ULONG style) { PCLBOX pclb; HPS hps; // allocate structure for caching some control data if (!(pclb = (PCLBOX)malloc(sizeof(CLBOX)))) return FALSE; memset((PVOID)pclb, 0, sizeof(CLBOX)); // copy some data pclb->hab = WinQueryAnchorBlock(hwnd); pclb->hwnd = hwnd; pclb->fl = pc->flStyle; pclb->szl.cx = pc->cx; pclb->szl.cy = pc->cy; pclb->id = pc->id; pclb->hOwner = pc->hwndOwner; // Set color control if (!(hps = WinGetPS(hwnd))) goto error0; clbUpdColors(pclb, hps); if ((pclb->cyFont = stSizeFont(hps)) % 2) ++pclb->cyFont; WinReleasePS(hps); // Interprets controldata if (!clbSetCtlData(pclb, pclcd)) goto error0; if (clbSetText(pclb, pc->pszText, -1)) *pc->pszText = 0; // reset WC_STATIC style WinSetWindowBits(hwnd, QWL_STYLE, style, 0xffff); WinSetWindowPtr(hwnd, cbWCstc, (PVOID)pclb); if (pfnwpWCstc(hwnd, WM_CREATE, (MPARAM)pclcd, (MPARAM)pc)) goto error1; // If no CLBXS_CHECK style is set to checkon flags at 1 if (!(pclb->fl & CLBXS_CHECK)) pclb->is.chkon = 1; if (!clbChilds(pclb, pc)) goto error2; if (!(pclb->fl & WS_DISABLED)) pclb->is.enbl = 1; return TRUE; error2: WinDestroyWindow(hwnd); error1: if (pclb->psz) free(pclb->psz); error0: free(pclb); return FALSE; }
static MRESULT EXPENTRY woNewWindowProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) { switch( msg ) { case WM_ERASEBACKGROUND : { HPS hpsFrame = ( HPS )mp1; PRECTL prcl = ( PRECTL )mp2; GpiCreateLogColorTable( hpsFrame, 0, LCOLF_RGB, 0, 0, NULL ); WinFillRect( hpsFrame, prcl, m_hwvs.ulKeyColor); return FALSE; } case WM_SIZE : case WM_MOVE : // WinMapWindowPoints() sometimes does a wrong conversion on WM_MOVE. // For examples, minimizing and restoring a window of Qt4. // So we need to setup on WM_PAINT as well in order to work around // this problem. case WM_PAINT : { RECTL rcl; kvaAdjustDstRect( &m_hwvs.rctlSrcRect, &rcl ); WinMapWindowPoints( hwnd, HWND_DESKTOP, ( PPOINTL )&rcl, 2 ); if( !WinEqualRect( WinQueryAnchorBlock( hwnd ), &rcl, &m_hwvs.rctlDstRect )) { m_hwvs.rctlDstRect = rcl; m_pfnHWVIDEOSetup( &m_hwvs ); } break; // fall through to old window proc } } return m_pfnwpOld( hwnd, msg, mp1, mp2 ); }
//---------------------------------------------------------------------------- // NPP_DestroyStream: //---------------------------------------------------------------------------- NPError NP_LOADDS NPP_DestroyStream(NPP instance, NPStream *stream, NPError reason) { if ( instance == 0 ) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance* This = (PluginInstance*) instance->pdata; if ( reason == NPRES_DONE && This->bufMeta ) { // create metafile from buffer // 1-st, create empty metafile HAB hab=WinQueryAnchorBlock( This->hWnd ); DEVOPENSTRUC dop; dop.pszLogAddress = (PSZ) NULL; dop.pszDriverName = "DISPLAY"; HDC hdcMeta = DevOpenDC( hab, OD_METAFILE, /* Metafile device context */ "*", /* Ignores OS2.INI */ 2L, /* Uses first two fields */ (PDEVOPENDATA) &dop, /* Device information */ (HDC) NULLHANDLE ); /* Compatible device context */ SIZEL sizlPage={ 0, 0 }; HPS hpsMeta = GpiCreatePS( hab, hdcMeta, &sizlPage, PU_PELS | GPIA_ASSOC ); GpiAssociate( hpsMeta, (HDC)NULLHANDLE ); HMF hmf = DevCloseDC( hdcMeta ); GpiDestroyPS( hpsMeta ); // 2-nd, add real data GpiSetMetaFileBits( hmf, 0, This->offMeta, This->bufMeta ); SelectMetaFile( This, hmf ); } // delete buffer if ( This->bufMeta ) { free( This->bufMeta ); This->bufMeta=NULL; This->cbMeta=0; This->offMeta=0; } return NPERR_NO_ERROR; }
HBITMAP EXPENTRY sknLoadBitmap( HWND hwnd, PSZ pszFileName ) { HBITMAP ret = 0; SIZEL sizl = { 0, 0 }; /* use same page size as device */ DEVOPENSTRUC dop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L}; HAB hab = WinQueryAnchorBlock(hwnd); HDC hdc; HPS hps; hdc = DevOpenDC(hab, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&dop, NULLHANDLE); hps = GpiCreatePS(hab, hdc, &sizl, PU_PELS | GPIT_MICRO | GPIA_ASSOC); if(hps) { ret = LoadBitmap(hab,hdc,hps,pszFileName); GpiDestroyPS(hps); } DevCloseDC(hdc); return ret; }
// Frame_window - текстовое окно. VOID Clipper_EndVIOMarkingAndCopyText( HWND Frame_window ) { // Узнаем окно картинки. HWND SysMenu_window = WinWindowFromID( Frame_window, FID_SYSMENU ); // Если окна нет - возврат. if( !WinIsWindow( WinQueryAnchorBlock( SysMenu_window ), SysMenu_window ) ) return; // Если в меню есть строки для включения выделения: if( MenuItemIsPresent( SysMenu_window, SM_VIO_MARK ) && MenuItemIsPresent( SysMenu_window, SM_VIO_MOUSE ) ) { // Если обе строки меню для включения выделения выбраны: if( MenuItemIsChecked( SysMenu_window, SM_VIO_MARK ) && MenuItemIsChecked( SysMenu_window, SM_VIO_MOUSE ) ) { // Запоминаем выделенный текст. При этом строка для включения выделения должна перестать быть включенной. if( MenuItemIsPresent( SysMenu_window, SM_VIO_COPY ) ) WinSendMsg( Frame_window, WM_SYSCOMMAND, (MPARAM) SM_VIO_COPY, MPFROM2SHORT( CMDSRC_MENU, 0 ) ); // Выключаем выделение с помощью мыши. WinSendMsg( Frame_window, WM_SYSCOMMAND, (MPARAM) SM_VIO_MOUSE, MPFROM2SHORT( CMDSRC_MENU, 0 ) ); WinSendMsg( SysMenu_window, MM_SETITEMATTR, MPFROM2SHORT( SM_VIO_MOUSE, INCLUDE_SUBMENUS ), MPFROM2SHORT( MIA_CHECKED, 0 ) ); // Если строка меню для включения выделения все еще выбрана: if( MenuItemIsChecked( SysMenu_window, SM_VIO_MARK ) ) { // Выключаем выделение с помощью клавиатуры. WinSendMsg( Frame_window, WM_SYSCOMMAND, (MPARAM) SM_VIO_MARK, MPFROM2SHORT( CMDSRC_MENU, 0 ) ); WinSendMsg( SysMenu_window, MM_SETITEMATTR, MPFROM2SHORT( SM_VIO_MARK, INCLUDE_SUBMENUS ), MPFROM2SHORT( MIA_CHECKED, 0 ) ); } } } // Возврат. return; }
BOOL launchPad::lpBuildObjectList(char * chrFolderID) { WPObject* wpObject; char chrText[200]; ULONG ul; SOMClass *folderClass; WPFolder *wpFolder; char chrPath[CCHMAXPATH]; ULONG ulBufferSize; HINI hIni; char * memPtr; HOBJECT *hObjectArray; int a; LPObject *lpoTemp; WPObject * wpTempObject; /* Get toolbar folder */ if(somIsObj(wpParentFolder)) { folderClass=wpParentFolder->somGetClass(); if(somIsObj(folderClass)) wpFolder=(WPFolder*)((M_WPFolder*)folderClass)->wpclsQueryFolder(chrFolderID, FALSE); if(!somIsObj(wpFolder)) return FALSE; } /* Build ini name */ ulBufferSize=sizeof(chrPath); wpFolder->wpQueryRealName(chrPath, &ulBufferSize, TRUE); strcat(chrPath,"\\objects.ini");/* Ini-File containing the hobjects */ do{ /* Open the ini-file */ if((hIni=PrfOpenProfile(WinQueryAnchorBlock(HWND_DESKTOP),chrPath))==NULLHANDLE) break; if(!PrfQueryProfileSize(hIni,"objects","handles", &ulBufferSize)) break; if(ulBufferSize==0) break;/* No entries yet */ if((memPtr=(char*)malloc(ulBufferSize))==NULL) break; ulNumObjects=ulBufferSize/sizeof(HOBJECT); if(!PrfQueryProfileData(hIni,"objects","handles", memPtr, &ulBufferSize)){ free(memPtr); break; } hObjectArray=(HOBJECT*)memPtr; ulBufferSize=ulNumObjects; for(a=0;a<ulBufferSize && lpoTemp; a++) { wpTempObject=((M_WPObject*)folderClass)->wpclsQueryObject(hObjectArray[a]); if(somIsObj(wpTempObject)) { if((lpoTemp=new LPObject(wpTempObject->wpQueryIcon()))!=NULL) { lpoTemp->wpObject=wpTempObject; wpTempObject->wpLockObject(); lpoTemp->hObject=hObjectArray[a]; // lpoTemp->hPtr=wpTempObject->wpQueryIcon(); /* Title of the object */ strncpy(lpoTemp->chrName, wpTempObject->wpQueryTitle(),sizeof(lpoTemp->chrName)); lpoTemp->lpParent=this; lpoTemp->lpoNext=lpoObjectList; lpoObjectList=lpoTemp; } } else { ulNumObjects--; } }/* for */ free(hObjectArray); PrfCloseProfile(hIni); return TRUE; }while(TRUE); if(hIni) PrfCloseProfile(hIni); return FALSE; }
void FillMenu( HWND hwndMenu ) { char szPidPath[1024]; char szBuffer[1024]; char* pBuf; QSPTRREC* pRecHead; QSPREC* pApp; int numItems, iCounter; PVOID pBuffer; PSWBLOCK pSB; TASKDATA* data; SHORT id = ID_ITEM_FIRST; // Delete all current items numItems = LONGFROMMR( WinSendMsg( hwndMenu, MM_QUERYITEMCOUNT, 0, 0 )); while( numItems-- ) { MENUITEM mi; SHORT id = LONGFROMMR( WinSendMsg( hwndMenu, MM_ITEMIDFROMPOSITION, MPFROMSHORT(0), 0 )); if( WinSendMsg( hwndMenu, MM_QUERYITEM, MPFROM2SHORT( id, FALSE ), MPFROMP( &mi ))) { if( mi.hItem ) { data = (TASKDATA*)mi.hItem; free( data->szTitle ); free( data ); } } WinSendMsg( hwndMenu, MM_DELETEITEM, MPFROM2SHORT( id, FALSE ), 0 ); } if( bType ) { // Ctrl is pressed, get the processes in the system. pBuf = (char*)malloc( 0x8000 ); // Get processes DosQuerySysState( QS_PROCESS, 0, 0, 0, (char*)pBuf, 0x8000 ); // Point to first process pRecHead = (QSPTRREC*)pBuf; pApp = pRecHead->pProcRec; // While its a process record while( pApp->RecType == 1 ) { // Get module name for process memset( szPidPath, 0, _MAX_PATH ); DosQueryModuleName( pApp->hMte, 512, szPidPath ); if( strlen( szPidPath ) == 0 ) { // If no hit is the kernel if( pApp->type == 1 ) { sprintf( szPidPath, "VDM (%d)", pApp->pid ); } else { strcpy ( szPidPath, "*SYSINIT" ); } } else { // Else trim the path strcpy ( szBuffer, FileGetFileExt( szPidPath )); sprintf( szPidPath, "%s (%d)", szBuffer, pApp->pid ); } // add to menu data = (TASKDATA*)malloc( sizeof( TASKDATA )); data->szTitle = strdup( szPidPath ); data->hWindow = NULLHANDLE; data->pid = pApp->pid; switch( pApp->type ) { case 0: data->hIcon = ico_os2fs; break; case 1: data->hIcon = ico_dos; break; case 2: data->hIcon = ico_os2vio; break; case 3: data->hIcon = ico_pm; break; case 4: data->hIcon = ico_detach; break; default: data->hIcon = NULLHANDLE; break; } winhInsertMenuItem( hwndMenu, MIT_END, id++, szPidPath, MIS_OWNERDRAW, 0, data ); // get next record pApp=(QSPREC *)((pApp->pThrdRec) + pApp->cTCB); } free(pBuf); } else { // Get number of items in switchlist numItems = WinQuerySwitchList( WinQueryAnchorBlock( hwndMenu ), NULL, 0 ); // Get all items into buffer pBuffer = malloc(( numItems * sizeof(SWENTRY)) + sizeof(HSWITCH)); WinQuerySwitchList( WinQueryAnchorBlock(hwndMenu), (SWBLOCK*)pBuffer, (numItems * sizeof(SWENTRY)) + sizeof(HSWITCH)); pSB = (PSWBLOCK)(pBuffer); for( iCounter = 0; iCounter < numItems; iCounter++ ) { // Should be JUMPABLE and VISIBLE to show in list if( pSB->aswentry[iCounter].swctl.uchVisibility == SWL_VISIBLE ) { // Put in menu data = (TASKDATA*)malloc( sizeof( TASKDATA )); data->szTitle = strdup( pSB->aswentry[iCounter].swctl.szSwtitle ); data->hWindow = pSB->aswentry[iCounter].swctl.hwnd; data->pid = pSB->aswentry[iCounter].swctl.idProcess; CleanString( data->szTitle ); if( pSB->aswentry[iCounter].swctl.hwndIcon != NULLHANDLE ) { data->hIcon = pSB->aswentry[iCounter].swctl.hwndIcon; } else { data->hIcon = (HPOINTER)WinSendMsg( data->hWindow, WM_QUERYICON, 0, 0 ); } winhInsertMenuItem( hwndMenu, MIT_END, id++, pSB->aswentry[iCounter].swctl.szSwtitle, MIS_OWNERDRAW, 0, data ); } } free(pBuffer); } }
static MRESULT EXPENTRY LinkLabelProc( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) { linkData *ld = (linkData *)WinQueryWindowULong( hwnd, QWL_USER ); switch ( msg ) { case WM_PAINT: { FONTMETRICS fm; FATTRS fat; HPS hps; ULONG style; char *text = (char *)malloc( MAXTEXTLEN ); WinQueryWindowText( hwnd, MAXTEXTLEN, text); hps = WinBeginPaint( hwnd , 0L , 0L ); GpiQueryFontMetrics( hps , sizeof( FONTMETRICS ) , &fm ); memset( &fat , 0 , sizeof( fat ) ); fat.usRecordLength = sizeof( FATTRS ); fat.lMatch = fm.lMatch; fat.fsSelection = FATTR_SEL_UNDERSCORE; strcpy( fat.szFacename , fm.szFacename ); GpiDeleteSetId( hps , 1 ); GpiCreateLogFont( hps , 0 , 1 , &fat ); GpiSetCharSet( hps , 1 ); WinQueryWindowRect( hwnd , &ld->textRect ); style = WinQueryWindowULong( hwnd, QWL_STYLE ); style &= DT_LEFT|DT_CENTER|DT_RIGHT|DT_TOP|DT_VCENTER|DT_BOTTOM; WinDrawText( hps, -1, text, &ld->textRect, CLR_BLUE, SYSCLR_DIALOGBACKGROUND, style | DT_ERASERECT | DT_UNDERSCORE ); WinDrawText( hps, -1, text, &ld->textRect, CLR_BLUE, SYSCLR_DIALOGBACKGROUND, style | DT_QUERYEXTENT | DT_UNDERSCORE ); WinEndPaint( hps ); free( text ); } return (MRESULT)FALSE; case WM_MOUSEMOVE: { if ( handPtr != NULLHANDLE ) { POINTL ptl; ptl.x = SHORT1FROMMP( mp1 ); ptl.y = SHORT2FROMMP( mp1 ); if ( WinPtInRect( WinQueryAnchorBlock( hwnd ), &ld->textRect, &ptl) ) { WinSetPointer( HWND_DESKTOP, handPtr ); return (MRESULT)FALSE; } } } break; case WM_BUTTON1CLICK: { PROGDETAILS pd; char *text; POINTL ptl; if ( strcmp( browserExe, "" ) == 0 ) break; ptl.x = SHORT1FROMMP( mp1 ); ptl.y = SHORT2FROMMP( mp1 ); if ( !WinPtInRect( WinQueryAnchorBlock( hwnd ), &ld->textRect, &ptl) ) break; if ( ld->url == NULL ) { text = (char *)malloc( MAXTEXTLEN ); WinQueryWindowText( hwnd, MAXTEXTLEN, text); } else text = strdup( ld->url ); pd.Length = sizeof( PROGDETAILS ); pd.progt.progc = PROG_DEFAULT; pd.progt.fbVisible = SHE_VISIBLE; pd.pszTitle = NULL; pd.pszExecutable = browserExe; pd.pszParameters = NULL; pd.pszStartupDir = ( browserDir[0] == 0 ) ? NULL : browserDir; pd.pszIcon = NULL; pd.pszEnvironment = NULL; pd.swpInitial.fl = SWP_ACTIVATE; pd.swpInitial.cy = 0; pd.swpInitial.cx = 0; pd.swpInitial.y = 0; pd.swpInitial.x = 0; pd.swpInitial.hwndInsertBehind = HWND_TOP; pd.swpInitial.hwnd = NULLHANDLE; pd.swpInitial.ulReserved1 = 0; pd.swpInitial.ulReserved2 = 0; WinStartApp( NULLHANDLE , &pd , text , NULL , 0 ); free( text ); } break; case WM_DESTROY: ld->labelProc( hwnd, msg, mp1, mp2 ); if ( ld->url != NULL ) free( ld->url ); free( ld ); return (MRESULT)FALSE; } return ld->labelProc( hwnd, msg, mp1, mp2 ); }
MRESULT EXPENTRY EDImgWinProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { // alla creazione estrae dal testo del controllo il nome della libreria // e l'ID della risorsa da cui ricavare l'immagine switch (msg) { case WM_CREATE: { LHANDLE himg; // handle immagine PSZ psz; // per ricavare nome modulo e id risorsa ULONG idres; // id risorsa HLIB hlib; HAB hab; SIZEL szl; hab = WinQueryAnchorBlock(hwnd); // cerca primo tab lo cambia in 0 e carica lib if (!(psz = memchr((PVOID)((PCREATESTRUCT)mp2)->pszText, '\t', 9))) goto error0; *psz = 0; if (!(hlib = WinLoadLibrary(hab, ((PCREATESTRUCT)mp2)->pszText))) goto error0; // ottiene handle e dimensione immagine if (!(idres = strtoul(++psz, NULL, 10))) goto error1; if (((PCREATESTRUCT)mp2)->flStyle & (ESI_PTR | ESI_ICON | ESI_MINI)) { if (!(himg = WinLoadPointer(HWND_DESKTOP, hlib, idres))) goto error1; if (((PCREATESTRUCT)mp2)->flStyle & ESI_PTR) { // pointer szl.cx = WgetSysValue(SV_CXPOINTER); szl.cy = WgetSysValue(SV_CYPOINTER); } else if (((PCREATESTRUCT)mp2)->flStyle & ESI_ICON) { // icona szl.cx = WgetSysValue(SV_CXICON); szl.cy = WgetSysValue(SV_CYICON); } else { // minicona szl.cx = WgetSysValue(SV_CXICON) / 2; szl.cy = WgetSysValue(SV_CYICON) / 2; } // end if } else { // bitmap if (!(himg = WloadBitmap(hwnd, hlib, idres))) goto error1; if (!WqueryBitmapSize(himg, &szl)) goto error2; } // end if WinDeleteLibrary(hab, hlib); // memorizza handle immagine WinSetWindowULong(hwnd, cbWCstc, (ULONG)himg); *((PCREATESTRUCT)mp2)->pszText = 0; //break; WinSetWindowPos(hwnd, 0, 0, 0, szl.cx, szl.cy, SWP_SIZE|SWP_NOADJUST); break; error2: GpiDeleteBitmap(himg); error1: WinDeleteLibrary(hab, hlib); error0: return (MRESULT)TRUE; } // end case WM_CREATE case WM_ADJUSTWINDOWPOS: // default window processing return WinDefWindowProc(hwnd, msg, mp1, mp2); case WM_PAINT: { LHANDLE himg = (LHANDLE)WinQueryWindowULong(hwnd, cbWCstc); ULONG flStyle = WinQueryWindowULong(hwnd, QWL_STYLE); HPS hps; hps = WinBeginPaint(hwnd, NULLHANDLE, NULL); if (flStyle & (ESI_PTR | ESI_ICON | ESI_MINI)) { WinDrawPointer(hps, 0, 0, himg, (flStyle & ESI_MINI? DP_MINI: DP_NORMAL)); } else { POINTL ptl = {0,0}; WinDrawBitmap(hps, himg, NULL, &ptl, 0, 0, DBM_NORMAL); } // end if WinEndPaint(hps); return (MRESULT)FALSE; } // end case WM_PAINT // restituisce handle immagine corrente case SM_QUERYHANDLE: return (MPARAM)WinQueryWindowULong(hwnd, cbWCstc); // memorizza nuovo handle immagine, forza repaint e restituisce // handle precedente immagine case SM_SETHANDLE: { LHANDLE himg = (LHANDLE)WinQueryWindowULong(hwnd, cbWCstc); if (!WinSetWindowULong(hwnd, cbWCstc, (ULONG)mp1)) return NULLHANDLE; WinRefreshWin(hwnd); return (MRESULT)himg; } // end case SM_SETHANDLE case WM_MATCHMNEMONIC: return (MRESULT)FALSE; case WM_DESTROY: { LHANDLE himg = (LHANDLE)WinQueryWindowULong(hwnd, cbWCstc); if (WinQueryWindowULong(hwnd, QWL_STYLE) & (ESI_PTR | ESI_ICON | ESI_MINI)) { WinDestroyPointer(himg); } else { GpiDeleteBitmap(himg); } // end if } break; } /* endswitch */ return pfnwpWCstc(hwnd, msg, mp1, mp2); // default static controls processing }
// ******************************************************************************* // FUNCTION: GetBitmapFromTrack // // FUNCTION USE: Creates a bitmap from a rectangle structure // // DESCRIPTION: This function takes the rectangle structure that is created // as a result of the tracking operation and creates a bitmap // of that area. // // PARAMETERS: RECTL tracking rectangle // // RETURNS: HBITMAP bitmap handle // // INTERNALS: NONE // // HISTORY: // // ******************************************************************************* HBITMAP GetBitmapFromTrack (RECTL rclTrack) { HAB hab; HBITMAP hbmTrack; HDC hdcMemory; HPS hpsMemory; HPS hpsScreen; LONG lFormats[2]; POINTL aptl[3]; SIZEL sizl; BITMAPINFOHEADER2 bmp2; // -------------------------------------------------------------------------- // Get an anchor block handle // -------------------------------------------------------------------------- hab = WinQueryAnchorBlock(HWND_DESKTOP); // -------------------------------------------------------------------------- // Get a memory device context // -------------------------------------------------------------------------- hdcMemory = DevOpenDC (hab, OD_MEMORY, "*", 0L, NULL, NULLHANDLE) ; // -------------------------------------------------------------------------- // Set presentation space size // -------------------------------------------------------------------------- sizl.cx = sizl.cy = 0 ; // -------------------------------------------------------------------------- // Create a micro presentation space and associate it // -------------------------------------------------------------------------- hpsMemory = GpiCreatePS (hab, hdcMemory, &sizl, PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC); // -------------------------------------------------------------------------- // Call GpiQueryDeviceBitmapFormats to get the number of bit planes // -------------------------------------------------------------------------- GpiQueryDeviceBitmapFormats (hpsMemory, 2L, lFormats); // -------------------------------------------------------------------------- // Initialize the bitmap info header structure // -------------------------------------------------------------------------- memset(&bmp2, 0, sizeof(BITMAPINFOHEADER2)); // -------------------------------------------------------------------------- // Populate the bitmap info header structure // -------------------------------------------------------------------------- bmp2.cbFix = sizeof bmp2; bmp2.cx = (rclTrack.xRight - rclTrack.xLeft); bmp2.cy = (rclTrack.yTop - rclTrack.yBottom); bmp2.cPlanes = lFormats[0]; bmp2.cBitCount = lFormats[1]; // -------------------------------------------------------------------------- // Create a bitmap representing the tracking rectangle // -------------------------------------------------------------------------- hbmTrack = GpiCreateBitmap (hpsMemory, &bmp2, 0L, NULL, NULL); if (hbmTrack == GPI_ERROR) { return GPI_ERROR; } else { // -------------------------------------------------------------------------- // Set the bitmap into our memory presentation space. // -------------------------------------------------------------------------- GpiSetBitmap (hpsMemory, hbmTrack); hpsScreen = WinGetScreenPS (HWND_DESKTOP); aptl[0].x = 0; aptl[0].y = 0; aptl[1].x = bmp2.cx; aptl[1].y = bmp2.cy; aptl[2].x = rclTrack.xLeft; aptl[2].y = rclTrack.yBottom; WinLockVisRegions (HWND_DESKTOP, TRUE); // -------------------------------------------------------------------------- // Bit blit the contents of the source presentation space into our target // presentation space. This is how we copy the bitmap from the source to // the target. // -------------------------------------------------------------------------- GpiBitBlt (hpsMemory, // Target presentation space handle hpsScreen, // Source presentation space handle 3L, // Number of Points aptl, // Array of Points ROP_SRCCOPY, // Mixing function (source copy) BBO_IGNORE); // Options WinLockVisRegions (HWND_DESKTOP, FALSE); WinReleasePS (hpsScreen); } // -------------------------------------------------------------------------- // Free Graphics Engine Resources // -------------------------------------------------------------------------- GpiDestroyPS (hpsMemory); DevCloseDC (hdcMemory); // -------------------------------------------------------------------------- // Return bitmap handle // -------------------------------------------------------------------------- return hbmTrack; }
// ******************************************************************************* // FUNCTION: DuplicateBitmap // // FUNCTION USE: Duplicates a bitmap // // DESCRIPTION: Uses GpiBitBlt to make a copy of a bitmap by bit-bliting the // contents of the source PS containing the bitmap, to the target // presentation space. // // PARAMETERS: HBITMAP source bitmap handle to copy // // RETURNS: HBITMAP target bitmap handle // // HISTORY: // // ******************************************************************************* HBITMAP DuplicateBitmap (HBITMAP hbmSource) { HAB hab; HBITMAP hbmTarget; HDC hdcSource; HDC hdcTarget; HPS hpsSource; HPS hpsTarget; SIZEL sizl; POINTL aptl[3]; BOOL bError = FALSE; BITMAPINFOHEADER2 bmp2; // -------------------------------------------------------------------------- // Get an anchor block handle // -------------------------------------------------------------------------- hab = WinQueryAnchorBlock(HWND_DESKTOP); // -------------------------------------------------------------------------- // Create memory device context handles and presentation space handles // -------------------------------------------------------------------------- hdcSource = DevOpenDC (hab, OD_MEMORY, "*", 0L, NULL, NULLHANDLE); hdcTarget = DevOpenDC (hab, OD_MEMORY, "*", 0L, NULL, NULLHANDLE); // -------------------------------------------------------------------------- // Set presentation space size // -------------------------------------------------------------------------- sizl.cx = 0; sizl.cy = 0; // -------------------------------------------------------------------------- // Create our source presentation space // -------------------------------------------------------------------------- hpsSource = GpiCreatePS (hab, hdcSource, &sizl, PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC); // -------------------------------------------------------------------------- // Create our target presentation space // -------------------------------------------------------------------------- hpsTarget = GpiCreatePS (hab, hdcTarget, &sizl, PU_PELS | GPIF_DEFAULT | GPIT_MICRO | GPIA_ASSOC); // -------------------------------------------------------------------------- // Initialize the bitmap info header structure // -------------------------------------------------------------------------- // memset(&bmp2, NULL, sizeof(BITMAPINFOHEADER2)); // -------------------------------------------------------------------------- // Set the size of the structure // -------------------------------------------------------------------------- bmp2.cbFix = sizeof (BITMAPINFOHEADER2); // -------------------------------------------------------------------------- // Get the bitmap information header from the source bitmap // -------------------------------------------------------------------------- GpiQueryBitmapInfoHeader (hbmSource, &bmp2); // -------------------------------------------------------------------------- // Create our target bitmap using the bitmap information header from // our source bitmap. // -------------------------------------------------------------------------- hbmTarget = GpiCreateBitmap (hpsTarget, &bmp2, 0L, NULL, NULL); // -------------------------------------------------------------------------- // If everything is cool, set the bitmaps into our presentation spaces. // -------------------------------------------------------------------------- if (hbmTarget != GPI_ERROR) { GpiSetBitmap (hpsSource, hbmSource); GpiSetBitmap (hpsTarget, hbmTarget); aptl[0].x = 0; aptl[0].y = 0; aptl[1].x = bmp2.cx; aptl[1].y = bmp2.cy; aptl[2].x = 0; aptl[2].y = 0; // -------------------------------------------------------------------------- // Bit blit the contents of the source presentation space into our target // presentation space. This is how we copy the bitmap from the source to // the target. // -------------------------------------------------------------------------- bError = GpiBitBlt (hpsTarget, // Target presentation space handle hpsSource, // Source presentation space handle 3L, // Number of Points aptl, // Array of Points ROP_SRCCOPY, // Mixing function (source copy) BBO_IGNORE); // Options // -------------------------------------------------------------------------- // If we get an error copying from our source PS to our target PS // set the error flag to TRUE so that we can return GPI_ERROR back // to the caller. // -------------------------------------------------------------------------- if (bError == GPI_ERROR) { bError = TRUE; } // -------------------------------------------------------------------------- // If we got a value back from GpiBitBlt reset our error flag since // bError would be TRUE. // -------------------------------------------------------------------------- else { bError = FALSE; } } // -------------------------------------------------------------------------- // If we get an error creating the bitmap set the bError flag to TRUE // so we can return GPI_ERROR telling the caller that the function failed. // -------------------------------------------------------------------------- else { bError = TRUE; } // -------------------------------------------------------------------------- // Regardless of what happens, we will free all of our graphics engine // resources by destroying our presentation spaces and device context // handles. // -------------------------------------------------------------------------- GpiDestroyPS (hpsSource); GpiDestroyPS (hpsTarget); DevCloseDC (hdcSource); DevCloseDC (hdcTarget); // -------------------------------------------------------------------------- // If we get an error trying to duplicate the bitmap, return GPI_ERROR. // -------------------------------------------------------------------------- if (bError) { return GPI_ERROR; } // -------------------------------------------------------------------------- // If everthing worked like a champ, return the bitmap handle. // -------------------------------------------------------------------------- else { return hbmTarget; } }
void M_CWMenuFolder::wpclsInitData() { somId mySomId; CLASSINFO ci; /* call parent */ if((mySomId=somIdFromString("wpclsInitData"))!=NULLHANDLE) { ((somTD_M_WPObject_wpclsInitData) somParentNumResolve(__ClassObject->somGetPClsMtabs(), 1, __ClassObject-> somGetMethodToken(mySomId)) )(this); SOMFree(mySomId); } else M_WPFolder::wpclsInitData(); if(!fInitDone) { /* Get install dir */ queryInstallDir(chrInstallPath, sizeof(chrInstallPath)); /* INI file path */ queryIniFilePath(chrWPSWizIni, sizeof(chrWPSWizIni)); /* Register new button class */ if(WinQueryClassInfo(WinQueryAnchorBlock(HWND_DESKTOP), (PSZ) WC_BUTTON, &ci)) { g_ulButtonDataOffset=ci.cbWindowData; g_pfnwpOrgButtonProc=ci.pfnWindowProc; ulQWP_WIZBUTTONDATA=g_ulButtonDataOffset; if (WinRegisterClass(WinQueryAnchorBlock(HWND_DESKTOP), (PSZ) WC_WIZBUTTON, fnwpWizButtonProc, // ci.pfnWindowProc, ci.flClassStyle&~CS_PUBLIC, ci.cbWindowData + WIZBUTTON_DATASIZE)) { /* */ } } if(WinQueryClassInfo(WinQueryAnchorBlock(HWND_DESKTOP), WC_STATIC, &ci)) { g_haveFlyOverClient=TRUE; /* Blended flyover window is only available if CWFolder is installed. */ } /* Register percentbar class */ if(!percentRegisterBarClass()) SysWriteToTrapLog("Can't register percent bar window class.\n"); /* Register REXX functions */ RexxRegisterFunctionExe("WPSWizCallWPSFunc", (PFN)rxCallWPSFunc); RexxRegisterFunctionExe("WPSWizCallWinFunc", (PFN)rxCallPMFunc); RexxRegisterFunctionExe("WPSWizCallFunc", (PFN)rxCallCWWPSFunc); RexxRegisterFunctionExe("WPSWizCallWPSClsFunc", (PFN)rxCallWPSClassFunc); RexxRegisterFunctionExe("DevGetHash", (PFN)rxGetHash); /* Register the gadget REXX function */ RexxRegisterFunctionExe("WPSWizGadgetFunc", (PFN)rxCallCWWPSFunc); RexxRegisterExitExe("WIZREXX", (PFN)cwRexxExitHandler, NULLHANDLE); /* Load Rexx error dialog */ if(!g_hwndRexxError) { somTD_M_CWObject_wizclsSetRexxErrorWindowHWND methodPtr; g_hwndRexxError=WinLoadDlg(HWND_DESKTOP, HWND_DESKTOP, pfnwpRexxErrorProc, queryModuleHandle(), IDDLG_REXXERROR, NULLHANDLE); TRY_LOUD(ERROR_HWND) { /* Make sure M_CWObject class is installed and replaces the normal M_WPObject class. If yes, the M_CWMenuFolder class has a new static method "wizclsSetRexxErrorWindowHWND". */ methodPtr=(somTD_M_CWObject_wizclsSetRexxErrorWindowHWND) somResolveByName( this, "wizclsSetRexxErrorWindowHWND"); // SysWriteToTrapLog("%s: %x\n", __FUNCTION__, methodPtr); if(methodPtr) methodPtr(this, g_hwndRexxError); } CATCH(ERROR_HWND) { SysWriteToTrapLog("%s: Error while setting REXX error window HWND.\n", __FUNCTION__); } END_CATCH; }
MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { static BOOL fContinueCalc = FALSE ; static HAB hab ; static HWND hwndMenu ; static INT iStatus = STATUS_READY ; static INT iCurrentRep = IDM_10 ; static LONG lCalcRep, lRepAmts [] = { 10, 100, 1000, 10000, 100000 } ; static ULONG ulElapsedTime ; double A ; LONG lRep ; QMSG qmsg ; switch (msg) { case WM_CREATE: hab = WinQueryAnchorBlock (hwnd) ; hwndMenu = WinWindowFromID ( WinQueryWindow (hwnd, QW_PARENT), FID_MENU) ; return 0 ; case WM_COMMAND: switch (COMMANDMSG(&msg)->cmd) { case IDM_10: case IDM_100: case IDM_1000: case IDM_10000: case IDM_100000: WinCheckMenuItem (hwndMenu, iCurrentRep, FALSE) ; iCurrentRep = COMMANDMSG(&msg)->cmd ; WinCheckMenuItem (hwndMenu, iCurrentRep, TRUE) ; return 0 ; case IDM_START: WinEnableMenuItem (hwndMenu, IDM_START, FALSE) ; WinEnableMenuItem (hwndMenu, IDM_ABORT, TRUE) ; iStatus = STATUS_WORKING ; WinInvalidateRect (hwnd, NULL, FALSE) ; lCalcRep = lRepAmts [iCurrentRep - IDM_10] ; fContinueCalc = TRUE ; ulElapsedTime = WinGetCurrentTime (hab) ; qmsg.msg = WM_NULL ; for (A = 1.0, lRep = 0 ; lRep < lCalcRep ; lRep++) { A = Savage (A) ; while (WinPeekMsg (hab, &qmsg, NULLHANDLE, 0, 0, PM_NOREMOVE)) { if (qmsg.msg == WM_QUIT) break ; WinGetMsg (hab, &qmsg, NULLHANDLE, 0, 0) ; WinDispatchMsg (hab, &qmsg) ; if (!fContinueCalc) break ; } if (!fContinueCalc || qmsg.msg == WM_QUIT) break ; } ulElapsedTime = WinGetCurrentTime (hab) - ulElapsedTime ; if (!fContinueCalc || qmsg.msg == WM_QUIT) iStatus = STATUS_READY ; else iStatus = STATUS_DONE ; WinInvalidateRect (hwnd, NULL, FALSE) ; WinEnableMenuItem (hwndMenu, IDM_START, TRUE) ; WinEnableMenuItem (hwndMenu, IDM_ABORT, FALSE) ; return 0 ; case IDM_ABORT: fContinueCalc = FALSE ; return 0 ; } break ; case WM_PAINT: PaintWindow (hwnd, iStatus, lCalcRep, ulElapsedTime) ; return 0 ; } return WinDefWindowProc (hwnd, msg, mp1, mp2) ; }
static MRESULT EXPENTRY launchPadWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { WPFolder* thisPtr; launchPad * lp; LPObject *lpo; static USHORT id=0;//Initialisation new in V1.00a switch(msg) { #if 0 case DM_ENDCONVERSATION: case DM_DRAGFILECOMPLETE: case DM_DROPNOTIFY: case DM_FILERENDERED: case DM_RENDERCOMPLETE: break; return (MRESULT)FALSE; case WM_ENDDRAG: break; return (MRESULT)TRUE; #endif case WM_PAINT: { RECTL rcl; launchPad * lp; HPS hps=WinBeginPaint(hwnd,NULLHANDLE, &rcl); WinFillRect(hps, &rcl, SYSCLR_DIALOGBACKGROUND); lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER); if(lp) { if(lp->lpQueryNumObjects()==0) { WinQueryWindowRect(hwnd,&rcl); WinDrawBorder(hps,&rcl,1,1,SYSCLR_WINDOWFRAME,SYSCLR_DIALOGBACKGROUND, DB_STANDARD); } } WinEndPaint(hps); return (MRESULT) 0; } case DM_DRAGOVER: return handleDragOver(hwnd, mp1, mp2); case DM_DROP: { ULONG ulCount; ULONG ulNumberOfObjects; PDRAGITEM pDragItem; SOMClass *folderClass; WPObject * wpObject; PDRAGINFO pDragInfo; TRY_LOUD(LP_FRAMEDROP) { /* A new object dropped on the launchpad */ pDragInfo=(PDRAGINFO)mp1; if(DrgAccessDraginfo(pDragInfo)) { /* Get number of items */ ulNumberOfObjects = DrgQueryDragitemCount( pDragInfo); if(ulNumberOfObjects>1){ /* Free the draginfo */ DrgDeleteDraginfoStrHandles(pDragInfo); DrgFreeDraginfo(pDragInfo); } else { ulCount=0; pDragItem=DrgQueryDragitemPtr( pDragInfo, ulCount); wpObject=(WPObject*)OBJECT_FROM_PREC(DrgQueryDragitemPtr( pDragInfo, ulCount)->ulItemID); lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER); if(lp) { if(somIsObj(wpObject)) { POINTL ptl; int numB; SWP swp; WinQueryWindowPos(hwnd,&swp); ptl.x=pDragInfo->xDrop; ptl.y=pDragInfo->yDrop; /* Pos in window coords */ WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl, 1); numB=(ptl.x-xButtonOffset)/(swp.cy+xButtonDelta); numB=((ptl.x-numB*swp.cy) > swp.cy/2 ? numB+1: numB); /* Do a link */ lp->lpAddButton(wpObject, numB); handleDragLeave(hwnd, mp1, mp2); } } DrgDeleteDraginfoStrHandles(pDragInfo); DrgFreeDraginfo(pDragInfo); } } handleDragLeave(hwnd, mp1, mp2); } CATCH(LP_FRAMEDROP) { } END_CATCH; break; } case DM_DRAGLEAVE: return handleDragLeave(hwnd, mp1, mp2); break; case WM_COMMAND: if(SHORT1FROMMP(mp2)==CMDSRC_PUSHBUTTON) { /* It's a push button */ lpo=(LPObject*)WinQueryWindowULong(WinWindowFromID(hwnd,SHORT1FROMMP(mp1)),QWL_USER); if(lpo) { if(somIsObj(lpo->wpObject)) lpo->wpObject->wpViewObject(NULLHANDLE, OPEN_DEFAULT,0); } } return (MRESULT)FALSE; /***********************************************/ /* Stuff for fly over help */ case WM_MOUSEMOVE: launchPad * lp; lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER); if(lp) { if(lp->lpQueryNumObjects()!=0) { break; } } #if 0 tempID=WinQueryWindowUShort(hwnd,QWS_ID);/* get the id of the window under the pointer */ if(id!=tempID) { // New Button? WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,tempID,(ULONG)iTBFlyOverDelay); // New timer for delay id=tempID; // Save ID } else { if(!hwndBubbleWindow) WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,tempID,(ULONG)iTBFlyOverDelay); // New timer for delay } #endif if(!hwndBubbleWindow) WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, 2,(ULONG)iTBFlyOverDelay); // New timer for delay break; case WM_DESTROY: WinStopTimer(WinQueryAnchorBlock(hwnd),hwnd,1);//Stop timer if running if(hwndBubbleWindow) WinDestroyWindow(hwndBubbleWindow);/* close the bubblewindow */ hwndBubbleWindow=0; /* Stop delay timer if running */ WinStopTimer(WinQueryAnchorBlock(hwnd),hwnd, 2); break; case WM_NEWBUBBLE: ULONG bubbleEnabled; HWND hwndStore; POINTL ptl; RECTL rclWork; LONG ulWinTextLen; POINTL aptlPoints[TXTBOX_COUNT]; LONG deltaX,deltaY; HPS hps; RECTL rcl; /* we have to build a new information window */ if(hwndBubbleWindow){// if(){...} new in V1.00a WinDestroyWindow(hwndBubbleWindow);/* close the bubblewindow */ hwndBubbleWindow=NULL; } // Query the pointer position WinQueryPointerPos(HWND_DESKTOP,&ptl); WinMapWindowPoints(HWND_DESKTOP,hwnd,&ptl,1); WinQueryWindowRect(hwnd,&rclWork); if(!hwndBubbleWindow && WinPtInRect(WinQueryAnchorBlock(hwnd),&rclWork,&ptl) && bTBFlyOverEnabled) { static HWND hwndBubbleClient; ULONG style=FCF_BORDER|FCF_NOBYTEALIGN; char winText[255]; /* Get window text for size calculating */ lp=(launchPad*)WinQueryWindowULong(hwnd,QWL_USER); if(lp) { strncpy(winText, lp->lpQueryFlyOverText(), sizeof(winText)); winText[sizeof(winText)-1]=0; } ulWinTextLen=(LONG)strlen(winText); // Query text length /* Delete 'Returns' in object title */ char *pBuchst; char *pRest; pRest=winText; while((pBuchst=strchr(pRest,13))!=NULL) { *pBuchst=' '; pBuchst++; if(*pBuchst==10) *pBuchst=' '; pRest=pBuchst; } /* Create help window */ hwndBubbleWindow=WinCreateStdWindow(HWND_DESKTOP, 0, &style, WC_STATIC, "", SS_TEXT|DT_CENTER|DT_VCENTER, NULLHANDLE, 400, &hwndBubbleClient); hwndShadow=WinCreateWindow(HWND_DESKTOP, WC_STATIC, "", SS_TEXT|DT_CENTER|DT_VCENTER, 0, 0, 0, 0, hwndBubbleWindow, hwndBubbleWindow, 401, NULLHANDLE, NULLHANDLE); oldProc=WinSubclassWindow(hwndShadow, shadowProc); // Set the font for the help WinSetPresParam(hwndBubbleClient,PP_FONTNAMESIZE, sizeof(chrTBFlyFontName), chrTBFlyFontName); /* Calculate text size in pixel */ hps=WinBeginPaint(hwndBubbleClient,(HPS)NULL,(PRECTL)NULL); GpiQueryTextBox(hps,ulWinTextLen,winText,TXTBOX_COUNT,aptlPoints); WinEndPaint(hps); /* Set colors */ WinSetPresParam(hwndBubbleClient, PP_BACKGROUNDCOLOR,sizeof(rgbTBFlyBackground) , &rgbTBFlyBackground ); WinSetPresParam(hwndBubbleClient, PP_FOREGROUNDCOLOR,sizeof(rgbTBFlyForeground) , &rgbTBFlyForeground ); /* Calculate bubble positon and show bubble */ WinQueryPointerPos(HWND_DESKTOP,&ptl);//Query pointer position in the desktop window WinQueryWindowRect(HWND_DESKTOP,&rcl);//Query desktop size aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x+7+xVal+ptl.x > rcl.xRight ? deltaX=-aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x-xVal-xVal-7 : deltaX=0 ; aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y+2+yVal+ptl.y > rcl.yTop ? deltaY=-aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y-2*yVal-7 : deltaY=0 ; WinSetWindowPos(hwndBubbleWindow, HWND_TOP, ptl.x+xVal+deltaX,ptl.y+yVal+deltaY, aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x+8, aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y+2, SWP_ZORDER|SWP_SIZE|SWP_MOVE|SWP_SHOW); WinSetWindowPos(hwndShadow, hwndBubbleWindow, ptl.x+xVal+deltaX+5 ,ptl.y+yVal+deltaY-5, aptlPoints[TXTBOX_BOTTOMRIGHT].x-aptlPoints[TXTBOX_BOTTOMLEFT].x+8, aptlPoints[TXTBOX_TOPLEFT].y-aptlPoints[TXTBOX_BOTTOMLEFT].y+2, SWP_ZORDER|SWP_SIZE|SWP_MOVE|SWP_SHOW); /* Set bubble text */ WinSetWindowText(hwndBubbleClient,winText); WinStartTimer(WinQueryAnchorBlock(hwnd),hwnd,1,35); } // end if(!hwndBubbleWindow) break; case WM_TIMER: switch (SHORT1FROMMP(mp1)) { case 1: //Intervall timer { POINTL ptl; RECTL rclWork; /* Test pointer position */ WinQueryPointerPos(HWND_DESKTOP, &ptl); WinMapWindowPoints(HWND_DESKTOP, hwnd,&ptl, 1); WinQueryWindowRect(hwnd, &rclWork); if(!WinPtInRect(WinQueryAnchorBlock(hwnd),&rclWork,&ptl)) { // Window has changed WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, 1); // stop the running timer if(hwndBubbleWindow) WinDestroyWindow(hwndBubbleWindow);/* close the bubblewindow */ hwndBubbleWindow=0; id=0; } break; } case 2:// delay over {//our own timer. POINTL ptl; RECTL rclWork; WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, 2);//Stop the delay timer /* Check the pointer position */ WinQueryPointerPos(HWND_DESKTOP,&ptl); WinMapWindowPoints(HWND_DESKTOP,hwnd,&ptl,1); WinQueryWindowRect(hwnd,&rclWork); if(WinPtInRect(WinQueryAnchorBlock(hwnd),&rclWork,&ptl)) WinPostMsg(hwnd,WM_NEWBUBBLE,NULL,NULL);//Request a help window return (MRESULT)FALSE; } default: break; } break; default: break; } return pfnwpOldLPProc(hwnd, msg, mp1, mp2); }
BOOL launchPad::lpSaveObjectList() { SOMClass *folderClass; WPFolder *wpFolder; char chrPath[CCHMAXPATH]; ULONG ulBufferSize; HINI hIni; char * memPtr; HOBJECT *hObject; HOBJECT hObject2; int a; LPObject *lpoTemp; /* First check the config folder */ if((hObject2=WinQueryObject(chrConfigID))==NULLHANDLE) { /* Toolbar folder lost recreate it */ if(!checkFileExists(chrConfigTarget)) return FALSE; /* No install dir defined */ sprintf(chrPath,"OBJECTID=%s",chrConfigID); if((hObject2=WinCreateObject("WPFolder", chrConfigID, chrPath,chrConfigTarget,CO_FAILIFEXISTS))==NULLHANDLE) return FALSE; /* Can't create new toolbar folder */ } /* Get toolbar folder */ if(somIsObj(wpParentFolder)) { folderClass=wpParentFolder->somGetClass(); if(somIsObj(folderClass)) wpFolder=(WPFolder*)((M_WPFolder*)folderClass)->wpclsQueryFolder(chrConfigID, FALSE); } ulBufferSize=sizeof(chrPath); wpFolder->wpQueryRealName(chrPath, &ulBufferSize, TRUE); strcat(chrPath,"\\objects.ini");/* Ini-File containing the hobjects */ // WinMessageBox(HWND_DESKTOP, HWND_DESKTOP, chrPath, "~launchPad", 123, MB_OK| MB_MOVEABLE); do{ /* Open the ini-file */ if((hIni=PrfOpenProfile(WinQueryAnchorBlock(HWND_DESKTOP),chrPath))==NULLHANDLE) break; if((memPtr=(char*)malloc(ulNumObjects*sizeof(HOBJECT)))==NULL) break; hObject=(HOBJECT*)memPtr; lpoTemp=lpoObjectList; for(a=ulNumObjects;a>0 && lpoTemp; a--) { hObject[a-1]=lpoTemp->hObject; lpoTemp=lpoTemp->lpoNext; } if(!PrfWriteProfileData(hIni,"objects","handles", hObject, ulNumObjects*sizeof(HOBJECT))) { free(hObject); break; } free(hObject); PrfCloseProfile(hIni); return TRUE; }while(TRUE); if(hIni) PrfCloseProfile(hIni); return FALSE; }
MRESULT EXPENTRY fnSaverWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { SWP swpDlg, swpParent; HWND hwndDlg; int rc; switch( msg ) { case WM_SUBCLASS_INIT: case WM_CREATE: { RECTL rclRect; // Any initialization of the window and variables should come here. // the timer for the moving text ulAnimationTimerID = WinStartTimer(WinQueryAnchorBlock(hwnd), hwnd, ANIMATION_TIMER_ID, 20); // setup the initial coordinates for the scrolling text WinQueryWindowRect(hwnd, &rclRect); textX = rclRect.xRight; textY = rclRect.yTop/2; // Hide mouse pointer, if we're in real screen-saving mode! if (!bOnlyPreviewMode) WinShowPointer(HWND_DESKTOP, FALSE); // Initialize WMCHAR record internal_InitWMCHARRecord(); break; } case WM_CHAR: if (!bOnlyPreviewMode) internal_SaveWMCHAREventToRecord(mp1, mp2); break; case WM_ASKPASSWORD: { // Get parameters char *pchPwdBuff = (char *) mp1; int iPwdBuffSize = (int) mp2; // Show mouse pointer, if we're screensaving. if (!bOnlyPreviewMode) WinShowPointer(HWND_DESKTOP, TRUE); hwndDlg = WinLoadDlg(hwnd, hwnd, fnAutoHiderDlgProc, hmodOurDLLHandle, DLG_PASSWORDPROTECTION, NULL); if (!hwndDlg) { // Could not load dialog window resources! if (!bOnlyPreviewMode) WinShowPointer(HWND_DESKTOP, FALSE); return (MRESULT) SSMODULE_ERROR_INTERNALERROR; } // Ok, dialog window loaded! // Now set its texts (NLS) internal_SetPageFont(hwndDlg); internal_SetPwdProtWindowText(hwndDlg); // Resize the window so text will fit! internal_ArrangePwdProtWindowControls(hwndDlg); // Initialize control(s)! WinSendDlgItemMsg(hwndDlg, EF_PASSWORD, EM_SETTEXTLIMIT, (MPARAM) (iPwdBuffSize-1), (MPARAM) 0); WinSetDlgItemText(hwndDlg, EF_PASSWORD, ""); // Center dialog in screen if (WinQueryWindowPos(hwndDlg, &swpDlg)) if (WinQueryWindowPos(hwnd, &swpParent)) { // Center dialog box within the screen int ix, iy; ix = swpParent.x + (swpParent.cx - swpDlg.cx)/2; iy = swpParent.y + (swpParent.cy - swpDlg.cy)/2; WinSetWindowPos(hwndDlg, HWND_TOP, ix, iy, 0, 0, SWP_MOVE); } WinSetWindowPos(hwndDlg, HWND_TOP, 0, 0, 0, 0, SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER); // Re-send WM_CHAR messages if needed if (bFirstKeyGoesToPwdWindow) internal_ReplayWMCHARRecord(); // Process the dialog! rc = WinProcessDlg(hwndDlg); if (rc!=PB_OK) { // The user pressed cancel! rc = SSMODULE_ERROR_USERPRESSEDCANCEL; } else { // The user pressed OK! // Get the entered password WinQueryDlgItemText(hwndDlg, EF_PASSWORD, iPwdBuffSize, pchPwdBuff); rc = SSMODULE_NOERROR; } // Destroy window WinDestroyWindow(hwndDlg); // Hide mouse pointer again, if we're screensaving. if (!bOnlyPreviewMode) WinShowPointer(HWND_DESKTOP, FALSE); return (MRESULT) rc; } case WM_SHOWWRONGPASSWORD: // Show mouse pointer, if we're screensaving. if (!bOnlyPreviewMode) WinShowPointer(HWND_DESKTOP, TRUE); hwndDlg = WinLoadDlg(hwnd, hwnd, fnAutoHiderDlgProc, hmodOurDLLHandle, DLG_WRONGPASSWORD, NULL); if (!hwndDlg) { // Could not load dialog window resources! if (!bOnlyPreviewMode) WinShowPointer(HWND_DESKTOP, FALSE); return (MRESULT) SSMODULE_ERROR_INTERNALERROR; } // Ok, dialog window loaded! // Now set its texts (NLS) internal_SetPageFont(hwndDlg); internal_SetWrongPwdWindowText(hwndDlg); // Resize the window so text will fit! internal_ArrangeWrongPwdWindowControls(hwndDlg); // Center dialog in screen if (WinQueryWindowPos(hwndDlg, &swpDlg)) if (WinQueryWindowPos(hwnd, &swpParent)) { // Center dialog box within the screen int ix, iy; ix = swpParent.x + (swpParent.cx - swpDlg.cx)/2; iy = swpParent.y + (swpParent.cy - swpDlg.cy)/2; WinSetWindowPos(hwndDlg, HWND_TOP, ix, iy, 0, 0, SWP_MOVE); } WinSetWindowPos(hwndDlg, HWND_TOP, 0, 0, 0, 0, SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER); // Process the dialog! rc = WinProcessDlg(hwndDlg); // Destroy window WinDestroyWindow(hwndDlg); // Hide mouse pointer again, if we're screensaving. if (!bOnlyPreviewMode) WinShowPointer(HWND_DESKTOP, FALSE); return (MRESULT) SSMODULE_NOERROR; case WM_SUBCLASS_UNINIT: case WM_DESTROY: // All kinds of cleanup (the opposite of everything done in WM_CREATE) // should come here. WinStopTimer(WinQueryAnchorBlock(hwnd), hwnd, ulAnimationTimerID); // Restore mouse pointer, if we're in real screen-saving mode! if (!bOnlyPreviewMode) WinShowPointer(HWND_DESKTOP, TRUE); break; case WM_ADJUSTWINDOWPOS: if (!bOnlyPreviewMode) { SWP *pSWP; // The following is required so that this window will be on // top of the xCenter window, evenif that is set to be always on top! // Real screensaving, here we should stay on top! // Set WS_TOPMOST flag again! WinSetWindowBits(hwnd, QWL_STYLE, WS_TOPMOST, WS_TOPMOST); pSWP = (SWP *) mp1; pSWP->hwndInsertBehind = HWND_TOP; pSWP->fl |= SWP_ZORDER; } break; case WM_PAINT: { HPS hpsBeginPaint; RECTL rclRect, blank, rclWindow; FONTMETRICS fm; int len; #ifdef DEBUG_LOGGING AddLog("WM_PAINT\n"); #endif hpsBeginPaint = WinBeginPaint(hwnd, NULLHANDLE, &rclRect); WinQueryWindowRect(hwnd, &rclRect); WinQueryWindowRect(hwnd, &rclWindow); WinSetWindowFontMy(hwnd, "10.Courier"); GpiQueryFontMetrics(hpsBeginPaint, sizeof(fm), &fm); rclRect.xLeft = textX; rclRect.yTop = textY; len = strlen(CfgDlgInit.pchText); rclRect.xRight = rclRect.xLeft + fm./*lAveCharWidth*/lMaxCharInc * len+5; rclRect.yBottom = rclRect.yTop - fm.lMaxBaselineExt; WinDrawText(hpsBeginPaint, len ,CfgDlgInit.pchText, &rclRect, CLR_WHITE, CLR_BLACK, DT_ERASERECT | DT_LEFT | DT_VCENTER); /* paint the black around the text*/ blank.xLeft = 0; blank.yBottom = 0; blank.xRight = rclRect.xLeft; blank.yTop = rclWindow.yTop; WinFillRect(hpsBeginPaint, &blank, CLR_BLACK); blank.xLeft = rclRect.xLeft-2; blank.yBottom = rclRect.yTop; blank.xRight = rclWindow.xRight; blank.yTop = rclWindow.yTop; WinFillRect(hpsBeginPaint, &blank, CLR_BLACK); blank.xLeft = rclRect.xRight; blank.yBottom = 0; blank.xRight = rclWindow.xRight; blank.yTop = rclRect.yTop; WinFillRect(hpsBeginPaint, &blank, CLR_BLACK); blank.xLeft = rclRect.xLeft-2; blank.yBottom = 0; blank.xRight = rclRect.xRight+2; blank.yTop = rclRect.yBottom; WinFillRect(hpsBeginPaint, &blank, CLR_BLACK); if (rclRect.xRight <= -10) { WinQueryWindowRect(hwnd, &rclRect); textX = rclRect.xRight; textY = rclRect.yTop/2; } WinEndPaint(hpsBeginPaint); #ifdef DEBUG_LOGGING AddLog("WM_PAINT done\n"); #endif return (MRESULT) FALSE; } case WM_TIMER: if (((SHORT)mp1)==ANIMATION_TIMER_ID) { // Timer, so make new image position textX -= 2; WinInvalidateRect(hwnd, NULL, FALSE); } break; default: break; } return WinDefWindowProc( hwnd, msg, mp1, mp2 ); }