/* * RePositionViewWnd - reposition the size of the window (for when a * different icon is selected) */ void RePositionViewWnd( img_node *node ) { WPI_RECT location; int h_adj; int v_adj; WPI_RECTDIM left; WPI_RECTDIM top; WPI_RECTDIM right; WPI_RECTDIM bottom; HWND frame; frame = _wpi_getframe( node->viewhwnd ); _wpi_getwindowrect( frame, &location ); h_adj = 2 * _wpi_getsystemmetrics( SM_CXDLGFRAME ) + 2 * BORDER_WIDTH; v_adj = 2 * _wpi_getsystemmetrics( SM_CYDLGFRAME ) + #ifndef __NT__ _wpi_getsystemmetrics( SM_CYCAPTION ) + 2 * BORDER_WIDTH - 1; #else _wpi_getsystemmetrics( SM_CYSMCAPTION ) + 2 * BORDER_WIDTH - 1; #endif _wpi_getrectvalues( location, &left, &top, &right, &bottom ); #ifdef __OS2_PM__ SetWindowPos( frame, NULL, left, bottom, h_adj + node->width, v_adj + node->height, SWP_SIZE | SWP_MOVE | SWP_NOZORDER | SWP_HIDEWINDOW ); #else SetWindowPos( node->viewhwnd, NULL, left, top, h_adj + node->width, v_adj + node->height, SWP_SIZE | SWP_MOVE | SWP_NOZORDER | SWP_HIDEWINDOW ); #endif hViewWindow = node->viewhwnd; ShowWindow( frame, showState ); SetFocus( HMainWindow ); InvalidateRect( hViewWindow, NULL, TRUE ); } /* RePositionViewWnd */
bool GUIWndInit( unsigned DClickInterval, gui_window_styles style ) { GUIMemOpen(); Style = style; GUISysInit( 0 ); _wpi_setdoubleclicktime( DClickInterval ); GUISetScreen( 0, 0, _wpi_getsystemmetrics( SM_CXSCREEN ), _wpi_getsystemmetrics( SM_CYSCREEN ) ); GUIInitDialog(); return( TRUE ); }
/* * CalculateDims - calculate the size of the "pixel" in the drawing * area and establish the device draw area size */ void CalculateDims( short img_width, short img_height, short *area_width, short *area_height ) { int point_size1; int point_size2; int max_width; int max_height; WPI_RECT rcclient; int x_adj; int y_adj; GetClientRect( ClientWindow, &rcclient ); x_adj = (short)(2 * _wpi_getsystemmetrics( SM_CXFRAME )); y_adj = (short)(2 * _wpi_getsystemmetrics( SM_CYFRAME ) + _wpi_getsystemmetrics( SM_CYCAPTION )); #if 0 max_width = _wpi_getwidthrect( rcclient ) - x_adj - origin->x; max_height = _wpi_getheightrect( rcclient ) - y_adj - origin->y; #else max_width = _wpi_getwidthrect( rcclient ) - x_adj; max_height = _wpi_getheightrect( rcclient ) - y_adj; #endif point_size1 = max( 1, max_width / img_width ); point_size2 = max( 1, max_height / img_height ); if( point_size1 < 1 ) { point_size1 = 1; } if( point_size2 < 1 ) { point_size2 = 1; } pointSize.x = min( point_size1, point_size2 ); while( pointSize.x * img_width < MIN_DRAW_WIN_WIDTH ) { pointSize.x++; } pointSize.y = pointSize.x; *area_width = (short)(pointSize.x * img_width); *area_height = (short)(pointSize.y * img_height); } /* CalculateDims */
static struct ScrollStruct getscrolldata( HWND Wnd, int dir ) /*=========================================================== This function gets the information needed to scroll a window properly */ { WPI_RECT rect; struct ScrollStruct info; WPI_RECTDIM left, right, top, bottom; //Get the necessary data _wpi_getscrollrange( Wnd, dir, &info.minpos, &info.maxpos ); info.currpos = _wpi_getscrollpos( Wnd, dir ); _wpi_getclientrect( Wnd, &rect ); _wpi_getrectvalues( rect, &left, &top, &right, &bottom ); if( dir == SB_VERT ){ info.max = _wpi_getsystemmetrics( SM_CYSCREEN ); info.pixls = bottom - top; info.currcoord = _BitBlt_Coord.ycoord; } else { info.max = _wpi_getsystemmetrics( SM_CXSCREEN ); info.pixls = right - left; info.currcoord = _BitBlt_Coord.xcoord; } // Amount to move the thumb by for every line scrolled if( info.pixls > LINEAMT ) { info.line = CalScrollAmt( info.maxpos, info.minpos, LINEAMT, info.max, info.pixls + 1); } else { info.line = info.pixls; } // Amount to move the thumb by for every page scrolled info.page = CalScrollAmt( info.maxpos, info.minpos, info.pixls, info.max, info.pixls + 1); return( info ); }
/* * HitRestoreButton - check if a specified point hit the restore button */ bool HitRestoreButton( HWND hwnd, WPI_PARAM2 lparam ) { WPI_RECT r; WPI_POINT pt; int left; int top; int right; int bottom; _wpi_getwindowrect( hwnd, &r ); _wpi_getrectvalues( r, &left, &top, &right, &bottom ); top += _wpi_getsystemmetrics( SM_CYCAPTION ) + _wpi_getsystemmetrics( SM_CYFRAME ); bottom = top + CLOSE_BITMAP_Y; right -= _wpi_getsystemmetrics( SM_CXFRAME ); left = right - CLOSE_BITMAP_X; _wpi_setrectvalues( &r, left, top, right, bottom ); WPI_MAKEPOINT(lparam, lparam, pt); return( _wpi_ptinrect( &r, pt ) ); } /* HitRestoreButton */
/* * setDefaultValues - set the default values of ImgedConfigInfo structure */ static void setDefaultValues( settings_info *info ) { int x, y; /* save settings */ info->settings = SET_SAVE_ALL; x = _wpi_getsystemmetrics( SM_CXSCREEN ); y = _wpi_getsystemmetrics( SM_CYSCREEN ); /* set defaults */ ImgedConfigInfo.x_pos = 0; ImgedConfigInfo.width = x; #ifdef __OS2_PM__ ImgedConfigInfo.y_pos = y / 5; ImgedConfigInfo.height = 4 * (y / 5); #else ImgedConfigInfo.y_pos = 0; ImgedConfigInfo.height = 4 * (y / 5); #endif ImgedConfigInfo.ismaximized = FALSE; ImgedConfigInfo.tool_xpos = ImgedConfigInfo.x_pos + ImgedConfigInfo.width - TBWidth - 2; ImgedConfigInfo.tool_ypos = ImgedConfigInfo.y_pos + _wpi_getsystemmetrics( SM_CYCAPTION ) + _wpi_getsystemmetrics( SM_CYMENU ) + FUNCTIONBAR_WIDTH + 2; ImgedConfigInfo.pal_xpos = ImgedConfigInfo.x_pos + ImgedConfigInfo.width - CP_WIDTH - 2; #ifdef __OS2_PM__ ImgedConfigInfo.pal_ypos = ImgedConfigInfo.y_pos + STATUS_WIDTH; #else ImgedConfigInfo.pal_ypos = ImgedConfigInfo.y_pos + ImgedConfigInfo.height - StatusWidth - CP_HEIGHT - 2; #endif ImgedConfigInfo.view_xpos = VIEWIN_XPOS; ImgedConfigInfo.view_ypos = ImgedConfigInfo.y_pos + _wpi_getsystemmetrics( SM_CYCAPTION ) + _wpi_getsystemmetrics( SM_CYMENU ) + FUNCTIONBAR_WIDTH + 2; /* other settings */ ImgedConfigInfo.show_state = SET_SHOW_TOOL | SET_SHOW_CLR | SET_SHOW_VIEW; info->paste = SET_PASTE_STR; info->rotate = 10 + SET_ROT_SIMPLE; // 10 means keep area info->viewwnd = SET_VIEW_1; info->wrapshift = TRUE; ImgedConfigInfo.shift = 1; ImgedConfigInfo.square_grid = TRUE; ImgedConfigInfo.brush_size = 2; ImgedConfigInfo.grid_on = TRUE; strcpy( info->opendir, "" ); strcpy( info->savedir, "" ); sprintf( info->color, "%ld", WHITE ); } /* setDefaultValues */
bool GUIGetMousePosn( gui_window *wnd, gui_point *point ) { WPI_POINT pt; if( !_wpi_getsystemmetrics( SM_MOUSEPRESENT ) ) { return( false ); } _wpi_getcursorpos( &pt ); #ifdef __OS2_PM__ // close your eyes!!! gross hack coming up _wpi_screentoclient( wnd->hwnd, &pt ); pt.y = _wpi_cvtc_y( wnd->hwnd, pt.y ); _wpi_clienttoscreen( wnd->hwnd, &pt ); #endif GUIMakeRelative( wnd, &pt, point ); return( true ); }
bool GUIXCreateToolBarWithTips( gui_window *wnd, bool fixed, gui_ord height, int num_toolbar_items, gui_toolbar_struct *toolinfo, bool excl, gui_colour_set *plain, gui_colour_set *standout, gui_rect *float_pos, bool use_tips ) { gui_coord size; gui_coord pos; HWND parent; HWND toolhwnd; toolbarinfo *tbar; int i; TOOLITEMINFO info; int fixed_height; int fixed_width; int adjust_amount; int width; int new_right; int bm_h; int bm_w; GUI_RECTDIM left, top, right, bottom; int h; excl = excl; plain = plain; standout = standout; fixed_height = 0; fixed_width = 0; if( ( wnd == NULL ) || ( num_toolbar_items < 1 ) || ( toolinfo == NULL ) || ( wnd->hwnd == NULLHANDLE ) || ( wnd->root == NULLHANDLE ) ) { return( false ); } if( wnd->tbinfo != NULL ) { GUICloseToolBar( wnd ); } tbar = wnd->tbinfo = (toolbarinfo *)GUIMemAlloc( sizeof( toolbarinfo ) ); if( tbar == NULL ) { return( false ); } memset( tbar, 0, sizeof( toolbarinfo ) ); parent = wnd->root; tbar->fixedrect = wnd->hwnd_client_rect; tbar->bitmaps = (HBITMAP *)GUIMemAlloc( num_toolbar_items * sizeof( HBITMAP ) ); if( tbar->bitmaps == NULL ) { GUIMemFree( tbar ); wnd->tbinfo = NULL; return( false ); } for( i = 0; i < num_toolbar_items; i++ ) { tbar->bitmaps[i] = _wpi_loadbitmap( GUIResHInst, _wpi_makeintresource( toolinfo[i].bitmap ) ); if( height == 0 ) { _wpi_getbitmapdim( tbar->bitmaps[i], &bm_w, &bm_h ); if( bm_h > fixed_height ) { fixed_height = bm_h; } if( bm_w > fixed_width ) { fixed_width = bm_w; } } } tbar->info.border_size.x = BORDER_AMOUNT; tbar->info.border_size.y = BORDER_AMOUNT; /* space for border and space before border */ adjust_amount = 2*(_wpi_getsystemmetrics( SM_CYBORDER )+BORDER_AMOUNT); if( height == 0 ) { /* maintian # of pixels in bitmap */ height = fixed_height + adjust_amount + OUTLINE_AMOUNT; width = fixed_width + OUTLINE_AMOUNT; } else { /* only height of windows given, make bitmaps square */ size.x = 0; size.y = height - 2; GUIScaleToScreenR( &size ); height = size.y; width = size.y; } _wpi_getrectvalues( tbar->fixedrect, &left, &top, &right, &bottom ); h = _wpi_getheightrect( tbar->fixedrect ); bottom = _wpi_cvth_y_plus1( height, h ); top = _wpi_cvth_y_plus1( top, h ); _wpi_setwrectvalues( &tbar->fixedrect, left, top, right, bottom ); height -= adjust_amount; /* leaving just button size */ tbar->info.button_size.x = width; tbar->info.button_size.y = height; bottom = height + BORDER_AMOUNT * 2 + _wpi_getsystemmetrics( SM_CYCAPTION ) + 2 * ( _wpi_getsystemmetrics( SM_CYFRAME ) - _wpi_getsystemmetrics( SM_CYBORDER ) ); bottom = _wpi_cvth_y_plus1( bottom, h ); #ifdef __OS2_PM__ bottom -= 2; #endif new_right = width * num_toolbar_items - (num_toolbar_items - 1) * tbar->info.border_size.x + left + 2 * _wpi_getsystemmetrics( SM_CXFRAME ) + BORDER_AMOUNT * 2; if( new_right < right ) { right = new_right; } _wpi_setwrectvalues( &tbar->floatrect, left, top, right, bottom ); _wpi_mapwindowpoints( parent, HWND_DESKTOP, (WPI_PPOINT)&tbar->floatrect, 2 ); if( fixed ) { tbar->info.area = tbar->fixedrect; tbar->info.style = TOOLBAR_FIXED_STYLE; } else { if( float_pos != NULL ) { GUICalcLocation( float_pos, &pos, &size, parent ); _wpi_setwrectvalues( &tbar->floatrect, pos.x, pos.y, pos.x + size.x, pos.y + size.y ); _wpi_mapwindowpoints( parent, HWND_DESKTOP, (WPI_PPOINT)&tbar->floatrect, 2 ); } tbar->info.area = tbar->floatrect; tbar->info.style = TOOLBAR_FLOAT_STYLE; } tbar->info.hook = guiToolBarProc; tbar->info.helphook = guiToolBarHelp; tbar->info.background = 0; tbar->info.foreground = 0; tbar->num = num_toolbar_items; tbar->info.is_fixed = fixed; tbar->info.use_tips = use_tips; tbar->hdl = ToolBarInit( parent ); ToolBarDisplay( tbar->hdl, &tbar->info ); GUIResizeBackground( wnd, true ); for( i = 0; i < num_toolbar_items; i++ ) { info.u.bmp = tbar->bitmaps[i]; info.id = toolinfo[i].id; info.flags = 0; if( use_tips && toolinfo[i].tip != NULL ) { strncpy( info.tip, toolinfo[i].tip, MAX_TIP ); } else { info.tip[0] = '\0'; } ToolBarAddItem( tbar->hdl, &info ); } toolhwnd = ToolBarWindow( tbar->hdl ); _wpi_showwindow( toolhwnd, SW_SHOWNORMAL ); _wpi_updatewindow( toolhwnd ); return( true ); }
static bool guiToolBarProc( HWND hwnd, WPI_MSG msg, WPI_PARAM1 wparam, WPI_PARAM2 lparam ) { gui_window *wnd; toolbarinfo *tbar; HMENU hmenu; gui_ctl_id id; wnd = GetToolWnd( hwnd ); if( wnd == NULL ) { return( false ); } tbar = wnd->tbinfo; if( tbar == NULL ) { return( false ); } switch( msg ) { case WM_CREATE : hwnd = _wpi_getframe( hwnd ); hmenu = _wpi_getsystemmenu( hwnd ); if( hmenu != NULLHANDLE ) { if( _wpi_appendmenu( hmenu, MF_SEPARATOR, 0, 0, NULLHANDLE, NULL ) ) { _wpi_appendmenu( hmenu, MF_ENABLED|MF_SYSMENU, 0, GUIHint[GUI_MENU_FIX_TOOLBAR].id, NULLHANDLE, GUIHint[GUI_MENU_FIX_TOOLBAR].label ); } } break; #ifdef __OS2_PM__ case WM_CHAR : case WM_TRANSLATEACCEL : #else case WM_SYSKEYDOWN : case WM_SYSKEYUP : case WM_KEYUP : case WM_KEYDOWN : #endif return( GUIProcesskey( hwnd, msg, wparam, lparam ) != 0 ); case WM_MENUSELECT : GUIProcessMenuSelect( wnd, hwnd, msg, wparam, lparam ); return( true ); case WM_SYSCOMMAND : id = _wpi_getid( wparam ); switch( id ) { case GUI_FIX_TOOLBAR : GUIChangeToolBar( wnd ); } break; #ifndef __OS2_PM__ case WM_NCLBUTTONDBLCLK : #endif case WM_RBUTTONDBLCLK : case WM_LBUTTONDBLCLK : /* flip the current state of the toolbar - * if we are fixed then start to float or vice versa */ if( !HasToolAtPoint( tbar->hdl, wparam, lparam ) ) { #ifdef __OS2_PM__ // Hack: For some reason we will get here with bogus coords, // we need to ignore the event. Should really find out where // the message is coming from. if( (ULONG)wparam != 0x0FFFFFFF ) GUIChangeToolBar( wnd ); #else GUIChangeToolBar( wnd ); #endif return( true ); } break; case WM_MOVE: case WM_SIZE: // Whenever we are moved or sized as a floating toolbar, we remember our position // so that we can restore it when dbl. clicked if( tbar->info.style == TOOLBAR_FLOAT_STYLE ) { hwnd = _wpi_getframe( hwnd ); _wpi_getwindowrect( hwnd, &tbar->floatrect ); } break; case WM_GETMINMAXINFO: { #ifdef __WINDOWS_386__ WPI_MINMAXINFO __far *minmax= (WPI_MINMAXINFO __far *)MK_FP32( (void *)lparam ); #else WPI_MINMAXINFO *minmax = (WPI_MINMAXINFO *)lparam; #endif _wpi_setmintracksize( minmax, ( tbar->info.border_size.x + _wpi_getsystemmetrics( SM_CXFRAME ) ) * 2 + tbar->info.button_size.x, ( tbar->info.border_size.y + _wpi_getsystemmetrics( SM_CYFRAME ) ) * 2 + tbar->info.button_size.y + _wpi_getsystemmetrics( SM_CYCAPTION ) ); } break; case WM_CLOSE : GUICloseToolBar( wnd ); return( true ); break; } return( false ); }
/* * loadPositionValues - load the position values from the configuration file */ static void loadPositionValues( HINI hini ) { int sysbox_width; int x, y; /* unused parameters */ (void)hini; x = _wpi_getsystemmetrics( SM_CXSCREEN ); y = _wpi_getsystemmetrics( SM_CYSCREEN ); sysbox_width = _wpi_getsystemmetrics( SM_CYCAPTION ); /* position of main window */ ImgedConfigInfo.x_pos = _wpi_getprivateprofileint( hini, imgedSection, "wnd_xpos", ImgedConfigInfo.x_pos, iniPath ); ImgedConfigInfo.y_pos = _wpi_getprivateprofileint( hini, imgedSection, "wnd_ypos", ImgedConfigInfo.y_pos, iniPath ); ImgedConfigInfo.width = _wpi_getprivateprofileint( hini, imgedSection, "wnd_width", ImgedConfigInfo.width, iniPath ); ImgedConfigInfo.height = _wpi_getprivateprofileint( hini, imgedSection, "wnd_height", ImgedConfigInfo.height, iniPath ); ImgedConfigInfo.ismaximized = _wpi_getprivateprofileint( hini, imgedSection, "ismaximized", ImgedConfigInfo.ismaximized, iniPath ); /* location of the tool window */ ImgedConfigInfo.tool_xpos = _wpi_getprivateprofileint( hini, imgedSection, "tool_xpos", ImgedConfigInfo.tool_xpos, iniPath ); ImgedConfigInfo.tool_ypos = _wpi_getprivateprofileint( hini, imgedSection, "tool_ypos", ImgedConfigInfo.tool_ypos, iniPath ); /* location of the color palette */ ImgedConfigInfo.pal_xpos = _wpi_getprivateprofileint( hini, imgedSection, "pal_xpos", ImgedConfigInfo.pal_xpos, iniPath ); ImgedConfigInfo.pal_ypos = _wpi_getprivateprofileint( hini, imgedSection, "pal_ypos", ImgedConfigInfo.pal_ypos, iniPath ); /* location of the view window */ ImgedConfigInfo.view_xpos = _wpi_getprivateprofileint( hini, imgedSection, "view_xpos", ImgedConfigInfo.view_xpos, iniPath ); ImgedConfigInfo.view_ypos = _wpi_getprivateprofileint( hini, imgedSection, "view_ypos", ImgedConfigInfo.view_ypos, iniPath ); /* * Now we want to make sure nothing is off the screen! */ if( ImgedConfigInfo.x_pos + ImgedConfigInfo.width > x ) { ImgedConfigInfo.width = x - ImgedConfigInfo.x_pos - 2; } if( ImgedConfigInfo.y_pos + ImgedConfigInfo.height > y ) { ImgedConfigInfo.height = y - ImgedConfigInfo.y_pos - 2; } if( ImgedConfigInfo.tool_xpos > x - sysbox_width - 2 ) { ImgedConfigInfo.tool_xpos = x - TBWidth - 1; } if( ImgedConfigInfo.tool_ypos > y - sysbox_width - 2 ) { ImgedConfigInfo.tool_ypos = y - TBHeight - 1; } if( ImgedConfigInfo.pal_xpos > x - sysbox_width - 2 ) { ImgedConfigInfo.pal_xpos = x - CP_WIDTH - 1; } if( ImgedConfigInfo.pal_ypos > y - sysbox_width - 2 ) { ImgedConfigInfo.pal_ypos = y - CP_HEIGHT - 1; } if( ImgedConfigInfo.view_xpos > x - sysbox_width - 2 ) { ImgedConfigInfo.view_xpos = x - sysbox_width - 5; } if( ImgedConfigInfo.pal_ypos > y - sysbox_width - 2 ) { ImgedConfigInfo.pal_ypos = y - sysbox_width - 5; } } /* loadPositionValues */
/* * ResizeChild - resizes the draw area of the child window. */ void ResizeChild( WPI_PARAM2 lparam, HWND hwnd, BOOL firsttime ) { short min_width; short width; short height; img_node *node; short x_adjustment; short y_adjustment; short new_width; short new_height; WPI_POINT point_size; WPI_POINT max; HWND frame; HMENU hmenu; WPI_RECT rc; WPI_RECT rect; frame = _wpi_getframe( hwnd ); width = LOWORD( lparam ); #ifdef __OS2_PM__ height = SHORT2FROMMP( lparam ); #else height = HIWORD( lparam ); #endif GetClientRect( hwnd, &rc ); GetWindowRect( hwnd, &rect ); if( frame ) { GetClientRect( frame, &rc ); GetWindowRect( frame, &rect ); } max.x = _wpi_getsystemmetrics( SM_CXSCREEN ); max.y = _wpi_getsystemmetrics( SM_CYSCREEN ); x_adjustment = _wpi_getwidthrect( rect ) - _wpi_getwidthrect( rc ); y_adjustment = _wpi_getheightrect( rect ) - _wpi_getheightrect( rc ); #if 1 min_width = MIN_DRAW_WIN_WIDTH; #else min_width = (short)(2*_wpi_getsystemmetrics(SM_CXSIZE)) + x_adjustment + 8; // fudge factor to allow some of title bar to show #endif #ifdef __OS2_PM__ ++y_adjustment; #endif node = SelectImage( hwnd ); if (!node) return; // the following assumes that max.x >> min_width point_size.x = min( max.x / node->width, width / node->width ); point_size.x = max( min_width / node->width + 1, point_size.x ); point_size.y = min( max.y / node->height, height / node->height ); point_size.y = max( 1, point_size.y ); if( ImgedConfigInfo.square_grid ) { point_size.x = min( point_size.x, point_size.y ); if( point_size.x < ( min_width / node->width + 1 ) ) { point_size.x = min_width / node->width + 1; } if( point_size.x > ( max.y / node->height ) ) { hmenu = GetMenu( _wpi_getframe(HMainWindow) ); CheckSquareGrid( hmenu ); } else { point_size.y = point_size.x; } } new_width = (short)(point_size.x * node->width + x_adjustment); new_height = (short)(point_size.y * node->height + y_adjustment); pointSize = point_size; if( (pointSize.x*node->width != width) || (pointSize.y*node->height != height) ) { SetWindowPos( frame, HWND_TOP, 0, 0, new_width, new_height, SWP_SIZE | SWP_ZORDER | SWP_NOMOVE | SWP_SHOWWINDOW); SetGridSize( pointSize.x, pointSize.y ); } if( !firsttime ) { BlowupImage( node->hwnd, NULL ); } } /* ResizeChild */
/* * FindOrigin - "cascade" the windows to find the placement of the new MDI child * - origin is expected to come in as (0, 0) or the equivalent for PM */ void FindOrigin( WPI_POINT *new_origin ) { WPI_ENUMPROC fp; int image_count; int i, j; WPI_POINT temp; WPI_RECT proposed; WPI_RECTDIM width; int base; image_count = DoImagesExist(); if( image_count == 0 ) { return; } #ifdef __OS2_PM__ imageMax = image_count; #endif windowCoords = MemAlloc( image_count * sizeof( WPI_POINT ) ); windowIndex = 0; fp = _wpi_makeenumprocinstance( GetPosProc, Instance ); _wpi_enumchildwindows( ClientWindow, fp, 0L ); _wpi_freeprocinstance( fp ); /* * I'm just using a simple bubble sort ... we're using small amounts of data */ for( i = 0; i < image_count; i++ ) { for( j = 0; j < image_count - i - 1; j++ ) { if( windowCoords[j].x > windowCoords[j + 1].x ) { temp = windowCoords[j]; windowCoords[j] = windowCoords[j + 1]; windowCoords[j + 1] = temp; } } } /* * Minimized windows will have coordinates set to negative, and we only * want non-minimized windows. */ for( base = 0; base < image_count; base++ ) { if( windowCoords[base].x >= 0 ) { break; } } if( base >= image_count ) { MemFree( windowCoords ); return; } width = _wpi_getsystemmetrics( SM_CYCAPTION ); #ifndef __OS2_PM__ _wpi_setintrectvalues( &proposed, new_origin->x, new_origin->y, new_origin->x + width, new_origin->y + width ); #else _wpi_setrectvalues( &proposed, new_origin->x, new_origin->y - 1, new_origin->x + width, new_origin->y + width - 1 ); #endif /* * Try to place at the origin passed in if we can. */ if( !_wpi_ptinrect( &proposed, windowCoords[base] ) ) { MemFree( windowCoords ); return; } for( i = base; i < image_count - 1; i++ ) { if( windowCoords[i + 1].x - windowCoords[i].x > 2 * width ) { break; } } temp.x = windowCoords[i].x + width; #ifndef __OS2_PM__ temp.y = windowCoords[i].x + width; #else temp.y = windowCoords[i].y - width; #endif _wpi_getclientrect( ClientWindow, &proposed ); #ifndef __OS2_PM__ if( !_wpi_ptinrect( &proposed, temp ) ) { return; } else { new_origin->x = temp.x; new_origin->y = temp.y; } #else new_origin->x = temp.x; new_origin->y = temp.y; #endif MemFree( windowCoords ); } /* FindOrigin */
WPI_MRESULT CALLBACK GraphWndProc( HWND Wnd, WPI_MSG message, WPI_PARAM1 wParam, WPI_PARAM2 lParam ) //============================================================= { WPI_PRES Win_dc; PAINTSTRUCT ps; int width, height; int x, y, t; int h_minpos, h_maxpos, h_currpos; int v_minpos, v_maxpos, v_currpos; WPI_RECTDIM left, top, right, bottom; WPI_RECT rect; struct ScrollStruct scroll_info; LPWDATA w; HWND frame; #if defined( __OS2__ ) int wheight; WPI_RECT wrect; #endif w = _GetWindowData( Wnd ); if( w == NULL ) { return( _wpi_defwindowproc( Wnd, message, wParam, lParam ) ); } #if defined( __OS2__ ) frame = w->frame; #else frame = Wnd; #endif switch( message ) { #if defined( __WINDOWS__ ) case WM_SETFOCUS: SetFocus( _MainWindow ); case WM_SYSCOMMAND: case WM_MOUSEACTIVATE: _MakeWindowActive( w ); return( _wpi_defwindowproc( Wnd, message, wParam, lParam ) ); case WM_KILLFOCUS: if( ( wParam != NULL) && ( wParam != _MainWindow ) ) { _ShowWindowActive( NULL, w ); } return( _wpi_defwindowproc( Wnd, message, wParam, lParam ) ); #else case WM_FOCUSCHANGE: case WM_SYSCOMMAND: _MakeWindowActive( w ); return( _wpi_defwindowproc( Wnd, message, wParam, lParam ) ); #endif case WM_PAINT: // Setup Win_dc = _wpi_beginpaint( Wnd, NULLHANDLE, &ps ); _wpi_torgbmode( Win_dc ); _wpi_getpaintrect( &ps, &rect ); _wpi_getwrectvalues( rect, &left, &top, &right, &bottom ); width = _wpi_getwidthrect( rect ); height = _wpi_getheightrect( rect ); // Copy from the memory dc to the screen #if defined( __OS2__ ) GetClientRect( Wnd, &wrect ); wheight = _wpi_getheightrect( wrect ); y = _GetPresHeight() - wheight - _BitBlt_Coord.ycoord + top; #else y = _BitBlt_Coord.ycoord + top; #endif _wpi_bitblt( Win_dc, left, top, width, height, _Mem_dc, _BitBlt_Coord.xcoord + left, y, SRCCOPY ); //Cleanup _wpi_endpaint( Wnd, Win_dc, &ps ); break; #if defined( __OS2__ ) case WM_CLOSE: WinDestroyWindow( w->frame ); return( 0 ); #endif case WM_DESTROY: // free the system resources allocated if( _Mem_dc ){ _wpi_deletecliprgn( _Mem_dc, _ClipRgn ); _wpi_deletecompatiblepres( _Mem_dc, _Hdc ); if( _Mem_bmp ){ _wpi_deletebitmap( _Mem_bmp ); if( !_IsStockFont() ){ _wpi_f_deletefont( _CurFnt ); } } #if defined( __OS2__ ) WinSendMsg( _GetWinMenuHandle(), ( ULONG )MM_DELETEITEM, MPFROM2SHORT( ( w->handles[0] + DID_WIND_STDIO ), FALSE ), 0 ); #endif _DestroyAWindow( w ); } break; case WM_VSCROLL: scroll_info = getscrolldata( frame, SB_VERT ); CalPos( &scroll_info, wParam, lParam, &v_currpos, &y ); // Make sure we have to refresh first if( _BitBlt_Coord.ycoord != y ) { _BitBlt_Coord.ycoord = y; _wpi_setscrollpos( frame, SB_VERT, v_currpos, TRUE ); _wpi_invalidaterect( Wnd, NULL, 0 ); _wpi_updatewindow( Wnd ); } return( _wpi_defwindowproc( Wnd, message, wParam, lParam ) ); case WM_HSCROLL: scroll_info = getscrolldata( frame, SB_HORZ ); CalPos( &scroll_info, wParam, lParam, &h_currpos, &x ); // make sure we need to refresh first if( _BitBlt_Coord.xcoord != x ) { _BitBlt_Coord.xcoord = x; _wpi_setscrollpos( frame, SB_HORZ, h_currpos, TRUE ); _wpi_invalidaterect( Wnd, NULL, 0 ); _wpi_updatewindow( Wnd ); } return( _wpi_defwindowproc( Wnd, message, wParam, lParam ) ); case WM_SIZE: x = _wpi_getsystemmetrics( SM_CXSCREEN ); y = _wpi_getsystemmetrics( SM_CYSCREEN ); _wpi_getscrollrange( frame, SB_VERT, &v_minpos, &v_maxpos ); _wpi_getscrollrange( frame, SB_HORZ, &h_minpos, &h_maxpos ); _wpi_getclientrect( Wnd, &rect ); _wpi_getrectvalues( rect, &left, &top, &right, &bottom ); height = bottom - top + 1; width = right - left + 1; if( width >= x ) { // hide the scroll bar #if defined( __OS2__ ) WinShowWindow( WinWindowFromID( frame, FID_HORZSCROLL ), FALSE ); #else ShowScrollBar( Wnd, SB_HORZ, FALSE ); #endif _BitBlt_Coord.xcoord = 0; h_currpos = 0; } else { // if the window isn't as big as the device context // show the scroll bar t = x - width + 1; if( x - _BitBlt_Coord.xcoord + 1 < width ) { _BitBlt_Coord.xcoord = x - width + 1; } if( _BitBlt_Coord.xcoord == t ) { h_currpos = h_maxpos; } else { h_currpos = CalScrollAmt( h_maxpos, h_minpos, _BitBlt_Coord.xcoord, x, width ); } #if defined( __OS2__ ) WinShowWindow( WinWindowFromID( frame, FID_HORZSCROLL ), TRUE ); #else ShowScrollBar( Wnd, SB_HORZ, 1 ); #endif } if( height >= y ) { // hide the scroll bar #if defined( __OS2__ ) WinShowWindow( WinWindowFromID( frame, FID_VERTSCROLL ), FALSE ); #else ShowScrollBar( Wnd, SB_VERT, 0 ); #endif _BitBlt_Coord.ycoord = 0; v_currpos = 0; } else { // if the the window isn't as big as the device context // then show the scroll bar t = y - height + 1; if( y - _BitBlt_Coord.ycoord + 1 < height ) { _BitBlt_Coord.ycoord = t; } if( _BitBlt_Coord.ycoord == t ) { v_currpos = v_maxpos; } else { v_currpos = CalScrollAmt( v_maxpos, v_minpos, _BitBlt_Coord.ycoord, y, height ); } #if defined( __OS2__ ) WinShowWindow( WinWindowFromID( frame, FID_VERTSCROLL ), TRUE ); #else ShowScrollBar( Wnd, SB_VERT, 1 ); #endif } // Adjust the scroll bar thumbs' positions _wpi_setscrollpos( frame, SB_HORZ, h_currpos, TRUE ); _wpi_setscrollpos( frame, SB_VERT, v_currpos, TRUE ); #if defined( __OS2__ ) Win_dc = WinBeginPaint( Wnd, NULL, &rect ); WinFillRect( Win_dc, &rect, CLR_BLACK ); WinEndPaint( Win_dc ); #endif _wpi_invalidaterect( Wnd, NULL, 0 ); break; default: return( _wpi_defwindowproc( Wnd, message, wParam, lParam ) ); } return( NULL ); }
/* * DrawAreaWinProc - window procedure for the drawing area window * - this window is an MDI window */ MRESULT CALLBACK DrawAreaWinProc( HWND hwnd, WPI_MSG msg, WPI_PARAM1 wparam, WPI_PARAM2 lparam ) { static WPI_POINT start_pt = { -1, -1 }; static WPI_POINT end_pt = { -1, -1 }; static WPI_POINT prev_pt = { -1, -1 }; static WPI_POINT new_pt = { -1, -1 }; static WPI_POINT pt1; static BOOL flbuttondown = FALSE; static BOOL frbuttondown = FALSE; static BOOL fdraw_shape = FALSE; static BOOL firsttime; static BOOL wasicon; int mousebutton; WPI_POINT pointsize; WPI_POINT pt2; #ifndef __OS2_PM__ CREATESTRUCT *cs; MDICREATESTRUCT *mdi_cs; MINMAXINFO *minmax; #endif img_node *node; int i; switch ( msg ) { case WM_CREATE: #ifndef __OS2_PM__ cs = (CREATESTRUCT __FAR *)lparam; mdi_cs = (MDICREATESTRUCT __FAR *)cs->lpCreateParams; node = (img_node *)mdi_cs->lParam; for( i = 0; i < node->num_of_images; i++ ) { node[i].hwnd = hwnd; } AddImageNode( node ); CreateUndoStack( node ); setTheCursor( -1, hwnd ); wasicon = FALSE; #endif firsttime = TRUE; i = i; return( 0 ); case WM_MDIACTIVATE: if( IMGED_GET_MDI_FACTIVATE( hwnd, wparam, lparam ) ) { if( _wpi_isiconic( hwnd ) ) { wasicon = TRUE; break; } else { wasicon = FALSE; FocusOnImage( hwnd ); } } return( 0 ); #ifndef __OS2_PM__ case WM_GETMINMAXINFO: node = SelectImage( hwnd ); if( node != NULL ) { minmax = (MINMAXINFO *)lparam; minmax->ptMinTrackSize.x = node->width + 2 * _wpi_getsystemmetrics( SM_CXFRAME ); minmax->ptMinTrackSize.y = node->height + 2 * _wpi_getsystemmetrics( SM_CYFRAME ) + _wpi_getsystemmetrics( SM_CYCAPTION ) - 1; } break; #endif case UM_SHOWVIEWWINDOW: ShowViewWindows( hwnd ); return 0; case WM_SIZE: if ( _imgwpi_issizerestored( wparam ) ) { ResizeChild( lparam, hwnd, firsttime ); firsttime = FALSE; if( wasicon ) { FocusOnImage( hwnd ); wasicon = FALSE; } #ifndef __OS2_PM__ } else if ( _imgwpi_issizeminimized( wparam ) ) { node = SelectImage( hwnd ); HideViewWindow( hwnd ); DeleteActiveImage(); ClearImageText(); SendMessage( ClientWindow, WM_MDINEXT, (WPARAM)(LPVOID)hwnd, 0L ); wasicon = TRUE; #endif } return( 0 ); #ifndef __OS2_PM__ case WM_CHAR: pointsize = GetPointSize( hwnd ); if( LOWORD( wparam ) == ESC_CHAR ) { if( !(lparam & 0x40000000) ) { switch( toolType ) { case IMGED_PASTE: fdraw_shape = FALSE; flbuttondown = FALSE; frbuttondown = FALSE; DontPaste( hwnd, &pt1, pointsize ); break; case IMGED_LINE: case IMGED_RECTO: case IMGED_RECTF: case IMGED_CIRCLEO: case IMGED_CIRCLEF: case IMGED_CLIP: if( !flbuttondown && !frbuttondown ) { break; } fdraw_shape = FALSE; flbuttondown = FALSE; frbuttondown = FALSE; if( toolType == IMGED_LINE ) { OutlineLine( hwnd, &start_pt, &prev_pt, &new_pt, TRUE ); } else if( toolType == IMGED_CLIP ) { OutlineClip( hwnd, &start_pt, &prev_pt, &new_pt, TRUE ); SetRectExists( FALSE ); } else { OutlineRegion( hwnd, &start_pt, &prev_pt, &new_pt, TRUE ); } break; default: break; } } } return( 0 ); #endif case WM_MOUSEMOVE: pointsize = GetPointSize( hwnd ); #ifdef __OS2_PM__ WinSetPointer( HWND_DESKTOP, hCursor[cursorIndex] ); #endif IMGED_MAKEPOINT( wparam, lparam, new_pt ); switch( toolType ) { case IMGED_SNAP: #ifndef __OS2_PM__ OutlineSnap(); #endif break; case IMGED_PASTE: pt1.x = new_pt.x / pointsize.x; pt1.y = new_pt.y / pointsize.y; pt2.x = prev_pt.x / pointsize.x; pt2.y = prev_pt.y / pointsize.y; if( pt1.x != pt2.x || pt1.y != pt2.y ) { DragClipBitmap( hwnd, &pt1, pointsize ); } SetPosInStatus( &new_pt, &pointsize, hwnd ); break; case IMGED_FREEHAND: case IMGED_BRUSH: if( flbuttondown ) { Paint( hwnd, &prev_pt, &new_pt, LMOUSEBUTTON ); } else if( frbuttondown ) { Paint( hwnd, &prev_pt, &new_pt, RMOUSEBUTTON ); } SetPosInStatus( &new_pt, &pointsize, hwnd ); break; case IMGED_LINE: case IMGED_RECTO: case IMGED_RECTF: case IMGED_CIRCLEO: case IMGED_CIRCLEF: case IMGED_CLIP: if( flbuttondown || frbuttondown ) { if( new_pt.x / pointsize.x != end_pt.x / pointsize.x || new_pt.y / pointsize.y != end_pt.y / pointsize.y ) { if( toolType == IMGED_LINE ) { OutlineLine( hwnd, &start_pt, &new_pt, &prev_pt, FALSE ); } else if( toolType == IMGED_CLIP ) { OutlineClip( hwnd, &start_pt, &new_pt, &prev_pt, FALSE ); } else { OutlineRegion( hwnd, &start_pt, &new_pt, &prev_pt, FALSE ); } end_pt = new_pt; SetSizeInStatus( hwnd, &start_pt, &new_pt, &pointsize ); } } else { SetPosInStatus( &new_pt, &pointsize, hwnd ); } break; case IMGED_FILL: SetPosInStatus( &new_pt, &pointsize, hwnd ); break; default: SetPosInStatus( &new_pt, &pointsize, hwnd ); break; } prev_pt = new_pt; return( 0 ); case WM_LBUTTONDOWN: case WM_RBUTTONDOWN: pointsize = GetPointSize( hwnd ); SetCapture( hwnd ); if( msg == WM_LBUTTONDOWN ) { if( frbuttondown ) { break; } #ifdef __OS2_PM__ node = GetCurrentNode(); if( hwnd != node->hwnd ) { break; } #endif flbuttondown = TRUE; mousebutton = LMOUSEBUTTON; } else { if( flbuttondown ) { break; } node = GetCurrentNode(); if( hwnd != node->hwnd ) { break; } frbuttondown = TRUE; mousebutton = RMOUSEBUTTON; } fdraw_shape = TRUE; IMGED_MAKEPOINT( wparam, lparam, start_pt ); IMGED_MAKEPOINT( wparam, lparam, new_pt ); switch( toolType ) { case IMGED_SNAP: #ifndef __OS2_PM__ TransferImage( hwnd ); #endif fdraw_shape = FALSE; flbuttondown = FALSE; frbuttondown = FALSE; break; case IMGED_FREEHAND: case IMGED_BRUSH: BeginFreeHand( hwnd ); DrawSinglePoint( hwnd, &start_pt, mousebutton ); break; case IMGED_LINE: IMGED_MAKEPOINT( wparam, lparam, end_pt ); OutlineLine( hwnd, &start_pt, &new_pt, &prev_pt, TRUE ); break; case IMGED_RECTO: case IMGED_RECTF: case IMGED_CIRCLEO: case IMGED_CIRCLEF: IMGED_MAKEPOINT( wparam, lparam, end_pt ); OutlineRegion( hwnd, &start_pt, &new_pt, &prev_pt, TRUE ); break; case IMGED_CLIP: IMGED_MAKEPOINT( wparam, lparam, end_pt ); RedrawPrevClip( hwnd ); OutlineClip( hwnd, &start_pt, &new_pt, &prev_pt, TRUE ); break; case IMGED_FILL: FillArea( &start_pt, mousebutton ); RecordImage( hwnd ); break; case IMGED_HOTSPOT: SetIsSaved( hwnd, FALSE ); prev_pt.x = start_pt.x / pointsize.x; prev_pt.y = start_pt.y / pointsize.y; SetNewHotSpot( &prev_pt ); break; default: break; } prev_pt = new_pt; return 0; case WM_LBUTTONUP: case WM_RBUTTONUP: pointsize = GetPointSize( hwnd ); IMGED_MAKEPOINT( wparam, lparam, end_pt ); IMGED_MAKEPOINT( wparam, lparam, new_pt ); if( msg == WM_LBUTTONUP ) { mousebutton = LMOUSEBUTTON; } else { mousebutton = RMOUSEBUTTON; } if( fdraw_shape ) { switch( toolType ) { case IMGED_PASTE: PasteImage( &start_pt, pointsize, hwnd ); flbuttondown = FALSE; frbuttondown = FALSE; break; case IMGED_FREEHAND: case IMGED_BRUSH: if( flbuttondown || frbuttondown ) { EndFreeHand( hwnd ); RecordImage( hwnd ); } break; case IMGED_LINE: DrawLine( hwnd, &start_pt, &end_pt, mousebutton ); RecordImage( hwnd ); break; case IMGED_RECTO: case IMGED_RECTF: case IMGED_CIRCLEO: case IMGED_CIRCLEF: DisplayRegion( hwnd, &start_pt, &end_pt, mousebutton ); RecordImage( hwnd ); break; case IMGED_CLIP: SetClipRect( hwnd, &start_pt, &end_pt, pointsize ); break; default: break; } fdraw_shape = FALSE; } ReleaseCapture(); flbuttondown = FALSE; frbuttondown = FALSE; prev_pt = new_pt; return( 0 ); case WM_PAINT: RepaintDrawArea( hwnd ); return( 0 ); case WM_QUERYENDSESSION: case WM_CLOSE: if( lastChanceSave( hwnd ) ) { CloseCurrentImage( hwnd ); return( (MRESULT)1 ); } else { return( (MRESULT)0 ); } #ifndef __OS2_PM__ case WM_DESTROY: SetCursor( LoadCursor( NULL, IDC_ARROW ) ); return( 0 ); #endif default: break; } return( _imgwpi_defMDIchildproc( hwnd, msg, wparam, lparam ) ); } /* DrawAreaWinProc */