/******************************************************************* * * File name - ANOATTR.C * * Description: * O/i 3.7 Annotation attribute dialog box routine. * * Initial revision - 2/25/94 * * Author - Kendra Roy ******************************************************************/ #include "oiui.h" #include #include "ui.h" #include #include #define OIOP_TP_NULL_STAMP 208 #define BUFLEN 128 extern char HelpFileName[]; extern DWORD aIDs[]; extern COLORREF BkBrushClr; static LPOI_UI_AttrStruct lpAttrStruct; static LPOITP_STAMPS lpLocalStampStruct; static OITP_STAMP WorkingStamp; static LPOIAN_MARK_ATTRIBUTES lpAttribs; static HBRUSH hBrush[TP_CUSCLRCNT]; static COLORREF aclrCust[TP_CUSCLRCNT]; static COLORREF clr1, clr2; static UINT uLineWidth; static HWND hLineWidthBox; RECT rectArray[TP_CUSCLRCNT]; // Position Information UINT uClrCount,uCurrentColor,uSelectedColor; UINT uLineExists = FALSE; #define MAXSTRLEN 100 void WINAPI TextUpdateFont(HWND hControID,LPOITP_STAMP lpStamp,HFONT far* lpFont); UINT PASCAL CheckErr (HWND hWnd, UINT ret_error) { char strbuff [MAXSTRLEN * 2]; /* External string buffer */ char msgbuf [MAXSTRLEN]; /* Auxiliary string buffer */ //char auxbuff [MAXSTRLEN]; /* Auxiliary string buffer */ if (!IsWindow(hWnd) && hWnd) /* check if window handle is valid */ return (ret_error); if (ret_error != SUCCESS && ret_error != CANCELPRESSED) { /* Get resource string for error code */ LoadString (hInst, ret_error, strbuff, sizeof(strbuff)); LoadString(hInst, ERROR_TITLE, msgbuf, sizeof(msgbuf)) ; /* Display discription and error code */ MessageBox (hWnd, strbuff, msgbuf, MB_OK |MB_ICONEXCLAMATION); } return (ret_error); /* return the error code passed in */ } /****************************************************************** * ChooseFontDlgProc * * DESCRIPTION: Hook function for the ChooseFont common dialog * * INPUTS: HWND hDlg - Handle to dialog window * unsigned message - Message passed to dialog window * WORD wParam - Additional message information. * LONG lParam - Annotation mark attributes structure address * * RETURNS: (BOOL WINAPI) Return code from dialog box * TRUE - dialog procedure handled the message. * FALSE - dialog procedure did not handle the message. * *****************************************************************************/ UINT WINAPI ChooseFontDlgProc(HWND hDlg, unsigned iMessage, WPARAM wParam, LONG lParam) { char szTitle [50]; LPOIAN_MARK_ATTRIBUTES lpAttribs; switch(iMessage) { case WM_INITDIALOG: // Set the dialog box title. // Note: lParam is our CHOOSEFONT argument structure address, and // CHOOSEFONT.lCustData points to the mark attributes structure lpAttribs = (LPOIAN_MARK_ATTRIBUTES)(((CHOOSEFONT *) lParam)->lCustData); switch (lpAttribs->uType) { case OIOP_AN_TEXT: LoadString(hInst,TEXT_FONT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; case OIOP_AN_TEXT_FROM_A_FILE: LoadString(hInst,TFILE_FONT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; case OIOP_AN_ATTACH_A_NOTE: LoadString(hInst,TNOTE_FONT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; case OIOP_AN_TEXT_STAMP: case OIOP_TP_NULL_STAMP: LoadString(hInst,TSTAMP_FONT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; default: return FALSE; /* Didn't process the message */ break; } SetWindowText(hDlg,szTitle); break; default: return FALSE; /* Didn't process the message */ break; } return TRUE; } /****************************************************************** * ChooseColorDlgProc * * DESCRIPTION: Hook function for the ChooseColor common dialog * * INPUTS: HWND hDlg - Handle to dialog window * unsigned message - Message passed to dialog window * WORD wParam - Additional message information. * LONG lParam - Annotation mark attributes structure address * * RETURNS: (BOOL WINAPI) Return code from dialog box * TRUE - dialog procedure handled the message. * FALSE - dialog procedure did not handle the message. * *****************************************************************************/ UINT WINAPI ChooseColorDlgProc(HWND hDlg, unsigned iMessage, WPARAM wParam, LONG lParam) { char szTitle [50]; LPOIAN_MARK_ATTRIBUTES lpAttribs; switch(iMessage) { case WM_INITDIALOG: // Set the dialog box title. // Note: lParam is our CHOOSECOLOR argument structure address, and // CHOOSECOLOR.lCustData points to the mark attributes structure lpAttribs = (LPOIAN_MARK_ATTRIBUTES)(((CHOOSECOLOR *) lParam)->lCustData); switch (lpAttribs->uType) { case OIOP_AN_LINE: if (lpAttribs->bHighlighting) LoadString(hInst,HLINE_COLOR_TITLE,(LPSTR) szTitle,sizeof(szTitle)); else LoadString(hInst,LINE_COLOR_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; case OIOP_AN_FREEHAND: LoadString(hInst,FLINE_COLOR_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; case OIOP_AN_ATTACH_A_NOTE: LoadString(hInst,TNOTE_COLOR_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; case OIOP_AN_FILLED_RECT: if (lpAttribs->bHighlighting) LoadString(hInst,HRECT_COLOR_TITLE,(LPSTR) szTitle,sizeof(szTitle)); else LoadString(hInst,RECT_COLOR_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; case OIOP_AN_HOLLOW_RECT: LoadString(hInst,ORECT_COLOR_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; default: return FALSE; /* Didn't process the message */ break; } SetWindowText(hDlg,szTitle); break; default: return FALSE; /* Didn't process the message */ break; } return TRUE; } /****************************************************************** * AttrLineDlgProc * * DESCRIPTION: Line attribute dialog box routine * * INPUTS: HWND hDlg - Handle to dialog window * unsigned message - Message passed to dialog window * WORD wParam - Additional message information. * LONG lParam - Pointer to the tool palette structure * * RETURNS: (BOOL) Return code from dialog box * TRUE - dialog procedure handled the message. * FALSE - dialog procedure did not handle the message. * * DATE: FEB.25, 1994 * AUTHOR: Kendra Roy * *****************************************************************************/ BOOL WINAPI AttrLineDlgProc(HWND hDlg, unsigned iMessage, WPARAM wParam, LONG lParam) { CHOOSECOLOR cc; COLORREF BrushClr; UINT i,error_status; DWORD dwError = 0; char szTitle [50]; HDC hDC; switch(iMessage) { case WM_INITDIALOG: lpAttrStruct = (LPOI_UI_AttrStruct)lParam; lpAttribs = lpAttrStruct->lpAttrib; uClrCount = TP_CUSCLRCNT; // Set the dialog box title. switch(lpAttribs->uType) /* Put the correct caption in the title bar.*/ { case OIOP_AN_LINE: if (lpAttribs->bHighlighting == TRUE) LoadString(hInst,HILINEATT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); else LoadString(hInst,LINEATT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; case OIOP_AN_FREEHAND: LoadString(hInst,FLINEATT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; case OIOP_AN_HOLLOW_RECT: LoadString(hInst,HORECTATT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); break; } SetWindowText(hDlg,szTitle); uLineExists = TRUE; GetCusDefColors(lpAttrStruct->lpColor, aclrCust, hBrush); // Get the custom define colors. hDC = GetDC (GetDlgItem (hDlg,IDC_USER1)); BrushClr = GetSysColor(COLOR_3DFACE); SetBkColor(hDC,BrushClr); for (i=0;iuLineSize; // Retrieve the line width. //SetDlgItemInt(hDlg,ID_UPDOWN, uLineWidth, FALSE); hLineWidthBox = GetDlgItem(hDlg,ID_LineWidthBox); // Get size and placement info to display the color palette. GetPalRectInfo(hDlg, rectArray); // set the updown control range SendDlgItemMessage( hDlg,IDC_UPDOWNSPIN, UDM_SETRANGE, 0L, MAKELONG(MAX_LINE_WIDTH,1)); SendDlgItemMessage( hDlg,IDC_UPDOWNSPIN, UDM_SETPOS, 0L, MAKELONG(uLineWidth,0)); // set the deafult value in the edit box of updown control SetDlgItemInt( hDlg, ID_UPDOWN, uLineWidth, FALSE); // Take care of the transparent check box if (lpAttrStruct->bTransVisible == 1) // ShowWindow(GetDlgItem(hDlg,IDC_COLOR_TRANS), SW_HIDE); //else { ShowWindow(GetDlgItem(hDlg,IDC_COLOR_TRANS), SW_SHOW); if (lpAttribs->bHighlighting == 0) CheckDlgButton(hDlg,IDC_COLOR_TRANS,0); else CheckDlgButton(hDlg,IDC_COLOR_TRANS,1); } break; case WM_PAINT: PaintTheLine(hLineWidthBox, uLineWidth, clr1); PaintColorPalette(hDlg, hBrush, rectArray); // Paint the color palette. SendDlgItemMessage(hDlg, IDC_USER1, WM_PAINT, 0, 0); // paint the selection box return FALSE; break; case WM_COMMAND: switch(LOWORD(wParam)) { case ID_UPDOWN: // If the number in this field is changed, we need to // update the sample line. switch (HIWORD (wParam)) { case EN_SETFOCUS: break; case EN_KILLFOCUS: PaintTheLine(hLineWidthBox, uLineWidth, clr1); break; case EN_CHANGE: if (GetFocus() == GetDlgItem(hDlg,ID_UPDOWN)) { // the cursor on the left side, force it to the right of the char SendMessage( GetDlgItem(hDlg,ID_UPDOWN), EM_SETSEL, 0, -1); SendMessage( GetDlgItem(hDlg,ID_UPDOWN), EM_SETSEL, (WPARAM)-1, -1); } uLineWidth = GetDlgItemInt(hDlg, ID_UPDOWN, (int*)&error_status, 0); SendDlgItemMessage( hDlg,IDC_UPDOWNSPIN, UDM_SETPOS, 0, MAKELONG(uLineWidth,0)); PaintTheLine(hLineWidthBox, uLineWidth, clr1); break; } break; case ID_PaletteCmd: _fmemset(&cc, 0, sizeof(CHOOSECOLOR)); cc.lStructSize = sizeof(CHOOSECOLOR); cc.hwndOwner = hDlg; cc.rgbResult = clr1; cc.lpCustColors = aclrCust; cc.lpfnHook = ChooseColorDlgProc; cc.lCustData = (LPARAM)lpAttribs; cc.Flags = CC_RGBINIT | CC_ENABLEHOOK; if (ChooseColor(&cc) == 0) /* error */ { dwError = CommDlgExtendedError(); CheckErr(hDlg, (WORD) dwError); break; } // Reset the custom colors and hBrush's upon return. hDC = GetDC(hLineWidthBox); // Use this to get a solid color for (i=0;i MAX_LINE_WIDTH) { uLineWidth = MAX_LINE_WIDTH; SetDlgItemInt(hDlg,ID_UPDOWN, MAX_LINE_WIDTH, FALSE); break; } SetCusDefColors(lpAttrStruct->lpColor, aclrCust, hBrush); // Get the custom define colors. SetColor1(lpAttribs, clr1); // Save the chosen line width for the tool. lpAttribs->uLineSize = uLineWidth; // take care of the transparent check box if (lpAttrStruct->bTransVisible == 1) { if (IsDlgButtonChecked(hDlg,IDC_COLOR_TRANS) == 0) // not check lpAttribs->bHighlighting = 0; else lpAttribs->bHighlighting = 1; } EndDialog(hDlg, SUCCESS); break; case IDCANCEL: for (i=0;iiContextType == HELPINFO_WINDOW) { WinHelp(((LPHELPINFO)lParam)->hItemHandle,HelpFileName,HELP_WM_HELP, (DWORD)(LPVOID)aIDs); } break; case WM_CONTEXTMENU: WinHelp((HWND)wParam,HelpFileName,HELP_CONTEXTMENU, (DWORD)(LPVOID)aIDs); break; default: return FALSE; /* Didn't process the message */ break; } return TRUE; } /* The following two functions: PaintTheLine and PaintSampleLine, do * the drawing of the sample line in all line attribute dialog boxes. * The window handle of the control (hCntrl), the width (uWidth), and * the color (color) of the line to be drawn are passed in. */ void PaintTheLine(HWND hCntrl, UINT uWidth, COLORREF color) { if (hCntrl == 0) return; InvalidateRect(hCntrl, NULL, TRUE); UpdateWindow(hCntrl); PaintSampleLine(hCntrl, uWidth, color); } void PaintSampleLine(HWND hCntrl, UINT uWidth, COLORREF color) { RECT LineRect, BackRect; HPEN hPen; HBRUSH hBrush, hBrOld; HDC hDC; static UINT uLastWidth = 0; POINT point; //COLORREF BrushClr; hDC = GetDC(hCntrl); // Get client coordinates of the line width static control and erase // the background (but leave the border). GetClientRect(hCntrl, &LineRect); BackRect.left = LineRect.left + 1; BackRect.top = LineRect.top + 1; BackRect.right = LineRect.right - 1; BackRect.bottom = LineRect.bottom - 1; //BrushClr = GetSysColor(COLOR_3DFACE); hBrush = CreateSolidBrush(BkBrushClr); //hBrush = GetStockObject (LTGRAY_BRUSH); hBrOld = SelectObject(hDC, hBrush); FillRect(hDC, &BackRect, hBrush); DeleteObject(SelectObject(hDC, hBrOld)); // 18 is the max line width that will fit. if (uLineWidth <= 18) hPen = CreatePen(PS_SOLID, (int)uLineWidth, clr1); else hPen = CreatePen(PS_SOLID, 18, clr1); hPen = SelectObject(hDC, hPen); // Draw the sample line. MoveToEx(hDC, LineRect.left + 10, ((LineRect.bottom) - (LineRect.top))/2,&point); LineTo(hDC, LineRect.right - 10, ((LineRect.bottom) - (LineRect.top))/2); DeleteObject(SelectObject(hDC, hPen)); ReleaseDC(hCntrl, hDC); uLastWidth = uWidth; } /****************************************************************** * AttrRectDlgProc * * DESCRIPTION: Rectangle attribute dialog box routine * * INPUTS: HWND hDlg - Handle to dialog window * unsigned message - Message passed to dialog window * WORD wParam - Additional message information. * LONG lParam - Pointer to the tool palette structure * * RETURNS: (BOOL WINAPI) Return code from dialog box * TRUE - dialog procedure handled the message. * FALSE - dialog procedure did not handle the message. * * DATE: FEB.25, 1994 * AUTHOR: Kendra Roy * *****************************************************************************/ BOOL WINAPI AttrRectDlgProc(HWND hDlg, unsigned iMessage, WPARAM wParam, LONG lParam) { CHOOSECOLOR cc; static UINT i; DWORD dwError = 0; char szTitle [50]; switch(iMessage) { case WM_INITDIALOG: lpAttrStruct = (LPOI_UI_AttrStruct)lParam; lpAttribs = lpAttrStruct->lpAttrib; uClrCount = TP_CUSCLRCNT; // Set the dialog box title. if (lpAttribs->bHighlighting == TRUE) LoadString(hInst,HIRECTATT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); else LoadString(hInst,FRECTATT_TITLE,(LPSTR) szTitle,sizeof(szTitle)); SetWindowText(hDlg,szTitle); uLineExists = FALSE; GetCusDefColors(lpAttrStruct->lpColor, aclrCust, hBrush); // Get the custom define colors. GetColor1(lpAttribs, &clr1); // Get rectangle color. uCurrentColor = FindCurrentColorMatch(clr1, aclrCust, uClrCount); uSelectedColor = uCurrentColor; // Get size and placement info to display the color palette. GetPalRectInfo(hDlg, rectArray); // Take care of the transparent check box if (lpAttrStruct->bTransVisible == 1) // ShowWindow(GetDlgItem(hDlg,IDC_COLOR_TRANS), SW_HIDE); //else { ShowWindow(GetDlgItem(hDlg,IDC_COLOR_TRANS), SW_SHOW); if (lpAttribs->bHighlighting == 0) CheckDlgButton(hDlg,IDC_COLOR_TRANS,0); else CheckDlgButton(hDlg,IDC_COLOR_TRANS,1); } break; case WM_PAINT: // Paint the color palette. PaintColorPalette(hDlg, hBrush, rectArray); SendDlgItemMessage(hDlg, IDC_USER1, WM_PAINT, 0, 0); return FALSE; break; case WM_COMMAND: switch(LOWORD(wParam)) { case ID_PaletteCmd: _fmemset(&cc, 0, sizeof(CHOOSECOLOR)); /* Initialize choosecolor structure. */ cc.lStructSize = sizeof(CHOOSECOLOR); cc.hwndOwner = hDlg; cc.rgbResult = clr1; cc.lpCustColors = aclrCust; cc.lpfnHook = ChooseColorDlgProc; cc.lCustData = (LPARAM)lpAttribs; cc.Flags = CC_RGBINIT | CC_ENABLEHOOK; if (ChooseColor(&cc) == 0) /* error */ { dwError = CommDlgExtendedError(); CheckErr(hDlg, (WORD) dwError); break; } // Reset the custom colors and hBrush's upon return. for (i=0;ibTransVisible == 1) lpAttribs->bHighlighting = IsDlgButtonChecked(hDlg,IDC_COLOR_TRANS); SetCusDefColors(lpAttrStruct->lpColor, aclrCust, hBrush); // Get the custom define colors. SetColor1(lpAttribs, clr1); EndDialog(hDlg, SUCCESS); break; case IDCANCEL: for(i=0;iiContextType == HELPINFO_WINDOW) { WinHelp(((LPHELPINFO)lParam)->hItemHandle,HelpFileName,HELP_WM_HELP, (DWORD)(LPVOID)aIDs); } break; case WM_CONTEXTMENU: WinHelp((HWND)wParam,HelpFileName,HELP_CONTEXTMENU, (DWORD)(LPVOID)aIDs); break; default: return FALSE; /* Didn't process the message */ break; } return TRUE; } /****************************************************************** * AttrNoteDlgProc * * DESCRIPTION: Attatch-A-Note attribute dialog box routine * * INPUTS: HWND hDlg - Handle to dialog window * unsigned message - Message passed to dialog window * WORD wParam - Additional message information. * LONG lParam - Pointer to the tool palette structure * * RETURNS: (BOOL WINAPI) Return code from dialog box * TRUE - dialog procedure handled the message. * FALSE - dialog procedure did not handle the message. * * DATE: FEB.28, 1994 * AUTHOR: Kendra Roy * *****************************************************************************/ BOOL WINAPI AttrNoteDlgProc(HWND hDlg,unsigned iMessage,WPARAM wParam,LONG lParam) { CHOOSECOLOR cc; static LOGFONT lf; static CHOOSEFONT cf; UINT i; DWORD dwError=0; switch(iMessage) { case WM_INITDIALOG: lpAttrStruct = (LPOI_UI_AttrStruct)lParam; lpAttribs = lpAttrStruct->lpAttrib; uClrCount = TP_CUSCLRCNT; uLineExists = FALSE; GetCusDefColors(lpAttrStruct->lpColor, aclrCust, hBrush); // Get the custom define colors. GetColor1(lpAttribs, &clr1); // Get the note color. uCurrentColor = FindCurrentColorMatch(clr1, aclrCust, uClrCount); uSelectedColor = uCurrentColor; GetColor2(lpAttribs, &clr2); // Get the text color. GetFont(lpAttribs,&lf,&cf); // Get the font stuff. // Get size and placement info to display the color palette. GetPalRectInfo(hDlg, rectArray); break; case WM_PAINT: // Paint the color palette. PaintColorPalette(hDlg, hBrush, rectArray); SendDlgItemMessage(hDlg, IDC_USER1, WM_PAINT, 0, 0); return FALSE; break; case WM_COMMAND: switch(LOWORD(wParam)) { case ID_PaletteCmd: _fmemset(&cc, 0, sizeof(CHOOSECOLOR)); /* Initialize choosecolor structure. */ cc.lStructSize = sizeof(CHOOSECOLOR); cc.hwndOwner = hDlg; cc.rgbResult = clr1; cc.lpCustColors = aclrCust; cc.lpfnHook = ChooseColorDlgProc; cc.lCustData = (LPARAM)lpAttribs; cc.Flags = CC_RGBINIT | CC_ENABLEHOOK; if (ChooseColor(&cc) == 0) /* error */ { dwError = CommDlgExtendedError(); CheckErr(hDlg, (WORD) dwError); break; } // Reset the custom colors and hBrush's upon return. for (i=0;ilpColor, aclrCust, hBrush); // Get the custom define colors. SetColor1(lpAttribs, clr1); SetColor2(lpAttribs, clr2); // Save the font information. SetFont(lpAttribs,&lf,&cf); // Close the dialog box. EndDialog(hDlg, SUCCESS); break; case IDCANCEL: for(i=0;iiContextType == HELPINFO_WINDOW) { WinHelp(((LPHELPINFO)lParam)->hItemHandle,HelpFileName,HELP_WM_HELP, (DWORD)(LPVOID)aIDs); } break; case WM_CONTEXTMENU: WinHelp((HWND)wParam,HelpFileName,HELP_CONTEXTMENU, (DWORD)(LPVOID)aIDs); break; default: return FALSE; /* Didn't process the message */ break; } return TRUE; } /***************************************************************************** * ROUTINE: DrawitemProc * * * * DESCRIPTION: Owner draw routine * * * * * INPUTS: hDlg - Handle to dialog window * * lpdis - Pointer to the draw structure * * iCenteringFactor - String position factor * * listID - Window control ID * * * * RETURNS: TRUE - dialog procedure handled the message. * * FALSE - dialog procedure did not handle the message. * * * * DATE: FEB.16, 1994 * * AUTHOR: Jennifer Wu * * * *****************************************************************************/ INT WINAPI DrawItemProc(HWND hDlg, LPDRAWITEMSTRUCT lpdis, short int iCenteringFactor,UINT listID) { HICON hIcon; /* get color stuff for drawing in the path list box */ const DWORD HIGHLIGHTCOLOR = GetSysColor (COLOR_HIGHLIGHT), HIGHLIGHTTEXTCOLOR = GetSysColor (COLOR_HIGHLIGHTTEXT), WINDOWCOLOR = GetSysColor (COLOR_WINDOW), WINDOWTEXTCOLOR = GetSysColor (COLOR_WINDOWTEXT); int cxIcon, cyIcon; int iTextXpos, iTextYpos, iIconXpos, iIconYpos; char szItemString [MAXFILESPECLENGTH]; int MapModePrevious; static int nLastOpenselPos;// used for remember the last openselicon position UINT iStringlen; /* Since we get a WM_DRAWITEM message * for every owner-draw control, we want to make * sure we are handling only the ID_LISTBOX control. */ if ((lpdis->CtlID == listID) && (lpdis->CtlType == ODT_LISTBOX)) { if (lpdis->itemID == -1) { DrawFocusRect (lpdis->hDC, (LPRECT)&lpdis->rcItem); return TRUE; } //If this item is losing the focus, draw the focus rect otherwise let Windows // take care of this focus business.... if (lpdis->itemAction & ODA_FOCUS) { DrawFocusRect (lpdis->hDC, (LPRECT)&lpdis->rcItem); } if (lpdis->itemState & ODA_SELECT) { DrawFocusRect (lpdis->hDC, (LPRECT)&lpdis->rcItem); return TRUE; } if (lpdis->itemState & ODS_SELECTED) { SetTextColor(lpdis->hDC, HIGHLIGHTTEXTCOLOR); SetBkColor(lpdis->hDC, HIGHLIGHTCOLOR); } else { SetTextColor(lpdis->hDC, WINDOWTEXTCOLOR); SetBkColor(lpdis->hDC, WINDOWCOLOR); } // get standard icon size cxIcon = GetSystemMetrics (SM_CXICON); cyIcon = GetSystemMetrics (SM_CYICON); if (lpdis->CtlType == ODT_LISTBOX) SendDlgItemMessage (hDlg, listID, LB_GETTEXT, lpdis->itemID, (LONG)(LPSTR)szItemString); /* * In AddIconToListBox, we saved the Icon handle with LB_SETITEMDATA. * Here, we try to retrieve that very same hIcon. */ if (lpdis->CtlType == ODT_LISTBOX) hIcon = (HICON)(SendDlgItemMessage (hDlg, listID, LB_GETITEMDATA, lpdis->itemID, 0L)); /* * Draw the icon * Assume (left,top) coordinates are (0,0) */ iIconXpos = 0; iIconYpos = lpdis->rcItem.top; iTextYpos = lpdis->rcItem.top + iCenteringFactor ; iTextXpos = iIconXpos + cxIcon - 4; iStringlen = lstrlen(szItemString); // write char string in rectangle region, add icon ExtTextOut(lpdis->hDC,iTextXpos, iTextYpos,ETO_OPAQUE,&(lpdis->rcItem), szItemString,iStringlen ,NULL); if (GetMapMode(lpdis->hDC) != MM_TEXT) { MapModePrevious = SetMapMode(lpdis->hDC,MM_TEXT); DrawIcon(lpdis->hDC,iIconXpos,iIconYpos, hIcon); SetMapMode(lpdis->hDC,MapModePrevious); } else { if ((hIcon != 0) && (hIcon > (void*)0x10))// below 0x10 is window draw DrawIcon(lpdis->hDC,iIconXpos,iIconYpos, hIcon); } return TRUE; } return FALSE; } LONG WINAPI CustClrPalUserCtlProc(HANDLE hWndCtl, UINT message, WPARAM wParam, LPARAM lParam) { POINT point; UINT i, uNewSelected, uFoundFlag = 0; RECT PalRect; switch (message) { case WM_PAINT: if (uCurrentColor != -1) UpdateCurrentRect(hWndCtl, rectArray[uCurrentColor], rectArray[uCurrentColor]); else uSelectedColor = 0; UpdateSelectedRect(hWndCtl,rectArray[uSelectedColor], rectArray[uSelectedColor]); break; case WM_LBUTTONDOWN: GetCursorPos(&point); GetWindowRect(hWndCtl,&PalRect); point.y -= PalRect.top; point.x -= PalRect.left; for(i=0;i= uClrCount/2) { UpdateSelectedRect(hWndCtl, rectArray[uSelectedColor-(uClrCount/2)], rectArray[uSelectedColor]); uSelectedColor = uSelectedColor - (uClrCount/2); } break; case VK_DOWN: if (uSelectedColor < uClrCount/2) { UpdateSelectedRect(hWndCtl, rectArray[uSelectedColor+(uClrCount/2)], rectArray[uSelectedColor]); uSelectedColor = uSelectedColor + (uClrCount/2); } break; case VK_SPACE: UpdateCurrentRect(hWndCtl, rectArray[uSelectedColor], rectArray[uCurrentColor]); uCurrentColor = uSelectedColor; clr1 = aclrCust[uCurrentColor]; if (uLineExists == TRUE) PaintTheLine(hLineWidthBox, uLineWidth, clr1); break; } break; case WM_DESTROY: break; } return (DefWindowProc(hWndCtl, message, wParam, lParam)); } void UpdateSelectedRect (HWND hWndCtl, RECT rectNew, RECT rectOld) { HDC hDC; HPEN hPenLtGray, hPenDotted; UINT uOffset = 4; hPenLtGray = CreatePen (PS_SOLID, 1, RGB (192, 192, 192)); hPenDotted = CreatePen (PS_DOT , 1, 0L); hDC = GetDC (hWndCtl); // Start the paint operation rectOld.left -= uOffset; rectOld.top -= uOffset; rectOld.right += (uOffset-1); rectOld.bottom += (uOffset-1); SelectObject (hDC, hPenLtGray); DrawABox (hDC, rectOld); // Erase the old rectNew.left -= uOffset; rectNew.top -= uOffset; rectNew.right += (uOffset-1); rectNew.bottom += (uOffset-1); SelectObject (hDC, hPenDotted); DrawABox (hDC, rectNew); // Draw the new ReleaseDC (hWndCtl, hDC); // End the paint operation DeleteObject (hPenLtGray); DeleteObject (hPenDotted); } void UpdateCurrentRect (HWND hWndCtl, RECT rectNew, RECT rectOld) { HDC hDC; HPEN hPenBlack, hPenLtGray; UINT uOffset = 1; hPenLtGray = CreatePen (PS_SOLID, 2, RGB (192, 192, 192)); hPenBlack = CreatePen (PS_SOLID, 2, 0L); hDC = GetDC (hWndCtl); // Start the paint operation rectOld.left -= uOffset; rectOld.top -= uOffset; rectOld.right += uOffset; rectOld.bottom += uOffset; SelectObject (hDC, hPenLtGray); DrawABox (hDC, rectOld); // Erase the old rectNew.left -= uOffset; rectNew.top -= uOffset; rectNew.right += uOffset; rectNew.bottom += uOffset; SelectObject (hDC, hPenBlack); DrawABox (hDC, rectNew); // Draw the new ReleaseDC (hWndCtl, hDC); // End the paint operation DeleteObject (hPenLtGray); DeleteObject (hPenBlack); } void DrawABox (HDC hDC, RECT rect) { POINT point; MoveToEx (hDC, rect.left, rect.top, &point); LineTo (hDC, rect.right, rect.top); LineTo (hDC, rect.right, rect.bottom); LineTo (hDC, rect.left, rect.bottom); LineTo (hDC, rect.left, rect.top); } void GetCusDefColors(LPOI_UI_ColorStruct lpColor,COLORREF aclrCust[],HBRUSH hBrush[]) { UINT i; for (i=0;irgbCustomColor[i].rgbRed, lpColor->rgbCustomColor[i].rgbGreen, lpColor->rgbCustomColor[i].rgbBlue); hBrush[i] = (CreateSolidBrush(aclrCust[i])); } } void WINAPI GetColor1(LPOIAN_MARK_ATTRIBUTES lpAttribs,COLORREF * clr1) { *clr1 = RGB(lpAttribs->rgbColor1.rgbRed, lpAttribs->rgbColor1.rgbGreen, lpAttribs->rgbColor1.rgbBlue); } void GetColor2(LPOIAN_MARK_ATTRIBUTES lpAttribs,COLORREF *clr2) { *clr2 = RGB(lpAttribs->rgbColor2.rgbRed, lpAttribs->rgbColor2.rgbGreen, lpAttribs->rgbColor2.rgbBlue); } void SetCusDefColors(LPOI_UI_ColorStruct lpColor,COLORREF aclrCust[],HBRUSH hBrush[]) { UINT i; for(i=0;irgbCustomColor[i].rgbRed = GetRValue(aclrCust[i]); lpColor->rgbCustomColor[i].rgbGreen = GetGValue(aclrCust[i]); lpColor->rgbCustomColor[i].rgbBlue = GetBValue(aclrCust[i]); DeleteObject(hBrush[i]); } } void WINAPI SetColor1(LPOIAN_MARK_ATTRIBUTES lpAttribs,COLORREF clr1) { lpAttribs->rgbColor1.rgbRed = GetRValue(clr1); lpAttribs->rgbColor1.rgbGreen = GetGValue(clr1); lpAttribs->rgbColor1.rgbBlue = GetBValue(clr1); } void SetColor2(LPOIAN_MARK_ATTRIBUTES lpAttribs,COLORREF clr2) { lpAttribs->rgbColor2.rgbRed = GetRValue(clr2); lpAttribs->rgbColor2.rgbGreen = GetGValue(clr2); lpAttribs->rgbColor2.rgbBlue = GetBValue(clr2); } void WINAPI GetFont(LPOIAN_MARK_ATTRIBUTES lpAttribs, LOGFONT * lplf, CHOOSEFONT * lpcf) { HDC hDC; *lplf = lpAttribs->lfFont; /* If the structure contains a point size, convert it to height */ /* Also save the point size value, since we'll get it back later */ if (lplf->lfHeight > 0) { lpcf->iPointSize = (lplf->lfHeight)*10; lplf->lfHeight = -MulDiv(lplf->lfHeight, GetDeviceCaps((hDC=GetDC(NULL)),LOGPIXELSY),72); ReleaseDC(NULL,hDC); } return; } void WINAPI SetFont(LPOIAN_MARK_ATTRIBUTES lpAttribs, LOGFONT * lplf, CHOOSEFONT * lpcf) { lpAttribs->lfFont = *lplf; /* Save the point size instead of the height (safer for weird terminals) */ lpAttribs->lfFont.lfHeight = (lpcf->iPointSize)/10; return; } void GetPalRectInfo(HWND hDlg,RECT rectArray[]) { HWND hWndStaticControl; UINT i; int iRegionWidth, iRegionHeight, iBorderSize; hWndStaticControl = GetDlgItem (hDlg,IDC_USER1); GetClientRect(hWndStaticControl, &rectArray[0]); // Get size of the control iRegionWidth = rectArray[0].right/11; // Compute color box size iRegionHeight = rectArray[0].bottom/3; iBorderSize = iRegionWidth/3; // ...and spacing SetRect (&rectArray[0], // Set to draw first box iBorderSize, iBorderSize, iBorderSize + iRegionWidth, iBorderSize + iRegionHeight); for (i=1; iuStampCount == 0) return; for (i=0;iStamps[i] != 0)// valid stamp? ++TempStampCount; else { for (j=i+1; j < TP_STAMPCNT; j++) { if (lpStampStruct->Stamps[j] != 0) { // move up lpStampStruct->Stamps[i] = lpStampStruct->Stamps[j]; lpStampStruct->Stamps[j] = 0; ++TempStampCount; break; } } } if (TempStampCount >= lpStampStruct->uStampCount) break; } return; } void ResetStampDialog (HWND hDlg, LPOITP_STAMPS lpStampStruct,HFONT far* lpFont) { int i; UINT TempStampCount; // Empty out the listbox and all text boxes SendDlgItemMessage(hDlg,ID_RefNameList, LB_RESETCONTENT, 0, 0L); SendDlgItemMessage(hDlg,ID_StmpCntntsLbl, WM_SETTEXT, 0, (LPARAM)(LPSTR)""); SendDlgItemMessage(hDlg,ID_StmpCntntsTxt,WM_SETTEXT, 0, (LPARAM)(LPSTR)""); if (lpStampStruct->uStampCount == 0)// Disable edit/delete if no stamps { EnableWindow(GetDlgItem(hDlg,ID_EditCmd), FALSE); EnableWindow(GetDlgItem(hDlg,ID_DelCmd), FALSE); return; // No stamps, nothing else to do } else // Enable edit/delete if any stamps { EnableWindow(GetDlgItem(hDlg,ID_EditCmd), TRUE); EnableWindow(GetDlgItem(hDlg,ID_DelCmd), TRUE); } if (lpStampStruct->uStampCount == TP_STAMPCNT) { // Disable create if maxed out EnableWindow(GetDlgItem(hDlg,ID_Create_Text_Stamp), FALSE); EnableWindow(GetDlgItem(hDlg,ID_Create_Image_Stamp), FALSE); } else // otherwise enable create { EnableWindow(GetDlgItem(hDlg,ID_Create_Text_Stamp), TRUE); EnableWindow(GetDlgItem(hDlg,ID_Create_Image_Stamp), TRUE); } // Refill listbox completely from the stamp struct // Use TempStampCount to prevent list more stamp then the count TempStampCount = 0; for (i=0;iStamps[i] != 0)// valid stamp? { AddToStampListBox(hDlg,lpStampStruct->Stamps[i]); ++TempStampCount; if (TempStampCount >= lpStampStruct->uStampCount) break; } } // Reset the selection (updates all text fields) ResetSelectedStamp (hDlg, lpStampStruct,lpFont); return; } /*****************************************************************************/ void ResetSelectedStamp (HWND hDlg, LPOITP_STAMPS lpStampStruct,HFONT far* lpFont) { LPOITP_STAMP lpStamp; char szLabel[32]; // Fill in labels based on current stamp type lpStamp = lpStampStruct->Stamps[lpStampStruct->uCurrentStamp]; SendDlgItemMessage(hDlg, ID_RefNameList, LB_SETCURSEL, (WPARAM) GetStampIndex(hDlg, lpStamp), 0L); if (lpStamp->StartStruct.Attributes.uType == OIOP_AN_IMAGE) { LoadString(hInst,IMG_FILE_NAME_LABEL,(LPSTR) szLabel,sizeof(szLabel)); SendDlgItemMessage(hDlg,ID_StmpCntntsTxt,WM_SETTEXT, 0,(LPARAM)(LPSTR) lpStamp->StartStruct.szString); } else { LoadString(hInst,STAMP_TEXT_LABEL,(LPSTR) szLabel,sizeof(szLabel)); TextUpdateFont(GetDlgItem(hDlg,ID_StmpCntntsTxt),lpStamp,lpFont); SendDlgItemMessage(hDlg,ID_StmpCntntsTxt,WM_SETTEXT, 0,(LPARAM)(LPSTR) lpStamp->StartStruct.szString); } SendDlgItemMessage(hDlg,ID_StmpCntntsLbl,WM_SETTEXT, 0,(LPARAM)(LPSTR) szLabel); WorkingStamp = *lpStamp; } /*****************************************************************************/ int GetStampIndex(HWND hDlg, LPOITP_STAMP lpStamp) { return ((int) SendDlgItemMessage(hDlg, ID_RefNameList, LB_FINDSTRINGEXACT, (WPARAM) -1, (LPARAM) (LPSTR) lpStamp->szRefName)); } /*****************************************************************************/ int AddToStampListBox(HWND hDlg, LPOITP_STAMP lpStamp) { HICON hIcon; int iIndex; // Get symbol for stamp type hIcon = (lpStamp->StartStruct.Attributes.uType == OIOP_AN_IMAGE) ? LoadIcon(hInst, "imgstamp") : LoadIcon(hInst, "textstamp"); // Add the stamp name to the list box iIndex = (UINT)SendDlgItemMessage(hDlg,ID_RefNameList,LB_ADDSTRING, 0,(LPARAM)(LPSTR)lpStamp->szRefName); // Add the symbol to the stamp type SendDlgItemMessage(hDlg,ID_RefNameList,LB_SETITEMDATA, iIndex,(LPARAM)hIcon); return (iIndex); } /*****************************************************************************/ void FreeStampsInStampStruct (LPOITP_STAMPS lpStampStruct) { int i; if (lpStampStruct) { for (i=0;iStamps[i] != 0) { free(lpStampStruct->Stamps[i]); lpStampStruct->Stamps[i] = 0; } } } return; } // return SUCCESS if the name is valid, otherwise error code int ValidateStampName(HWND hDlg, LPSTR szRefName, UINT uDlgType) { int i; char szTemp1[TP_REFNAMLEN],szTemp2[TP_REFNAMLEN]; if (!lstrcmp(szRefName,"")) { return (CheckErr(hDlg, OIANNOSTAMPNAMEINVALID)); } // changes to lower case to compare lstrcpy(szTemp1,szRefName); CharLower(szTemp1); for (i=0;iStamps[i] != 0) { lstrcpy(szTemp2,lpLocalStampStruct->Stamps[i]->szRefName); if (!lstrcmp(CharLower(szTemp2), szTemp1)) { if ((uDlgType == DLGSTAMPEDIT) && (i == (int) lpLocalStampStruct->uCurrentStamp)) { continue; } else { return(CheckErr(hDlg, OIANNOSTAMPNAMEEXIST)); } } } } return (0); } /*****************************************************************************/ /* ROUTINE: AttrImageStampEditProc */ /* */ /* DESCRIPTION: Image stamp Attributes Edit and Create Dialog proc */ /* */ /* INPUTS: LPARAM has a pointer to the stamp structure */ /* If operation type is text or image stamp then */ /* Dialog is EDIT */ /* Else operation is OIOP_TP_NULL_STAMP */ /* Dialog is CREATE */ /* */ /* RETURNS: SUCCESS or CANCELPRESSED */ /* */ /* DATE: 5 April 1994 */ /* */ /* AUTHOR: Tim Duggan */ /* */ /* Note: This proc handles both the EDIT and CREATE cases */ /* */ /*****************************************************************************/ BOOL APIENTRY AttrImageStampEditProc(HWND hDlg, UINT message,WPARAM wParam,LPARAM lParam) { static LPOITP_STAMP lpStamp; char szBuf[BUFLEN]; static LOGFONT lf; static CHOOSEFONT cf; DWORD dwError = 0; static UINT uDlgType; //dialog type UINT wReturn; FIO_INFORMATION FileInfo; FIO_INFO_CGBW ColorInfo; static LPOI_LOCAL_STAMP lpLocalStamp; DWORD dOfnFlag = 0; switch(message) { case WM_INITDIALOG: // Limit length of path or text to maxfilespeclength - 1 (255) // bytes (actual is 256 including null terminator). SendDlgItemMessage(hDlg, ID_StmpCntntsTxt, EM_LIMITTEXT, MAXFILESPECLENGTH-1, 0L); // Limit length of reference name to 15 bytes (actual is 16 // including null terminator). SendDlgItemMessage(hDlg, ID_RefNameTxt, EM_LIMITTEXT, TP_REFNAMLEN-1, 0L); lpLocalStamp = (LPOI_LOCAL_STAMP)lParam; lpStamp = (LPOITP_STAMP) lpLocalStamp->lpStamp; if (lpStamp->StartStruct.Attributes.uType == OIOP_TP_NULL_STAMP) { uDlgType = DLGSTAMPCREATE; LoadString(hInst, CAPT_CREATE_IMAGE_STAMP,(LPSTR) szBuf,sizeof(szBuf)); SetWindowText(hDlg, (LPSTR) szBuf); //dwHelpId = HELPID_ANNO_STAMP_IMAGE_CREATE; } else { uDlgType = DLGSTAMPEDIT; //edit dialog box SendDlgItemMessage(hDlg,ID_StmpCntntsTxt,WM_SETTEXT, (WPARAM) 0, (LPARAM)(LPSTR) lpStamp->StartStruct.szString); SendDlgItemMessage(hDlg,ID_RefNameTxt, WM_SETTEXT, (WPARAM) 0, (LPARAM)(LPSTR) lpStamp->szRefName); } GetColor1(&(lpStamp->StartStruct.Attributes), &clr2); // Get the text color. GetFont(&(lpStamp->StartStruct.Attributes),&lf,&cf); // Get the font stuff. //bGotoEnd = TRUE; // Initially, got end of stamp contents edit for Date, Time. break; // END case INIT_DIALOG case WM_COMMAND: switch(LOWORD(wParam)) { case ID_BrowseCmd: { int cStatus; if (uDlgType == DLGSTAMPCREATE) LoadString(hInst, CAPT_CREATE_IMAGE_STAMP, (LPSTR) szBuf, sizeof(szBuf)); else LoadString(hInst, CAPT_EDIT_IMAGE_STAMP, (LPSTR) szBuf, sizeof(szBuf)); dOfnFlag = OFN_HIDEREADONLY; cStatus = InitOFN(hDlg,szBuf, IMAGEFILE_FILTERS, lpStamp->StartStruct.szString, sizeof(lpStamp->StartStruct.szString), dOfnFlag); SetFocus(hDlg); if (cStatus==SUCCESS) SendDlgItemMessage(hDlg,ID_StmpCntntsTxt,WM_SETTEXT, (WPARAM) 0, (LPARAM)(LPSTR) lpStamp->StartStruct.szString); } break; case IDOK: SendDlgItemMessage(hDlg,ID_StmpCntntsTxt,WM_GETTEXT, (WPARAM) sizeof(lpStamp->StartStruct.szString), (LPARAM)(LPSTR) lpStamp->StartStruct.szString); SendDlgItemMessage(hDlg,ID_RefNameTxt, WM_GETTEXT, (WPARAM) sizeof(lpStamp->szRefName), (LPARAM)(LPSTR) lpStamp->szRefName); if (ValidateStampName(hDlg, lpStamp->szRefName, uDlgType)) { SetFocus(GetDlgItem(hDlg,ID_RefNameTxt)); break; } if (!lstrcmp(lpStamp->StartStruct.szString,"")) { CheckErr(hDlg, OIANNOIMAGENAMEINVALID); SetFocus(GetDlgItem(hDlg,ID_StmpCntntsTxt)); break; } lpStamp->StartStruct.Attributes.uType = OIOP_AN_IMAGE; // Check if file is a valid NON-ANNOTATED image. _fmemset(&FileInfo, 0, sizeof(FIO_INFORMATION)); _fmemset(&ColorInfo, 0, sizeof(FIO_INFO_CGBW)); FileInfo.filename = lpStamp->StartStruct.szString; FileInfo.page_number = 1; wReturn = IMGFileGetInfo(NULL,lpLocalStamp->hwndImage, (LP_FIO_INFORMATION)&FileInfo, (LP_FIO_INFO_CGBW)&ColorInfo,NULL); if (wReturn != 0) { if ((wReturn == FIO_FILE_NOEXIST) || (wReturn == FIO_OPEN_READ_ERROR)) CheckErr(hDlg, OIANNOIMAGENAMEINVALID); else if (wReturn == FIO_ILLEGAL_COMPRESSION_TYPE) CheckErr(hDlg, FIO_UNSUPPORTED_FILE_TYPE); else CheckErr(hDlg, wReturn); SetFocus(GetDlgItem(hDlg,ID_StmpCntntsTxt)); break; } if (ColorInfo.fio_flags & FIO_ANNO_DATA) { CheckErr(hDlg, FIO_UNSUPPORTED_FILE_TYPE); SetFocus(GetDlgItem(hDlg,ID_StmpCntntsTxt)); break; } // Save the font information. SetFont(&(lpStamp->StartStruct.Attributes),&lf,&cf); SetColor1(&(lpStamp->StartStruct.Attributes),clr2); EndDialog(hDlg, SUCCESS); break; case IDCANCEL: EndDialog(hDlg, CANCELPRESSED); break; } // End case WM_COMMAND, switch (wparam) break; case WM_HELP: if (((LPHELPINFO)lParam)->iContextType == HELPINFO_WINDOW) { WinHelp(((LPHELPINFO)lParam)->hItemHandle,HelpFileName,HELP_WM_HELP, (DWORD)(LPVOID)aIDs); } break; case WM_CONTEXTMENU: WinHelp((HWND)wParam,HelpFileName,HELP_CONTEXTMENU, (DWORD)(LPVOID)aIDs); break; default: return FALSE; /* Didn't process the message */ break; } return TRUE; } /**************************************************************************** SwitchKeyboard Switch the keyboard layout according to the charset *****************************************************************************/ void WINAPI SwitchKeyboard(BYTE bCharset, LPHKL lpOldKeyboard) { if (bCharset == GREEK_CHARSET) { if ((*lpOldKeyboard = ActivateKeyboardLayout((HKL)0X408,KLF_REORDER)) == 0) *lpOldKeyboard = LoadKeyboardLayout("00000408",KLF_REORDER); } else if (bCharset == RUSSIAN_CHARSET) { if ((*lpOldKeyboard = ActivateKeyboardLayout((HKL)0X419,KLF_REORDER)) == 0) *lpOldKeyboard = LoadKeyboardLayout("00000419",KLF_REORDER); } else if ((bCharset == EASTEUROPE_CHARSET) || (bCharset == TURKISH_CHARSET)) { if ((*lpOldKeyboard = ActivateKeyboardLayout((HKL)0X405,KLF_REORDER)) == 0) *lpOldKeyboard = LoadKeyboardLayout("00000405",KLF_REORDER); } else if (bCharset == BALTIC_CHARSET) // German Standard { if ((*lpOldKeyboard = ActivateKeyboardLayout((HKL)0X407,KLF_REORDER)) == 0) *lpOldKeyboard = LoadKeyboardLayout("00000407",KLF_REORDER); } return; } /**************************************************************************** TextUpdateFont Setfont to the control with the adjusted font height *****************************************************************************/ void WINAPI TextUpdateFont(HWND hControlID,LPOITP_STAMP lpStamp,HFONT far* lpFont) { int iFontHeight=0; HDC hTempDC; // prevent memory leak if (*lpFont) DeleteObject(*lpFont); iFontHeight = lpStamp->StartStruct.Attributes.lfFont.lfHeight; if (lpStamp->StartStruct.Attributes.lfFont.lfHeight> 10) { // Edit box only can handle the height up to 10 lpStamp->StartStruct.Attributes.lfFont.lfHeight = 10; } // adjust the font height to the resolution factor hTempDC = GetDC(hControlID); lpStamp->StartStruct.Attributes.lfFont.lfHeight = -MulDiv(lpStamp->StartStruct.Attributes.lfFont.lfHeight, GetDeviceCaps(hTempDC, LOGPIXELSY), 72); ReleaseDC(hControlID,hTempDC); // setfont to the edit control *lpFont = CreateFontIndirect(&lpStamp->StartStruct.Attributes.lfFont); SendMessage(hControlID, WM_SETFONT, (WPARAM) *lpFont, 0L); if (iFontHeight != 0) lpStamp->StartStruct.Attributes.lfFont.lfHeight = iFontHeight; return; } /*****************************************************************************/ /* ROUTINE: AttrTextStampEditProc */ /* */ /* DESCRIPTION: Text stamp Attributes Edit and Create Dialog proc */ /* */ /* INPUTS: LPARAM has a pointer to the stamp structure */ /* If operation type is text or image stamp then */ /* Dialog is EDIT */ /* Else operation is OIOP_TP_NULL_STAMP */ /* Dialog is CREATE */ /* */ /* RETURNS: SUCCESS or CANCELPRESSED */ /* */ /* DATE: 5 April 1994 */ /* */ /* AUTHOR: Tim Duggan */ /* */ /* Note: This proc handles both the EDIT and CREATE cases */ /* */ /*****************************************************************************/ BOOL APIENTRY AttrTextStampEditProc(HWND hDlg, UINT message,WPARAM wParam,LPARAM lParam) { static LPOITP_STAMP lpStamp; char szDateTime[10]; char szBuf[BUFLEN]; static LOGFONT lf; static CHOOSEFONT cf; DWORD dwError = 0; static UINT uDlgType; //dialog type static HKL hOldKeyboard; BYTE bCharset; static HFONT hFont; DWORD dMargin; switch(message) { case WM_INITDIALOG: // Limit length of path or text to maxfilespeclength - 1 (255) // bytes (actual is 256 including null terminator). SendDlgItemMessage(hDlg, ID_StmpCntntsTxt, EM_LIMITTEXT, MAXFILESPECLENGTH-1, 0L); // Limit length of reference name to 15 bytes (actual is 16 // including null terminator). SendDlgItemMessage(hDlg, ID_RefNameTxt, EM_LIMITTEXT, TP_REFNAMLEN-1, 0L); hOldKeyboard = 0; hFont = 0; lpStamp = (LPOITP_STAMP) lParam; GetFont(&(lpStamp->StartStruct.Attributes),&lf,&cf); // Get the font stuff. TextUpdateFont(GetDlgItem(hDlg,ID_StmpCntntsTxt),lpStamp,&hFont); dMargin = SendDlgItemMessage(hDlg, ID_StmpCntntsTxt, EM_GETMARGINS, 0, 0L); if (dMargin > 0) SendDlgItemMessage(hDlg, ID_StmpCntntsTxt, EM_SETMARGINS, (WPARAM)EC_LEFTMARGIN, 0L); if (lpStamp->StartStruct.Attributes.uType == OIOP_TP_NULL_STAMP) { uDlgType = DLGSTAMPCREATE; LoadString(hInst, CAPT_CREATE_STAMP,(LPSTR) szBuf,sizeof(szBuf)); SetWindowText(hDlg, (LPSTR) szBuf); } else { uDlgType = DLGSTAMPEDIT; //edit dialog box LoadString(hInst, CAPT_EDIT_STAMP, (LPSTR) szBuf, sizeof(szBuf)); SetWindowText(hDlg, (LPSTR) szBuf); SendDlgItemMessage(hDlg,ID_StmpCntntsTxt,WM_SETTEXT, (WPARAM) 0, (LPARAM)(LPSTR) lpStamp->StartStruct.szString); SendDlgItemMessage(hDlg,ID_RefNameTxt, WM_SETTEXT, (WPARAM) 0, (LPARAM)(LPSTR) lpStamp->szRefName); } GetColor1(&(lpStamp->StartStruct.Attributes), &clr2); // Get the text color. EnableWindow(GetDlgItem(hDlg,ID_DateImg), FALSE); EnableWindow(GetDlgItem(hDlg,ID_TimeImg), FALSE); break; // END case INIT_DIALOG case WM_COMMAND: switch(LOWORD(wParam)) { case ID_RefNameTxt: // disable the date and time button if (HIWORD(wParam) == EN_SETFOCUS) { EnableWindow(GetDlgItem(hDlg,ID_DateImg), FALSE); EnableWindow(GetDlgItem(hDlg,ID_TimeImg), FALSE); } break; case ID_StmpCntntsTxt: if (HIWORD(wParam) == EN_SETFOCUS) { EnableWindow(GetDlgItem(hDlg,ID_DateImg), TRUE); EnableWindow(GetDlgItem(hDlg,ID_TimeImg), TRUE); bCharset = lpStamp->StartStruct.Attributes.lfFont.lfCharSet; if ((bCharset != 0) && (bCharset != 1)) SwitchKeyboard(bCharset,&hOldKeyboard); } if (HIWORD(wParam) == EN_KILLFOCUS) { if (hOldKeyboard != 0) ActivateKeyboardLayout(hOldKeyboard,KLF_REORDER); } break; case ID_DateImg: SetFocus(GetDlgItem(hDlg, ID_StmpCntntsTxt)); LoadString(hInst,STR_DATE,(LPSTR) szDateTime,sizeof(szDateTime)); SendDlgItemMessage(hDlg,ID_StmpCntntsTxt, EM_REPLACESEL,0,(LPARAM)(LPCSTR)szDateTime); break; case ID_TimeImg: SetFocus(GetDlgItem(hDlg, ID_StmpCntntsTxt)); LoadString(hInst,STR_TIME,(LPSTR) szDateTime,sizeof(szDateTime)); SendDlgItemMessage(hDlg,ID_StmpCntntsTxt, EM_REPLACESEL,0,(LPARAM)(LPCSTR)szDateTime); break; case ID_FontCmd: // disable the date and time buttons. EnableWindow(GetDlgItem(hDlg,ID_DateImg), FALSE); EnableWindow(GetDlgItem(hDlg,ID_TimeImg), FALSE); // Initialize the LOGFONT structure. cf.lStructSize = sizeof(CHOOSEFONT); cf.hwndOwner = hDlg; cf.lpLogFont = &lf; cf.lpfnHook = ChooseFontDlgProc; cf.lCustData = (LPARAM)(LPOIAN_MARK_ATTRIBUTES FAR *) (&(lpStamp->StartStruct.Attributes)); cf.Flags = CF_SCREENFONTS | CF_EFFECTS | CF_INITTOLOGFONTSTRUCT | CF_ENABLEHOOK|CF_NOVERTFONTS ; cf.rgbColors = clr2; if (ChooseFont(&cf) == 0) /* error */ { dwError = CommDlgExtendedError(); CheckErr(hDlg, (WORD) dwError); break; } // Reset the text color. clr2 = cf.rgbColors; SetFont(&(lpStamp->StartStruct.Attributes),&lf,&cf); TextUpdateFont(GetDlgItem(hDlg,ID_StmpCntntsTxt),lpStamp,&hFont); dMargin = SendDlgItemMessage(hDlg, ID_StmpCntntsTxt, EM_GETMARGINS, 0, 0L); if (dMargin > 0) SendDlgItemMessage(hDlg, ID_StmpCntntsTxt, EM_SETMARGINS, (WPARAM)EC_LEFTMARGIN, 0L); break; case IDOK: SendDlgItemMessage(hDlg,ID_StmpCntntsTxt,WM_GETTEXT, (WPARAM) sizeof(lpStamp->StartStruct.szString), (LPARAM)(LPSTR) lpStamp->StartStruct.szString); SendDlgItemMessage(hDlg,ID_RefNameTxt, WM_GETTEXT, (WPARAM) sizeof(lpStamp->szRefName), (LPARAM)(LPSTR) lpStamp->szRefName); if (ValidateStampName(hDlg, lpStamp->szRefName, uDlgType)) { SetFocus(GetDlgItem(hDlg,ID_RefNameTxt)); break; } if (!lstrcmp(lpStamp->StartStruct.szString,"")) { CheckErr(hDlg, OIANNOSTAMPTEXTINVALID); SetFocus(GetDlgItem(hDlg,ID_StmpCntntsTxt)); break; } lpStamp->StartStruct.Attributes.uType = OIOP_AN_TEXT_STAMP; // Save the font information. //SetFont(&(lpStamp->StartStruct.Attributes),&lf,&cf); SetColor1(&(lpStamp->StartStruct.Attributes),clr2); if (hFont != 0) DeleteObject(hFont); EndDialog(hDlg, SUCCESS); break; case IDCANCEL: if (hFont != 0) DeleteObject(hFont); EndDialog(hDlg, CANCELPRESSED); break; } // End case WM_COMMAND, switch (wparam) break; case WM_HELP: if (((LPHELPINFO)lParam)->iContextType == HELPINFO_WINDOW) { WinHelp(((LPHELPINFO)lParam)->hItemHandle,HelpFileName,HELP_WM_HELP, (DWORD)(LPVOID)aIDs); } break; case WM_CONTEXTMENU: WinHelp((HWND)wParam,HelpFileName,HELP_CONTEXTMENU, (DWORD)(LPVOID)aIDs); break; default: return FALSE; /* Didn't process the message */ break; } return TRUE; } BOOL WINAPI AttrStampDlgProc(HWND hDlg, UINT message,WPARAM wParam,LONG lParam) { LPDRAWITEMSTRUCT lpdis; // Used to draw txt/img bmps RECT CtlDims2; // " static short int iCenteringFactor; // " LPMEASUREITEMSTRUCT lpmis; // " static TEXTMETRIC tm; // Used for Font display // General purpose char szRefNameBuf[TP_REFNAMLEN]; // stamp name buffer int i, // Loop control iIndex, // item index in dialog box iCurStamp; // item index in array static LPOITP_STAMPS lpStamp; OI_LOCAL_STAMP LocalStamp; char szMessage[128]; char szTitle[50]; static HFONT hFont; switch(message) { case WM_INITDIALOG: lpStamp = (LPOITP_STAMPS)lParam; hFont = 0; SetFocus(GetDlgItem(hDlg,ID_RefNameList)); // Put focus on listbox. iCenteringFactor = 0; // Allocate a local version of the stamps structure if (!(lpLocalStampStruct = (LPOITP_STAMPS) malloc(sizeof(OITP_STAMPS)))) { EndDialog(hDlg, NOMEMORY); } else memset(lpLocalStampStruct, '\0', sizeof(OITP_STAMPS) ); for (i=0;i<(int)lpStamp->uStampCount;++i) { if (lpStamp->Stamps[i] != 0)// valid stamp? { if (!(lpLocalStampStruct->Stamps[i] = // local copy (LPOITP_STAMP) malloc(sizeof(OITP_STAMP)))) { FreeStampsInStampStruct (lpLocalStampStruct); EndDialog(hDlg, NOMEMORY); } else memset(lpLocalStampStruct->Stamps[i], '\0', sizeof(OITP_STAMP) ); // copy stamp to local structure *lpLocalStampStruct->Stamps[i] = *lpStamp->Stamps[i]; } } lpLocalStampStruct->uStampCount = lpStamp->uStampCount; iCurStamp = lpLocalStampStruct->uCurrentStamp = lpStamp->uCurrentStamp; // Fill in the listbox, select current stamp, fill in static fields ResetStampDialog (hDlg, lpLocalStampStruct,&hFont); SetFocus(GetDlgItem(hDlg,ID_RefNameList)); // Put focus on listbox. return (FALSE); // And keep it there! break; // END case WM_INITDIALOG case WM_MEASUREITEM: lpmis = (LPMEASUREITEMSTRUCT) lParam; if(lpmis->CtlID == ID_RefNameList) { lpmis->itemHeight = tm.tmHeight; GetWindowRect(GetDlgItem(hDlg,lpmis->CtlID),&CtlDims2); lpmis->itemWidth = CtlDims2.right; } break; case WM_DRAWITEM: lpdis = (LPDRAWITEMSTRUCT)lParam; if((lpdis->CtlID == ID_RefNameList) || (lpdis->CtlID == ID_RefNameTxt)); { if (DrawItemProc(hDlg,lpdis,iCenteringFactor,lpdis->CtlID)); { return TRUE; } } break; case WM_COMMAND: switch(LOWORD(wParam)) { case ID_RefNameList: // Listbox calling... switch(HIWORD(wParam)) { case LBN_DBLCLK: // Double clicked a selection PostMessage (hDlg, WM_COMMAND, (WPARAM) IDOK, (LPARAM) 0L); break; case LBN_SELCHANGE: // Current selection has changed // Compute new selected stamp index iIndex = (int) SendDlgItemMessage(hDlg, // Get index in box ID_RefNameList, LB_GETCURSEL, 0,0L); SendDlgItemMessage(hDlg, ID_RefNameList, // Get name of selected stamp LB_GETTEXT, (WPARAM)iIndex, (LPARAM)(LPSTR)szRefNameBuf); for(i=0;iStamps[i] != 0) { if (lstrcmp(lpLocalStampStruct->Stamps[i] ->szRefName,szRefNameBuf) == 0) { lpLocalStampStruct->uCurrentStamp = i; break; } } } // Update the static fields for the new selected stamp ResetSelectedStamp (hDlg,lpLocalStampStruct,&hFont); break; // END case LBN_SELCHANGE (listbox) } break; case ID_EditCmd: // Edit button pressed { LPOITP_STAMP lpCurrentStamp; PROC lpfnDlgProc; int iDlgRtn; lpCurrentStamp = lpLocalStampStruct->Stamps[lpLocalStampStruct->uCurrentStamp]; WorkingStamp = *lpCurrentStamp; lpAttribs = (LPOIAN_MARK_ATTRIBUTES)&lpCurrentStamp->StartStruct; // Put up the edit/create dialog according the stamp type if (lpAttribs->uType == OIOP_AN_TEXT_STAMP) { lpfnDlgProc = GetProcAddress (hInst, "AttrTextStampEditProc"); iDlgRtn =DialogBoxParam(hInst, "RubberStampEditDlg", hDlg, lpfnDlgProc, (LPARAM) (LPVOID)&WorkingStamp); } else if(lpAttribs->uType == OIOP_AN_IMAGE) { LocalStamp.lpStamp = &WorkingStamp; LocalStamp.hwndImage = lpStamp->hwndImage; lpfnDlgProc = GetProcAddress (hInst, "AttrImageStampEditProc"); iDlgRtn =DialogBoxParam(hInst, "ImageStampEditDlg", hDlg, lpfnDlgProc, (LPARAM) (LPVOID)&LocalStamp); } switch (iDlgRtn) { case SUCCESS: *lpCurrentStamp = WorkingStamp; ResetStampDialog(hDlg,lpLocalStampStruct,&hFont); break; case CANCELPRESSED: WorkingStamp = *lpCurrentStamp; break; } } break; case ID_Create_Text_Stamp: case ID_Create_Image_Stamp: { LPOITP_STAMP lpCurrentStamp; LPOITP_STAMP lpCreateStamp; PROC lpfnDlgProc; int iDlgRtn; /* get the last stamp */ lpCurrentStamp = lpLocalStampStruct->Stamps[lpLocalStampStruct->uCurrentStamp]; // Allocate an empty stamp if (!(lpCreateStamp =(LPOITP_STAMP) malloc(sizeof(OITP_STAMP)))) { FreeStampsInStampStruct (lpLocalStampStruct); EndDialog(hDlg, NOMEMORY); } else memset(lpCreateStamp, '\0', sizeof(OITP_STAMP) ); lpCreateStamp->StartStruct.Attributes.uType = OIOP_TP_NULL_STAMP; if (lpCurrentStamp) { lpCreateStamp->StartStruct.Attributes.lfFont = lpCurrentStamp->StartStruct.Attributes.lfFont; lpCreateStamp->StartStruct.Attributes.rgbColor1 = lpCurrentStamp->StartStruct.Attributes.rgbColor1; } else // no current stamp, set default font(arial) and color(black) { LoadString(hInst,IDS_DEFFONT,(LPSTR) szMessage,sizeof(szMessage)); lstrcpy(lpCreateStamp->StartStruct.Attributes.lfFont.lfFaceName,szMessage); lpCreateStamp->StartStruct.Attributes.lfFont.lfHeight = 10; lpCreateStamp->StartStruct.Attributes.lfFont.lfWeight = 400; lpCreateStamp->StartStruct.Attributes.lfFont.lfItalic = FALSE; lpCreateStamp->StartStruct.Attributes.lfFont.lfStrikeOut = FALSE; lpCreateStamp->StartStruct.Attributes.lfFont.lfUnderline = FALSE; lpCreateStamp->StartStruct.Attributes.lfFont.lfCharSet = 1; lpCreateStamp->StartStruct.Attributes.rgbColor1.rgbRed = 0; lpCreateStamp->StartStruct.Attributes.rgbColor1.rgbGreen = 0; lpCreateStamp->StartStruct.Attributes.rgbColor1.rgbBlue = 0; } //lpAttribs = (LPOIAN_MARK_ATTRIBUTES)&lpCurrentStamp->StartStruct; if (LOWORD(wParam) == ID_Create_Text_Stamp) { lpfnDlgProc = GetProcAddress (hInst, "AttrTextStampEditProc"); iDlgRtn =DialogBoxParam(hInst, "RubberStampEditDlg", hDlg, lpfnDlgProc, (LPARAM) lpCreateStamp); } else if(LOWORD(wParam) == ID_Create_Image_Stamp) { LocalStamp.lpStamp = lpCreateStamp; LocalStamp.hwndImage = lpStamp->hwndImage; lpfnDlgProc = GetProcAddress (hInst, "AttrImageStampEditProc"); iDlgRtn =DialogBoxParam(hInst, "ImageStampEditDlg", hDlg, lpfnDlgProc, (LPARAM)&LocalStamp); } switch (iDlgRtn) { case SUCCESS: for (i=0;iStamps[i] == 0) { lpLocalStampStruct->Stamps[i] = lpCreateStamp; lpLocalStampStruct->uCurrentStamp = i; lpLocalStampStruct->uStampCount++; ResetStampDialog(hDlg,lpLocalStampStruct,&hFont); break; } } break; case CANCELPRESSED: free(lpCreateStamp); break; } } break; case ID_DelCmd: { LoadString(hInst,TITLE_RS_WARNING,(LPSTR) szTitle,sizeof(szTitle)); LoadString(hInst,MSG_DELETE_STAMP,(LPSTR) szMessage,sizeof(szMessage)); MessageBeep(MB_ICONQUESTION); if (MessageBox (hDlg, szMessage, szTitle, MB_ICONQUESTION|MB_YESNOCANCEL) == IDYES) { free(lpLocalStampStruct->Stamps[lpLocalStampStruct->uCurrentStamp]); lpLocalStampStruct->Stamps[lpLocalStampStruct->uCurrentStamp] = 0; // reset the stamp structure ResetStampStruct(hDlg, lpLocalStampStruct); //Set the cursor to the next item in the list box iIndex = (int) SendDlgItemMessage(hDlg, // Get index in box ID_RefNameList, LB_GETCURSEL, 0,0L); // get the item count in the list box i = (int) SendDlgItemMessage(hDlg, // Get index in box ID_RefNameList, LB_GETCOUNT, 0,0L); if (i == iIndex +1) // delete the last item --iIndex; else // set next on the list as the current stamp ++iIndex; SendDlgItemMessage(hDlg, ID_RefNameList, // Get name of selected stamp LB_GETTEXT, (WPARAM)iIndex, (LPARAM)(LPSTR)szRefNameBuf); for(i=0;i<(int)lpLocalStampStruct->uStampCount;++i) // Find it in the array { if (lpLocalStampStruct->Stamps[i] != 0) { if (lstrcmp(lpLocalStampStruct->Stamps[i] ->szRefName,szRefNameBuf) == 0) { lpLocalStampStruct->uCurrentStamp = i; break; } } } // reset the dialog lpLocalStampStruct->uStampCount -= 1; if (lpLocalStampStruct->uStampCount >= 0) ResetStampDialog (hDlg, lpLocalStampStruct,&hFont); } } break; case IDOK: // Copy all the stamp info from local to lpStamp for (i=0;i<(int)lpLocalStampStruct->uStampCount;i++) { *lpStamp->Stamps[i]= *lpLocalStampStruct->Stamps[i]; } // Clean up the rest of the unused stamp structure for ( i=lpLocalStampStruct->uStampCount; i < TP_STAMPCNT; i++) lstrcpy(lpStamp->Stamps[i]->szRefName,""); // Update new count and current stamp lpStamp->uStampCount = lpLocalStampStruct->uStampCount; lpStamp->uCurrentStamp = lpLocalStampStruct->uCurrentStamp; // Free local stamp array FreeStampsInStampStruct (lpLocalStampStruct); free(lpLocalStampStruct); if (hFont != 0) DeleteObject(hFont); EndDialog(hDlg, SUCCESS); break; case IDCANCEL: // Get rid of all stamps in the local stamp array FreeStampsInStampStruct (lpLocalStampStruct); // Free local stamp array free(lpLocalStampStruct); if (hFont != 0) DeleteObject(hFont); // Return CANCEL EndDialog(hDlg, CANCELPRESSED); break; } // End case WM_COMMAND, switch (wparam) break; case WM_HELP: if (((LPHELPINFO)lParam)->iContextType == HELPINFO_WINDOW) { WinHelp(((LPHELPINFO)lParam)->hItemHandle,HelpFileName,HELP_WM_HELP, (DWORD)(LPVOID)aIDs); } break; case WM_CONTEXTMENU: WinHelp((HWND)wParam,HelpFileName,HELP_CONTEXTMENU, (DWORD)(LPVOID)aIDs); break; default: return FALSE; /* Didn't process the message */ break; } return TRUE; }