// calcola dimensioni rettangolo testo groupbox VOID SizeGroupText(PCTL pgb) { HPS hps = WinGetPS(pgb->hwnd); POINTL aptl[3]; PSZ psz; pgb->wrtxt.cx = 0; // calculate text rectangle size if ((pgb->fl & DT_MNEMONIC) && NULL != (psz = strchr(pgb->psz, '~'))) { if (psz - pgb->psz) { // se la tilde non Š primo char GpiQueryTextBox(hps, psz - pgb->psz, pgb->psz, 3, aptl); pgb->wrtxt.cx = aptl[2].x - aptl[0].x; } // end if se tilde non Š ultimo char if (pgb->cbtxt - (psz - pgb->psz) - 1) { GpiQueryTextBox(hps, pgb->cbtxt - (psz - pgb->psz) - 1, psz + 1, 3, aptl); pgb->wrtxt.cx += aptl[2].x - aptl[0].x + 2; } /* endif */ //pgb->wrtxt.cy = aptl[0].y - aptl[1].y; } else { GpiQueryTextBox(hps, pgb->cbtxt, pgb->psz, 3, aptl); //pgb->wrtxt.cy = aptl[0].y - aptl[1].y; pgb->wrtxt.cx = aptl[2].x - aptl[0].x + 2; } /* endif */ WinReleasePS(hps); } /* endif */
MRESULT InitMainWindow(HWND hwnd, /* handle to the main client window */ MPARAM mp1, /* first parameter of WM_CREATE message */ MPARAM mp2) /* second parameter of WM_CREATE message */ { FONTMETRICS fm; HPS hps; hps = WinGetPS (hwnd) ; GpiQueryFontMetrics (hps, (LONG) sizeof fm, &fm) ; cxChar = fm.lAveCharWidth ; cxCaps = fm.lEmInc ; cyChar = fm.lMaxBaselineExt ; cyDesc = fm.lMaxDescender ; WinReleasePS (hps) ; cxTextTotal = MESSAGE_LEN * cxChar ; hwndHscroll = WinWindowFromID ( WinQueryWindow (hwnd, QW_PARENT), FID_HORZSCROLL) ; hwndVscroll = WinWindowFromID ( WinQueryWindow (hwnd, QW_PARENT), FID_VERTSCROLL) ; return (MRFROMLONG(0)); }
/*@ XBitmap::Load(const char* filename, XBitmapFilter * params, BOOL releaseParams) @group loading a bitmap @remarks Load a bitmap from a file. <P><I>If this method is used, GBM.DLL and OLLGLIB.DLL must be in the LIBPATH.</I> <P>Due a bug (?) in OS/2-GPI you should specify params->cBitCount = BFP_BPP_TRUECOLOR if you want to modify or resave the bitmap. @parameters <t 'ø' c=2> øchar * fileName øfilename of the file to load øXBitmapFilter * params øfiletype specific filter informations. An initialized structure has to be created by XBitmap :: GetImportFilterStruct () or XGLibFileDialog. (default is NULL) øBOOL releaseParams øfilter informations will be released after usages <\t> @exceptions If the method fails to create a new bitmap an exception of the type XException is thrown. */ void XBitmap :: Load (const char* filename, XBitmapFilter* params, BOOL releaseParams) { if (hbm) GpiDeleteBitmap(hbm); hbm = NULLHANDLE; XResourceLibrary* lib = new XResourceLibrary ("OOLGLIB"); XGLibProcIO* func = (XGLibProcIO*) lib->LoadFunction ("OOL_GLIB_IMP"); DosSleep(100); if (NULL != func) { if (owner) hps = WinGetPS (owner->GetHandle()); ULONG rc; if (NULL == params) params = GetImportFilterStruct (filename); params->hps = hps; params->hbm = hbm; params->hab = XApplication :: GetApplication ()->GetAnchorBlock (); if (BFE_OK != (rc = func (filename, __XBMFProfile__, params, 0))) { if (releaseParams) ReleaseFilterStruct (params); OOLThrow (GetLastErrorMessage (lib, &rc, params), rc); } hbm = params->hbm; if (releaseParams) ReleaseFilterStruct (params); lib->UnLoadFunction ((PFNWP) func); } else { if (releaseParams) ReleaseFilterStruct (params); ULONG error = WinGetLastError (XApplication :: GetApplication ()->GetAnchorBlock ()); OOLThrow("Could not load function \"OOL_GLIB_IMP\" from library \"OOLGLIB.DLL\".", error); } delete lib; XSize s; GetDimensions(&s); width = cx = s.GetWidth(); height = cy = s.GetHeight(); }
MRESULT clbPPchange(PCLBOX pclb, ULONG fl) { HPS hps; if (pclb && NULLHANDLE != (hps = WinGetPS(pclb->hwnd))) { switch (fl) { case PP_FOREGROUNDCOLOR: case PP_FOREGROUNDCOLORINDEX: pclb->lfgnd = WgetCtlClr(pclb->hwnd, hps, PP_FOREGROUNDCOLOR, PP_FOREGROUNDCOLORINDEX, SYSCLR_WINDOWSTATICTEXT); break; case PP_BACKGROUNDCOLOR: case PP_BACKGROUNDCOLORINDEX: pclb->lbkgnd = WgetCtlClr(pclb->hwnd, hps, PP_BACKGROUNDCOLOR, PP_BACKGROUNDCOLORINDEX, SYSCLR_DIALOGBACKGROUND); break; case PP_FONTNAMESIZE: if ((pclb->cyFont = stSizeFont(hps)) % 2) ++pclb->cyFont; clbSize(pclb); clbMove(pclb); break; } /* endswitch */ WinReleasePS(pclb->hwnd); WinRefreshWin(pclb->hwnd); } return (MRESULT)FALSE; }
/*-------------------------------------------------- * Sets a new font to be used by the window *--------------------------------------------------*/ PMWindow& PMWindow::set_font( const char* font ) { static int have_warpsans = -1; const char* used_font = font; if( strcmp( font, "9.WarpSans" ) == 0 ) { if( have_warpsans == -1 ) { LONG rc; LONG fonts = 0; HPS hps; hps = WinGetPS( HWND_DESKTOP ); rc = GpiQueryFonts( hps, QF_PUBLIC, "WarpSans", &fonts, 0, NULL ); WinReleasePS( hps ); have_warpsans = ( rc > 0 && rc != GPI_ALTERROR ); } if( !have_warpsans ) { used_font = "8.Helv"; } } if( !WinSetPresParam( win_handle, PP_FONTNAMESIZE, strlen(used_font)+1, (PVOID)used_font )) PM_THROW_GUIERROR(); return *this; }
void ValueSample::init() { COLOR color[] = { CLR_RED, CLR_GREEN, CLR_BLUE, CLR_YELLOW }; logo.showLogo(1500); createDlg(); if (!hwnd) OThrowPM("Dialog creation failed.", 0, OException::unrecoverable); VSet.inherit(hwnd); VSet.setItemAttr(1, 0, VIA_ICON); VSet.setItemAttr(2, 0, VIA_BITMAP); VSet.setItemAttr(3, 0, VIA_COLORINDEX); if ((VSet.selected.icon = WinLoadPointer(HWND_DESKTOP, NULLHANDLE, VALUE_ICON)) == NULLHANDLE) OThrowPM("Loading icon failed.", 0, OException::unrecoverable); if (!VSet.setItem(1, 0, (ULONG)VSet.selected.icon)) OThrowPM("Could not set icons.", 0, OException::unrecoverable); if ((VSet.selected.bitmap = GpiLoadBitmap(WinGetPS(hwnd), NULLHANDLE, VALUE_BMP, 0, 0)) == NULLHANDLE) OThrowPM("Loading bitmap failed.", 0, OException::unrecoverable); if (!VSet.setItem(2, 0, (ULONG)VSet.selected.bitmap)) OThrowPM("Could not set bitmaps.", 0, OException::unrecoverable); for (ULONG count = 1; count <= 4; count++) if (!VSet.setItem(3, count, color[count-1])) OThrowPM("Could not set color.", 0, OException::unrecoverable); centerDlg(); showDlg(); }
MRESULT EXPENTRY ClientWndProc (HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { static HBITMAP hbm ; HPS hps ; RECTL rcl ; switch (msg) { case WM_CREATE: hps = WinGetPS (hwnd) ; hbm = GpiLoadBitmap (hps, 0, IDB_HELLO, 0L, 0L) ; WinReleasePS (hps) ; return 0 ; case WM_PAINT: hps = WinBeginPaint (hwnd, NULLHANDLE, NULL) ; GpiErase (hps) ; WinQueryWindowRect (hwnd, &rcl) ; if (hbm) WinDrawBitmap (hps, hbm, NULL, (PPOINTL) &rcl, CLR_BACKGROUND, CLR_NEUTRAL, DBM_STRETCH) ; WinEndPaint (hps) ; return 0 ; case WM_DESTROY: if (hbm) GpiDeleteBitmap (hbm) ; return 0 ; } return WinDefWindowProc (hwnd, msg, mp1, mp2) ; }
void FontSelectDialog( HWND hwndWnd ) { /* * Bring up the font selection dialog; display only FIXED-pitch fonts! * Save the client window handle in the ulUser field. */ fdFontDlg.hpsScreen = WinGetPS( hwndWnd ); fdFontDlg.cbSize = sizeof( FONTDLG ); fdFontDlg.pszFamilyname = achFamily; fdFontDlg.usFamilyBufLen = sizeof( achFamily ); fdFontDlg.clrFore = CLR_BLACK; fdFontDlg.pszPreview = "AaBb"; fdFontDlg.fl = FNTS_CENTER | FNTS_FIXEDWIDTHONLY | FNTS_INITFROMFATTRS | FNTS_HELPBUTTON | FNTS_RESETBUTTON | FNTS_APPLYBUTTON; fdFontDlg.pfnDlgProc = FontDlgProc; fdFontDlg.ulUser = (ULONG)hwndWnd; WinFontDlg( HWND_DESKTOP, hwndWnd, (PFONTDLG)&fdFontDlg ); WinReleasePS( fdFontDlg.hpsScreen ); /* * If a font was successfully selected, copy its attributes into achFont and * use that to set the default PM font parameter for the client window. */ if ( fdFontDlg.lReturn == DID_OK ) { sprintf( achFont, "%d.%s", FIXEDINT( fdFontDlg.fxPointSize ), fdFontDlg.fAttrs.szFacename ); WinSetPresParam( hwndWnd, PP_FONTNAMESIZE, strlen( achFont ) + 1, achFont ); GetFontMetrics( hwndWnd, FALSE ); UpdateScreenLimits( hwndWnd, TRUE ); } }
/* SaverWindowProc This is the window procedure of the screen-size window that is created when the saver starts. There should be no reason to alter the code. Note that we do not process WM_PAINT messages. They are forwarded to the default window procedure, which just validates the window area and does no drawing. All drawing to the window should be done in the drawing-thread. Therefore, if you want to blank the screen before drawing on it for instance, issue a WinFillRect call at the beginning of your drawing-thread. */ MRESULT EXPENTRY SaverWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { switch(msg){ case WM_CREATE: // reset the "stop" flag stop_draw_thread = FALSE; // store window handle hwndSaver = hwnd; // get presentation space hps = WinGetPS(hwnd); // start the drawing-thread tidDraw = _beginthread(draw_thread, NULL, STACKSIZE, NULL); // create thread to control priority of drawing thread if(low_priority){ stop_priority_thread = FALSE; DosCreateThread(&tidPriority, (PFNTHREAD)priority_thread, 0, 2L, 1000); } return (MRESULT)FALSE; case WM_DESTROY: // release the presentation space WinReleasePS(hps); break; case WM_PAINT: // just validate the update area. all drawing is done // in the drawing-thread. return WinDefWindowProc(hwnd, msg, mp1, mp2); } return WinDefWindowProc(hwnd, msg, mp1, mp2); }
static USHORT setControlPos(HWND hwnd, USHORT x, USHORT y, USHORT ySize) { char buffer[0x0100]; POINTL aptl[TXTBOX_COUNT]; HPS hps; ULONG flag = SWP_SIZE; WinQueryWindowText(hwnd,0xFF,buffer); *(buffer+0xFF) = 0; hps = WinGetPS(hwnd); GpiQueryTextBox( hps, strlen(buffer), (char *) buffer, TXTBOX_COUNT, aptl); WinReleasePS(hps); if(x != 0xFFFF && y != 0xFFFF) flag |= SWP_MOVE|SWP_SHOW; WinSetWindowPos(hwnd, 0, x, y, aptl[TXTBOX_TOPRIGHT].x, ySize, flag); return x+aptl[TXTBOX_TOPRIGHT].x; }
void DrawBox( HWND hwnd ) { HPS hps; POINTL pointl; // Get a cached PS for the window hps = WinGetPS( hwnd ); pointl.x = pointl.y = 0; // Set the current position to (0,0) GpiSetCurrentPosition( hps, &pointl ); pointl.x = pointl.y = 10; // Draw a 10 by 10 box from the current position in the // current color. GpiBox( hps, DRO_OUTLINE, &pointl,0,0 ); // Free the cached PS WinReleasePS( hps ); }
MRESULT clbSCchange(PCLBOX pclb) { HPS hps; if (pclb && NULLHANDLE != (hps = WinGetPS(pclb->hwnd))) { clbUpdColors(pclb, hps); WinReleasePS(hps); WinRefreshWin(pclb->hwnd); } /* endif */ return (MRESULT)FALSE; }
QPixmap QPixmap::grabWindow(WId winId, int x, int y, int w, int h) { QPixmap pm; if (w == 0 || h == 0) return pm; RECTL rcl; if (!WinQueryWindowRect(winId, &rcl)) return pm; if (w < 0) w = rcl.xRight; if (h < 0) h = rcl.yTop; // flip y coordinate y = rcl.yTop - (y + h); HPS hps = qt_alloc_mem_ps(w, h); if (hps == NULLHANDLE) return pm; HBITMAP hbm = NULLHANDLE; // bitmap header + 2 palette entries (for the mask) BITMAPINFOHEADER2 bmh; bmh.cbFix = sizeof(BITMAPINFOHEADER2); // create the uninitialized bitmap to hold window pixels bmh.cx = w; bmh.cy = h; bmh.cPlanes = 1; bmh.cBitCount = 32; hbm = GpiCreateBitmap(hps, &bmh, 0, 0, 0); if (hbm != NULLHANDLE) { GpiSetBitmap(hps, hbm); HPS hpsWin = WinGetPS(winId); if (hpsWin != NULLHANDLE) { POINTL pnts[] = { {0, 0}, {w, h}, {x, y} }; if (GpiBitBlt(hps, hpsWin, 3, pnts, ROP_SRCCOPY, BBO_IGNORE) != GPI_ERROR) { GpiSetBitmap(hps, NULLHANDLE); pm = fromPmHBITMAP(hbm); } WinReleasePS(hpsWin); } GpiDeleteBitmap(hbm); } qt_free_mem_ps(hps); return pm; }
/****************************************************************\ * Routine to start semaphore example * *--------------------------------------------------------------* * * * Name: StartSemExample(VOID) * * * * Purpose: Calls routines to create semaphores and draw * * resources. Creates consumer threads. * * * * Usage: Called in file usercmd.c when the user selects * * start from the semaphore menu. * * * * Method: Uses routines in paint.c to draw consumers and * * resources. This is done by creating a paint * * message, not calling the draw routines directly. * * * * Returns: TRUE if start succeeds, FALSE if start fails * * * \****************************************************************/ INT StartSemExample(VOID) { TID tid=0; ULONG rc; INT i; FONTMETRICS fntmet; HPS hps; SWP swp; InitSemaphExample(); rc = CreateAllSems(); if (rc) return FALSE; /****************************************************************\ * Create consumer threads. Note that values can be passed to * * threads in OS/2 2.0. We pass the ordinal number of the child * * to each child. * \****************************************************************/ for (usConsumerThreadsCreated = 0; usConsumerThreadsCreated < cNumUsers; usConsumerThreadsCreated++) { rc = DosCreateThread((PTID) &tid, (PFNTHREAD)ThreadConsumer, (ULONG) usConsumerThreadsCreated, (ULONG)1,(ULONG) STACKSIZE); if (rc) { SemError("DosCreateThread",rc); return FALSE; } else { thrConsumers[usConsumerThreadsCreated].tid = tid; thrConsumers[usConsumerThreadsCreated].lHits = 0L; } } for (i = 0; i < (INT) cNumUsers; i++) { DosResumeThread (thrConsumers[i].tid); } hps = WinGetPS (hwndMain); if (hps) { GpiQueryFontMetrics (hps, (LONG) sizeof fntmet, &fntmet); WinQueryWindowPos (hwndMain, &swp); SetRectPositions((SHORT)swp.cx, (SHORT)swp.cy, (SHORT) fntmet.lMaxBaselineExt, (SHORT) fntmet.lMaxDescender); DrawRects (hps); WinReleasePS (hps); } return TRUE; }
/*DOC CLASS XPalette FUNCTION XPalette GROUP x-games/constructors/destructor REMARKS Default constructor for a palette object. Queries the WPS colors (0-9, 246-255) and stores them. */ XPalette::XPalette() { int i; // get HPS and HDC of the root window hpsDesktop = WinGetPS( HWND_DESKTOP ); hdcDesktop = GpiQueryDevice( hpsDesktop ); // get WPS colors GpiQueryRealColors( hpsDesktop, 0, 0, 256, (PLONG)aulWPSPalette ); memcpy( &aulData[0], &aulWPSPalette[0], 256 * sizeof( ULONG ) ); } // XPalette::XPalette
void EXPENTRY wmPaint(HWND hwnd) { video_canvas_t c=(video_canvas_t)WinQueryWindowPtr(hwnd,QWL_USER); // Ptr to usr resources HPS hps=WinGetPS(hwnd); // Handle to Presentation Space // next time call cavas_refresh, refresh the whole canvas if (c->init_ready) c->exposure_handler(c->width, c->height); else c->init_ready=TRUE; // First call=canvas initialize ended WinBeginPaint(hwnd, hps, NULL); // Set Region in hps to blit; WinEndPaint (hps); // must be done every time WM_PAINT was sent }
void CairoDrawThread(void *pParam) { HWND hwndClientWindow = (HWND) pParam; HPS hpsClientWindow; SWP swpTemp; // Query HPS of HWND hpsClientWindow = WinGetPS(hwndClientWindow); WinQueryWindowPos(hwndClientWindow, &swpTemp); // Set FPU state which might have been changed by some Win* calls! // (Workaround for a PM bug) DisableFPUException(); // Initialize cairo support cairo_os2_init(); // Create cairo surface pCairoSurface = cairo_os2_surface_create(hpsClientWindow, swpTemp.cx, swpTemp.cy); // Tell the surface the HWND too, so if the application decides // that it wants to draw itself, then it will be able to turn // on blit_as_changes. cairo_os2_surface_set_hwnd(pCairoSurface, hwndClientWindow); // Make sure that the changes will be shown only // when we tell so cairo_os2_surface_set_manual_window_refresh(pCairoSurface, TRUE); // Create Cairo drawing handle for the surface pCairoHandle = cairo_create(pCairoSurface); // Do the main drawing loop as long as needed! bShutdownDrawing = 0; CairoDrawLoop(hwndClientWindow, swpTemp.cx, swpTemp.cy, pCairoSurface, pCairoHandle); // Clean up! cairo_destroy(pCairoHandle); cairo_surface_destroy(pCairoSurface); cairo_os2_fini(); WinReleasePS(hpsClientWindow); _endthread(); }
/* SaverWindowProc This is the window procedure of the screen-size window that is created when the saver starts. There should be no reason to alter the code. Note that we do not process WM_PAINT messages. They are forwarded to the default window procedure, which just validates the window area and does no drawing. All drawing to the window should be done in the drawing-thread. Therefore, if you want to blank the screen before drawing on it for instance, issue a WinFillRect call at the beginning of your drawing-thread. */ MRESULT EXPENTRY SaverWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2) { switch(msg){ case WM_CREATE: /* reset the "stop" flag */ stop_draw_thread = FALSE; /* store window handle */ hwndSaver = hwnd; /* get presentation space */ hps = WinGetPS(hwnd); /* start the drawing-thread */ /* $$$$$ note $$$$$ Some compilers use another parameter ordering for _beginthread. The _beginthread call below works with EMX, ICC and BCC. Check your compiler docs for other compilers. */ #if defined(__BORLANDC__) /* for Borland C++ */ tidDraw = _beginthread(draw_thread, STACKSIZE, NULL); #elif defined(__EMX__) || defined(__IBMC__) /* for EMX and ICC */ tidDraw = _beginthread(draw_thread, NULL, STACKSIZE, NULL); #endif /* create thread to control priority of drawing thread */ if(low_priority){ stop_priority_thread = FALSE; DosCreateThread(&tidPriority, (PFNTHREAD)priority_thread, 0, 2L, 1000); } /* create timer that moves the saver window to top regularly */ WinStartTimer(hab, hwndSaver, IDT_ZORDERTIMER, ZORDERTIMERSTEP); return (MRESULT)FALSE; case WM_TIMER: if(SHORT1FROMMP(mp1) == IDT_ZORDERTIMER){ /* move saver window to top */ WinSetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER); return (MRESULT)0; } break; case WM_DESTROY: /* release the presentation space */ WinReleasePS(hps); /* stop the z-order timer */ WinStopTimer(hab, hwndSaver, IDT_ZORDERTIMER); break; case WM_PAINT: /* just validate the update area. all drawing is done */ /* in the drawing-thread. */ return WinDefWindowProc(hwnd, msg, mp1, mp2); } return WinDefWindowProc(hwnd, msg, mp1, mp2); }
void MyRenderWin::calcWinSize(MiniWin* win) { char sampleString[64]; switch (timeFmt) { case 0: // 12 hour strcpy(sampleString, "77:77aI"); break; case 1: // 24 hour strcpy(sampleString, "77:77I"); break; default: strcpy(sampleString, "?time?"); break; } const ULONG sampleLen = strlen(sampleString); HPS hps = WinGetPS(win->client()); POINTL aptl[TXTBOX_COUNT]; BOOL success = GpiQueryTextBox(hps, sampleLen, (PSZ)sampleString, TXTBOX_COUNT, aptl); ULONG x; ULONG y; if (success == TRUE) { ULONG hgt1 = Max(aptl[TXTBOX_TOPRIGHT].y, aptl[TXTBOX_TOPLEFT].y); ULONG hgt2 = Min(aptl[TXTBOX_BOTTOMRIGHT].y, aptl[TXTBOX_BOTTOMLEFT].y); ULONG wid1 = Max(aptl[TXTBOX_TOPRIGHT].x, aptl[TXTBOX_BOTTOMRIGHT].x); ULONG wid2 = Min(aptl[TXTBOX_TOPLEFT].x, aptl[TXTBOX_BOTTOMLEFT].x); x = wid1 - wid2; y = hgt1 - hgt2; } else { x = strlen(sampleString) * 12; y = 20; } WinReleasePS(hps); win->size(x + 6, y + 6); // 2 border & 1 blank on each edge }
/* * _ClearWindow - erase a window */ void _ClearWindow( LPWDATA w ) { HWND hwnd; hwnd = w->hwnd; /*** Clear the w->image array ***/ #ifdef _MBCS { mb_char mbc; int count; mbc = _mbsnextc( (unsigned char *)" " ); for( count=0; count < w->width * w->height; count++ ) { w->image[count] = mbc; /* store space in w->image */ } } #else FARmemset( w->image, 0x20, w->width*w->height ); #endif #if defined( __OS2__ ) { HPS ps; RECTL rcl; ps = WinGetPS( hwnd ); WinQueryWindowRect( hwnd, &rcl ); WinFillRect( ps, &rcl, CLR_WHITE ); WinReleasePS( ps ); } #else { RECT rect; HDC dc; dc = GetDC( hwnd ); #ifndef __NT__ UnrealizeObject( w->brush ); #endif SelectObject( dc, w->brush ); #ifdef __NT__ SetBrushOrgEx( dc, 0, 0, NULL ); #endif GetClientRect( hwnd, &rect ); FillRect( dc, &rect, w->brush ); ReleaseDC( hwnd, dc ); } #endif } /* _ClearWindow */
TkRegion TkCreateRegion() { HRGN region; HPS hps; hps= WinGetPS(HWND_DESKTOP); region = GpiCreateRegion(hps, 0, NULL); WinReleasePS(hps); #ifdef DEBUG printf("TkCreateRegion region %x, hps %x\n", region, hps); #endif return (TkRegion) region; }
/*@ XToolBar::Draw(void) @group display @remarks Redraw the toolbar. */ void XToolBar::Draw(void) { RECTL rect; WinQueryWindowRect(winhandle, &rect); HPS hps = WinGetPS(winhandle); GpiCreateLogColorTable(hps, LCOL_RESET, LCOLF_RGB, 0,0,NULL); WinFillRect( hps, &rect, SYSCLR_BUTTONMIDDLE); WinDrawBorder(hps, &rect, 1,1,0,0,DB_PATCOPY|DB_RAISED); HENUM e; HWND hwnd; e = WinBeginEnumWindows(winhandle); while ((hwnd = WinGetNextWindow(e)) != 0) WinInvalidateRegion(hwnd, NULLHANDLE, TRUE); WinEndEnumWindows(e); }
void OListBox::auto_scroll() { FONTMETRICS FontMetrics; WinQueryWindowRect(hwnd, &rcl); hps = WinGetPS(hwnd); GpiQueryFontMetrics(hps, sizeof(FONTMETRICS), &FontMetrics); WinReleasePS(hps); if (queryItemCount() > ((rcl.yTop - rcl.yBottom) / FontMetrics.lMaxBaselineExt)) { if ((rcl.yTop - rcl.yBottom) % FontMetrics.lMaxBaselineExt) setToTop(queryTopItem()+2); else setToTop(queryTopItem()+1); } }
void PrintString(char szMessage[],ULONG ulLine) { HPS hps; RECTL rcl; POINTL ptl; ptl.y = (ulWindowHeight - (ulLine * (stCell.cy + 3))); ptl.x = stCell.cx; rcl.yBottom = (ptl.y - 3); rcl.yTop = (ptl.y + stCell.cy); rcl.xLeft = 0; rcl.xRight = ulWindowWidth; hps = WinGetPS(hwndClient); WinFillRect(hps,&rcl,CLR_WHITE); GpiCharStringAt(hps,&ptl,strlen(szMessage),szMessage); WinReleasePS(hps); }
HPS gfxOS2Surface::GetPS() { // Creating an HPS on-the-fly should never be needed because GetPS() // is only called for printing surfaces & mPS should only be null for // window surfaces. It would be a bug if Cairo had an HPS but Thebes // didn't, but we'll check anyway to avoid leakage. As a last resort, // if this is a window surface we'll create one & hang on to it. if (!mPS) { cairo_os2_surface_get_hps(CairoSurface(), &mPS); if (!mPS && mWnd) { mPS = WinGetPS(mWnd); cairo_os2_surface_set_hps(CairoSurface(), mPS); } } return mPS; }
static void internal_GetStaticTextSize(HWND hwnd, ULONG ulID, int *piCX, int *piCY) { HPS hps; char achTemp[512]; POINTL aptl[TXTBOX_COUNT]; // This calculates how much space is needed for a given static text control // to hold its text. WinQueryDlgItemText(hwnd, ulID, sizeof(achTemp), achTemp); hps = WinGetPS(WinWindowFromID(hwnd, ulID)); GpiQueryTextBox(hps, strlen(achTemp), achTemp, TXTBOX_COUNT, aptl); *piCX = aptl[TXTBOX_TOPRIGHT].x - aptl[TXTBOX_BOTTOMLEFT].x; *piCY = aptl[TXTBOX_TOPRIGHT].y - aptl[TXTBOX_BOTTOMLEFT].y; WinReleasePS(hps); }
/*------------------------------------------------------------------------*/ MRESULT EXPENTRY SplashWndProc(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2) { static HBITMAP hbm; static SWP swp; HPS hps; RECTL rcl; switch(msg) { case WM_CREATE: hps = WinGetPS (hwnd); hbm = GpiLoadBitmap(hps, (HMODULE)0L, IDB_LOGO, (ULONG)0, (ULONG)0); WinReleasePS (hps); WinQueryWindowPos(hwnd, (PSWP)&swp); return (MRESULT)0; case WM_PAINT: hps = WinBeginPaint (hwnd, NULLHANDLE, /* Get a cached PS */ (RECTL *)0); GpiErase (hps); GpiCreateLogColorTable (hps, LCOL_RESET, LCOLF_RGB, 0L, 0L, NULL) ; rcl.xLeft = 0; rcl.yBottom = 0; rcl.xRight = swp.cx; rcl.yTop = swp.cy; if ( hbm ) WinDrawBitmap(hps,hbm, NULL, (PPOINTL) &rcl, CLR_NEUTRAL, CLR_BACKGROUND, DBM_STRETCH ); WinDrawBorder(hps, &rcl,2L,2L,0L, 0L, DB_DEPRESSED); WinEndPaint(hps); return (MRESULT)0; } return( WinDefWindowProc(hwnd, msg, mp1, mp2) ); }
void ErrorNotify(char szMessage[]) { HPS hps; RECTL rcl; POINTL ptl; ptl.y = 2; ptl.x = stCell.cx; rcl.yBottom = 0; rcl.yTop = stCell.cy; rcl.xLeft = 0; rcl.xRight = ulWindowWidth; hps = WinGetPS(hwndClient); WinFillRect(hps,&rcl,CLR_WHITE); GpiCharStringAt(hps,&ptl,strlen(szMessage),szMessage); WinReleasePS(hps); }
// ------------------------------------------------------------------------- HWND CreateToolbar(HWND hwndParent, HMODULE hmod, ULONG menuid) { UCMINFO UCMInfo; ULONG ulMCx, ulMCy, flgs = 0; HWND hwndClient, hwndMenu, hTmp; WinRegisterClass( (HAB)0, "TOOLBAR", ClientWndProc, CS_SIZEREDRAW, 0); hwndClient = WinCreateWindow( hwndParent, "TOOLBAR", "", flgs, 8, 8, 0, 0, hwndParent, HWND_TOP, menuid, NULL, NULL ); memset(&UCMInfo, 0, sizeof(UCMINFO)); UCMInfo.cb = sizeof(UCMINFO); UCMInfo.NbOfCols = 1; UCMInfo.NbOfRows = 7; UCMInfo.Style = UCS_FRAMED | // Draw a 3D frame around the items UCS_FORCESIZE | // Force the size of the items UCS_CHNGBMPBG | // Use one of the bitmap colors as a background color UCS_NO_DM | // No drag&drop manip UCS_NO_CM; // No context menu HPS hps = WinGetPS( hwndClient ); // -- Set the color of the bitmaps which has to be replaced by the items background color UCMInfo.BgBmp = GpiQueryRGBColor( hps, 0, CLR_PALEGRAY ); UCMInfo.BgColor = GpiQueryRGBColor( hps, 0, CLR_DARKGRAY ); // -- Set the color of the items background UCMInfo.ItemBgColor = 0x00b0b0b0; WinReleasePS( hps ); UCMInfo.cx = 24; // Width of the items ( used because UCS_FORCESIZE is set ) UCMInfo.cy = 24; // Height of the items UCMInfo.hModule = hmod; hwndMenu = UCMenuCreateFromResource( (HAB)0, hwndClient, hwndClient, CMS_MATRIX, 0, 0, 0, 0, HWND_TOP, FID_MENU, hmod, ID_TOOLS, &UCMInfo, &hTmp ); // hide_scrollbars( hwndMenu ); WinSendMsg( hwndMenu, UCMENU_QUERYSIZE, MPFROMP( &ulMCx ), MPFROMP( &ulMCy ) ); WinSetWindowPos( hwndMenu, HWND_TOP, 0, 0, ulMCx, ulMCy, SWP_SIZE ); WinSetWindowPos( hwndClient, HWND_TOP, 0, 0, ulMCx, ulMCy+8, SWP_SIZE ); return hwndClient; }
/*@ XBitmap::LoadBMP(const char* filename) @group loading a bitmap @remarks Load a bitmap from a file. This method works faster than Load() but can only load bitmpas in OS2-BMP format @parameters char * fileName filename of the file to load @exceptions If the method fails to create a new bitmap an exception of the type XException is thrown. */ void XBitmap :: LoadBMP(const char* filename) { if (hbm) GpiDeleteBitmap(hbm); hbm = 0; XFile file; PBITMAPFILEHEADER p; if (file.Open(filename, XFILE_FAIL_IF_NEW | XFILE_OPEN_EXISTING, XFILE_READONLY, XFILE_SHARE_DENYNONE ) == 0) { XFileInfo info; file.GetFileInfo(&info); file.Seek(0, XFILE_BEGIN); p = (PBITMAPFILEHEADER) malloc(info.GetFileSize()); file.Read(p, info.GetFileSize()); file.Close(); } else OOLThrow( "couldnït open file!", -1); if (owner ) { hps = WinGetPS(owner->GetHandle()); hbm = GpiCreateBitmap(hps, (PBITMAPINFOHEADER2) &p->bmp, CBM_INIT, (PBYTE) p + p->offBits, (PBITMAPINFO2) &p->bmp); if(hbm == 0) OOLThrow("error creating bitmap", 3); } else SetData((BITMAPINFOHEADER2 *) &p->bmp, p->offBits); free(p); XSize s; GetDimensions(&s); width = cx = s.GetWidth(); height = cy = s.GetHeight(); if (hbm == GPI_ERROR) { ULONG error = WinGetLastError(XApplication::GetApplication()->GetAnchorBlock()); OOLThrow("couldnït load bitmap", error); } return; }