#include "stdafx.h" extern "C" { #include #include #include #include #include "oiui.h" } #include #include #include "toolpal.h" #include "minitlbx.h" #include "imgedctl.h" #include "resource.h" #include "oicalls.h" #define STAMPSIZE 50 // max length of a stamp #define DefaultFontSize 28 char DateMacroString[] = " %x"; // registered msgs from tool palette to image/edit control extern UINT STP_SET_ANNOTATION_TYPE; extern UINT STP_SET_ANNOTATION_FONTNAME; extern UINT STP_SET_ANNOTATION_FONTSIZE; extern UINT STP_SET_ANNOTATION_FONTBOLD; extern UINT STP_SET_ANNOTATION_FONTITALIC; extern UINT STP_SET_ANNOTATION_FONTSTRIKETHRU; extern UINT STP_SET_ANNOTATION_FONTUNDERLINE; extern UINT STP_SET_ANNOTATION_FONTCHARSET; extern UINT STP_SET_ANNOTATION_STAMPTEXT; extern UINT STP_SET_ANNOTATION_LINESIZE; extern UINT STP_SET_ANNOTATION_STYLE; extern UINT STP_SET_ANNOTATION_REDCOLOR; extern UINT STP_SET_ANNOTATION_GREENCOLOR; extern UINT STP_SET_ANNOTATION_BLUECOLOR; extern UINT STP_SET_ANNOTATION_BACKREDCOLOR; extern UINT STP_SET_ANNOTATION_BACKGREENCOLOR; extern UINT STP_SET_ANNOTATION_BACKBLUECOLOR; extern UINT STP_SET_ANNOTATION_IMAGE; extern UINT TOOLTIP_EVENT; extern UINT TOOLPALETTE_HIDDEN; extern UINT TOOL_SELECTED_EVENT; extern UINT TOOLPALETTE_HIDDEN_XPOSITION; extern UINT TOOLPALETTE_HIDDEN_YPOSITION; // end registered msgs from tool palette to image/edit control // registered messages from image/edit to tool palette extern UINT SELECT_TOOL_BUTTON; // end registered messages from image/edit to tool palette // name to tool palette class name extern CString szToolPaletteClassName; CMiniToolBox::CMiniToolBox() { } CMiniToolBox::~CMiniToolBox() { } BEGIN_MESSAGE_MAP(CMiniToolBox, CMiniFrameWnd) //{{AFX_MSG_MAP(CMiniToolBox) ON_WM_DESTROY() ON_WM_PAINT() //}}AFX_MSG_MAP END_MESSAGE_MAP() BOOL CMiniToolBox::Create(DWORD dwStyle, RECT& rect, CWnd* pImageEditWnd, LPCTSTR ToolTip, BOOL bShowAttrDialog) { BOOL bResult,bFoundStampInfo; CUpdateRegistry *Registry; HKEY hAnnotationToolPaletteKey,hToolKey; char ToolStringKey[50],RefName[MAXREFNAME_SIZE],AttributeString[300],StampCountString[20]; int i,StampCount,StampType; long lRet; char CurrentStamp[MAXREFNAME_SIZE]; CString strBuffer; CWnd *Parent, *TopParent; RECT MoveRect; RECT WindowRect; RECT ToolPaletteRect; RECT ClientRect; BYTE FontColorRed, FontColorGreen, FontColorBlue; CString szFontName; UINT uFontSize; BOOL bFontBold,bFontItalic,bFontStrikeThru,bFontUnderline; BYTE FontCharSet; long Left=0,Top=0; BOOL bDefaultPosition; CString strRubberStampApproved; CString strRubberStampRejected; CString strRubberStampDraft; CString strRubberStampReceived; CString Caption; BYTE bDefaultCharset=1; // save image edit window m_pImageWnd = pImageEditWnd; // get the top most overlapped window TopParent = Parent = pImageEditWnd->GetParent(); while (Parent != NULL) { Parent = Parent->GetParent(); if (Parent != NULL) TopParent = Parent; } // if user specified tool palette position then save it if (rect.right != -1) { Left = rect.left; Top = rect.top; bDefaultPosition = FALSE; } else bDefaultPosition = TRUE; // create mini frame window based on position and size of Image/Edit control window. pImageEditWnd->GetWindowRect(&rect); rect.left += 10; rect.top += 10; rect.right = rect.left + 52; // approximate width of tool palette rect.bottom = rect.top + 136; // approximate height of tool palette // 15may96 paj Remove toolbar caption // Caption.LoadString(IDS_TOOLPALETTE_CAPTION); bResult = CMiniFrameWnd::Create(szToolPaletteClassName, Caption.GetBuffer(20), dwStyle, rect, TopParent, 0); if (bResult == TRUE) { bResult = m_PaletteBar.Create(WS_VISIBLE | WS_CHILD | CCS_TOP | TBSTYLE_WRAPABLE | CCS_NODIVIDER | TBSTYLE_TOOLTIPS, CRect(0,0,0,0), this, IDB_TOOLPAL, bShowAttrDialog); if (bResult == FALSE) return FALSE; } // get width and height of mini frame window int MiniFrameWidth = rect.right - rect.left; int MiniFrameHeight = rect.bottom - rect.top; // get client size of miniframe window GetClientRect(&ClientRect); // get width of mini frame border int FrameBorderWidth = MiniFrameWidth - ClientRect.right; // get height of mini frame caption and border int FrameBorderHeight = MiniFrameHeight - ClientRect.bottom; // get client area of tool palette m_PaletteBar.GetClientRect(&ToolPaletteRect); // get width of tool palette window int ToolPaletteWidth = ToolPaletteRect.right - ToolPaletteRect.left; // get height of tool palette window int ToolPaletteHeight = ToolPaletteRect.bottom - ToolPaletteRect.top; // get left and top of client area of frame in screen coordinates int FrameClientLeft = rect.left + FrameBorderWidth; int FrameClientTop = rect.top + FrameBorderHeight; // if user specified tool palette position then use it otherwise default // position to 10 pixels inside of image/edit control. if (bDefaultPosition) { // place window in relation to image/edit control pImageEditWnd->GetWindowRect(&WindowRect); MoveRect.left = WindowRect.left + 10; MoveRect.top = WindowRect.top + 10; } else { // place window where user specified MoveRect.left = Left; MoveRect.top = Top; } // MoveRect.right = MoveRect.left + ToolPaletteWidth + FrameBorderWidth; MoveRect.right = MoveRect.left + ToolPaletteWidth + (3 * FrameBorderWidth); // make it xtra wide for tools caption MoveRect.bottom = MoveRect.top + ToolPaletteHeight + FrameBorderHeight; // set size of frame window and move it MoveWindow(&MoveRect, FALSE); // change the tool palette window so if fits evenly within miniframe window GetClientRect(&ClientRect); m_PaletteBar.GetClientRect(&WindowRect); int xdiff = ClientRect.right - WindowRect.right; WindowRect.left += (xdiff / 2); WindowRect.right += (xdiff / 2); m_PaletteBar.MoveWindow(&WindowRect, FALSE); // create registry class Registry = new CUpdateRegistry; if (Registry == NULL) return FALSE; // read initial tool palette settings and put them into internal variables. If // registry settings are not there then write initial ones. hAnnotationToolPaletteKey = Registry->OpenRegistry(); if (hAnnotationToolPaletteKey == 0) { delete Registry; return FALSE; } if (ToolTip != NULL && ToolTip[0] != '\0') { int len,CurrentPos,PipeCount,StartPos; CString Temp; Temp = ToolTip; len = Temp.GetLength(); for (CurrentPos = 0, PipeCount = 0, StartPos = 0; CurrentPos < len; CurrentPos++) { if (Temp[CurrentPos] == '|') { switch(PipeCount) { case ID_ANNOTATION_SELECTION: m_strAnnotationSelectionToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; case ID_FREEHAND_LINE: m_strFreehandLineToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; case ID_HIGHLIGHTING_LINE: m_strHighlightingLineToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; case ID_STRAIGHT_LINE: m_strStraightLineToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; case ID_HOLLOW_RECT: m_strHollowRectToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; case ID_FILLED_RECT: m_strFilledRectToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; case ID_TEXT: m_strTextToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; case ID_TEXT_ATTACHMENT: m_strTextAttachmentToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; case ID_TEXT_FROM_FILE: m_strTextFromFileToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; case ID_RUBBER_STAMP: m_strRubberStampToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); StartPos = CurrentPos + 1; break; } // end switch PipeCount++; } } // end for if (PipeCount == ID_RUBBER_STAMP) m_strRubberStampToolTip = Temp.Mid(StartPos, CurrentPos - StartPos); } else { m_strAnnotationSelectionToolTip.LoadString(IDS_ANNOTATIONSELECTION); m_strFreehandLineToolTip.LoadString(IDS_FREEHANDLINE); m_strHighlightingLineToolTip.LoadString(IDS_HIGHLIGHTINGLINE); m_strStraightLineToolTip.LoadString(IDS_STRAIGHTLINE); m_strHollowRectToolTip.LoadString(IDS_HOLLOWRECT); m_strFilledRectToolTip.LoadString(IDS_FILLEDRECT); m_strTextToolTip.LoadString(IDS_TEXT); m_strTextAttachmentToolTip.LoadString(IDS_ATTACHANOTE); m_strTextFromFileToolTip.LoadString(IDS_TEXTFROMFILE); m_strRubberStampToolTip.LoadString(IDS_RUBBERSTAMP); } // load default font - Arial - need to do this for internationaization strBuffer.LoadString(IDS_DEFFONTNAME); // do freehand line, line width _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"FREEHAND_LINE_TOOL"); bResult = Registry->GetLineWidth(hAnnotationToolPaletteKey, ToolStringKey, (LPINT)&m_uFL_LineWidth); if (bResult == FALSE) { // write out initial freehand line width m_uFL_LineWidth = 1; // set default bResult = Registry->SetLineWidth(hAnnotationToolPaletteKey, ToolStringKey, m_uFL_LineWidth); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do freehand line, line color bResult = Registry->GetLineColor(hAnnotationToolPaletteKey, ToolStringKey, &m_FL_LineColorRed, &m_FL_LineColorGreen, &m_FL_LineColorBlue); if (bResult == FALSE) { // default to black m_FL_LineColorRed = 0; m_FL_LineColorGreen = 0; m_FL_LineColorBlue = 0; bResult = Registry->SetLineColor(hAnnotationToolPaletteKey, ToolStringKey, m_FL_LineColorRed, m_FL_LineColorGreen, m_FL_LineColorBlue); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do highlight line, line color - actually a filled rect now _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"HIGHLIGHT_LINE_TOOL"); bResult = Registry->GetLineColor(hAnnotationToolPaletteKey, ToolStringKey, &m_HL_LineColorRed, &m_HL_LineColorGreen, &m_HL_LineColorBlue); if (bResult == FALSE) { // default to yellow m_HL_LineColorRed = 255; m_HL_LineColorGreen = 255; m_HL_LineColorBlue = 0; bResult = Registry->SetLineColor(hAnnotationToolPaletteKey, ToolStringKey, m_HL_LineColorRed, m_HL_LineColorGreen, m_HL_LineColorBlue); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do straight line, line width _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"STRAIGHT_LINE_TOOL"); bResult = Registry->GetLineWidth(hAnnotationToolPaletteKey, ToolStringKey, (LPINT)&m_uSL_LineWidth); if (bResult == FALSE) { // write out initial straight line width m_uSL_LineWidth = 4; // set default bResult = Registry->SetLineWidth(hAnnotationToolPaletteKey, ToolStringKey, m_uSL_LineWidth); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do straight line, line color bResult = Registry->GetLineColor(hAnnotationToolPaletteKey, ToolStringKey, &m_SL_LineColorRed, &m_SL_LineColorGreen, &m_SL_LineColorBlue); if (bResult == FALSE) { // default to red m_SL_LineColorRed = 255; m_SL_LineColorGreen = 0; m_SL_LineColorBlue = 0; bResult = Registry->SetLineColor(hAnnotationToolPaletteKey, ToolStringKey, m_SL_LineColorRed, m_SL_LineColorGreen, m_SL_LineColorBlue); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do hollow rect, line width _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"HOLLOW_RECT_TOOL"); bResult = Registry->GetLineWidth(hAnnotationToolPaletteKey, ToolStringKey, (LPINT)&m_uHR_LineWidth); if (bResult == FALSE) { // write out initial straight line width m_uHR_LineWidth = 4; // set default bResult = Registry->SetLineWidth(hAnnotationToolPaletteKey, ToolStringKey, m_uHR_LineWidth); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do hollow rect, line color bResult = Registry->GetLineColor(hAnnotationToolPaletteKey, ToolStringKey, &m_HR_LineColorRed, &m_HR_LineColorGreen, &m_HR_LineColorBlue); if (bResult == FALSE) { // default to blue m_HR_LineColorRed = 0; m_HR_LineColorGreen = 0; m_HR_LineColorBlue = 255; bResult = Registry->SetLineColor(hAnnotationToolPaletteKey, ToolStringKey, m_HR_LineColorRed, m_HR_LineColorGreen, m_HR_LineColorBlue); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do hollow rect, style bResult = Registry->GetStyle(hAnnotationToolPaletteKey, ToolStringKey, &m_uHR_LineStyle); if (bResult == FALSE) { // default to opaque m_uHR_LineStyle = OI_OPAQUE; bResult = Registry->SetStyle(hAnnotationToolPaletteKey, ToolStringKey, m_uHR_LineStyle); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do filled rect, fill color _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"FILLED_RECT_TOOL"); bResult = Registry->GetFillColor(hAnnotationToolPaletteKey, ToolStringKey, &m_FR_FillColorRed, &m_FR_FillColorGreen, &m_FR_FillColorBlue); if (bResult == FALSE) { m_FR_FillColorRed = 255; m_FR_FillColorGreen = 255; m_FR_FillColorBlue = 0; bResult = Registry->SetFillColor(hAnnotationToolPaletteKey, ToolStringKey, m_FR_FillColorRed, m_FR_FillColorGreen, m_FR_FillColorBlue); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do text entry, font color _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"TEXT_TOOL"); bResult = Registry->GetFontColor(hAnnotationToolPaletteKey, ToolStringKey, &m_TE_FontColorRed, &m_TE_FontColorGreen, &m_TE_FontColorBlue); if (bResult == FALSE) { // default font color is black m_TE_FontColorRed = 0; m_TE_FontColorGreen = 0; m_TE_FontColorBlue = 0; bResult = Registry->SetFontColor(hAnnotationToolPaletteKey, ToolStringKey, m_TE_FontColorRed, m_TE_FontColorGreen, m_TE_FontColorBlue); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do text entry, font name, size, bold, italic, strikethru, underline m_strTE_FontName = "01234567890123456789012345678901"; // initialize to max - 32 chars bResult = Registry->GetFontAttributes(hAnnotationToolPaletteKey, ToolStringKey, m_strTE_FontName, (LPINT)&m_uTE_FontSize, &m_bTE_FontBold, &m_bTE_FontItalic, &m_bTE_FontStrikeThru, &m_bTE_FontUnderline,&m_TE_FontCharSet); if (bResult == FALSE) { m_strTE_FontName = strBuffer; m_uTE_FontSize = DefaultFontSize; m_bTE_FontBold = m_bTE_FontItalic = m_bTE_FontStrikeThru = m_bTE_FontUnderline = FALSE; m_TE_FontCharSet = bDefaultCharset; bResult = Registry->SetFontAttributes(hAnnotationToolPaletteKey, ToolStringKey, m_strTE_FontName, m_uTE_FontSize, m_bTE_FontBold, m_bTE_FontItalic, m_bTE_FontStrikeThru, m_bTE_FontUnderline,m_TE_FontCharSet); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do text attachment, font color _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"ATTACH_A_NOTE_TOOL"); bResult = Registry->GetFontColor(hAnnotationToolPaletteKey, ToolStringKey, &m_TA_FontColorRed, &m_TA_FontColorGreen, &m_TA_FontColorBlue); if (bResult == FALSE) { // default font color is black m_TA_FontColorRed = 0; m_TA_FontColorGreen = 0; m_TA_FontColorBlue = 0; bResult = Registry->SetFontColor(hAnnotationToolPaletteKey, ToolStringKey, m_TA_FontColorRed, m_TA_FontColorGreen, m_TA_FontColorBlue); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do text attachment, back color bResult = Registry->GetBackColor(hAnnotationToolPaletteKey, ToolStringKey, &m_TA_BackColorRed, &m_TA_BackColorGreen, &m_TA_BackColorBlue); if (bResult == FALSE) { // default color is yellow m_TA_BackColorRed = 255; m_TA_BackColorGreen = 255; m_TA_BackColorBlue = 0; bResult = Registry->SetBackColor(hAnnotationToolPaletteKey, ToolStringKey, m_TA_BackColorRed, m_TA_BackColorGreen, m_TA_BackColorBlue); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do text attachment, font name, size, bold, italic, strikethru, underline m_strTA_FontName = "01234567890123456789012345678901"; // initialize to max - 32 chars bResult = Registry->GetFontAttributes(hAnnotationToolPaletteKey, ToolStringKey, m_strTA_FontName, (LPINT)&m_uTA_FontSize, &m_bTA_FontBold, &m_bTA_FontItalic, &m_bTA_FontStrikeThru, &m_bTA_FontUnderline,&m_TA_FontCharSet); if (bResult == FALSE) { m_strTA_FontName = strBuffer; m_uTA_FontSize = DefaultFontSize; m_bTA_FontBold = m_bTA_FontItalic = m_bTA_FontStrikeThru = m_bTA_FontUnderline = FALSE; m_TA_FontCharSet = bDefaultCharset; bResult = Registry->SetFontAttributes(hAnnotationToolPaletteKey, ToolStringKey, m_strTA_FontName, m_uTA_FontSize, m_bTA_FontBold, m_bTA_FontItalic, m_bTA_FontStrikeThru, m_bTA_FontUnderline,m_TA_FontCharSet); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do text from file, font color _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"TEXT_FROM_FILE_TOOL"); bResult = Registry->GetFontColor(hAnnotationToolPaletteKey, ToolStringKey, &m_TF_FontColorRed, &m_TF_FontColorGreen, &m_TF_FontColorBlue); if (bResult == FALSE) { // default font color is black m_TF_FontColorRed = 0; m_TF_FontColorGreen = 0; m_TF_FontColorBlue = 0; bResult = Registry->SetFontColor(hAnnotationToolPaletteKey, ToolStringKey, m_TF_FontColorRed, m_TF_FontColorGreen, m_TF_FontColorBlue); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // do text from file, font name, size, bold, italic, strikethru, underline m_strTF_FontName = "01234567890123456789012345678901"; // initialize to max - 32 chars bResult = Registry->GetFontAttributes(hAnnotationToolPaletteKey, ToolStringKey, m_strTF_FontName, (LPINT)&m_uTF_FontSize, &m_bTF_FontBold, &m_bTF_FontItalic, &m_bTF_FontStrikeThru, &m_bTF_FontUnderline,&m_TF_FontCharSet); if (bResult == FALSE) { m_strTF_FontName = strBuffer; m_uTF_FontSize = DefaultFontSize; m_bTF_FontBold = m_bTF_FontItalic = m_bTF_FontStrikeThru = m_bTF_FontUnderline = FALSE; m_TF_FontCharSet = bDefaultCharset; bResult = Registry->SetFontAttributes(hAnnotationToolPaletteKey, ToolStringKey, m_strTF_FontName, m_uTF_FontSize, m_bTF_FontBold, m_bTF_FontItalic, m_bTF_FontStrikeThru, m_bTF_FontUnderline,m_TF_FontCharSet); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // get the current color scheme Registry->GetColorScheme(hAnnotationToolPaletteKey, &m_CurrentColorScheme); ////////////////////////// // RUBBER STAMPS // ////////////////////////// // no stamp info found initially bFoundStampInfo = FALSE; // get rubber stamp count and current stamp bResult = Registry->GetStampCount(hAnnotationToolPaletteKey, &StampCount, CurrentStamp); if (bResult == TRUE && StampCount > 0) { m_pRubberStampStruct = new CRubberStampStruct(StampCount); if (m_pRubberStampStruct == NULL) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } m_pRubberStampStruct->m_nStampCount = StampCount; m_pRubberStampStruct->m_strCurrentStamp = CurrentStamp; m_pRubberStampStruct->m_uCurrentStampIndex = 0; // get info for each stamp for (i = 0; i < StampCount; i++) { // get reference name, attribute string and stamp type bResult = Registry->GetStampInfo(hAnnotationToolPaletteKey, i + 1, RefName, AttributeString, &StampType); if (bResult == TRUE) { // compare current stamp with each stamp info to get current index if (_mbscmp((unsigned char *)CurrentStamp, (const unsigned char *)RefName) == 0) m_pRubberStampStruct->m_uCurrentStampIndex = i; // add this stamp to internal stamp class bResult = m_pRubberStampStruct->AddStamp(i, RefName, AttributeString, StampType); if (bResult == FALSE) break; // go to rubber stamp key off of annotation tool palette key so we can get // the font color and font attributes with member functions lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, "RUBBER_STAMP_TOOL", 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) // use defaults, something wrong with registry break; // get font color for this stamp _mbscpy((unsigned char *)StampCountString, (const unsigned char *)"STAMP_"); _itoa(i+1, StampCountString+6, 10); bResult = Registry->GetFontColor(hToolKey, StampCountString, &FontColorRed, &FontColorGreen, &FontColorBlue); if (bResult == FALSE) { RegCloseKey(hToolKey); break; } szFontName = "01234567890123456789012345678901"; // initialize to max - 32 chars bResult = Registry->GetFontAttributes(hToolKey, StampCountString, szFontName, (LPINT)&uFontSize, &bFontBold, &bFontItalic, &bFontStrikeThru, &bFontUnderline, &FontCharSet); if (bResult == FALSE) { RegCloseKey(hToolKey); break; } // close the "STAMP_X" key RegCloseKey(hToolKey); // add stamp attributes to internal stamp class bResult = m_pRubberStampStruct->UpdateStampAttributes(i, FontColorRed, FontColorGreen, FontColorBlue, (LPCTSTR)szFontName.GetBuffer(LF_FACESIZE), uFontSize, bFontBold, bFontItalic, bFontStrikeThru, bFontUnderline, FontCharSet); if (bResult == FALSE) { RegCloseKey(hToolKey); break; } } else break; } // end for if (i == StampCount) bFoundStampInfo = TRUE; } // write default stamp attributes if (bFoundStampInfo == FALSE) { // rubber stamp not found in registry, use defaults StampCount = 4; strRubberStampApproved.LoadString(IDS_RUBBERSTAMP_APPROVED); bResult = Registry->SetStampCount(hAnnotationToolPaletteKey, StampCount, strRubberStampApproved.GetBuffer(STAMPSIZE)); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } m_pRubberStampStruct = new CRubberStampStruct(StampCount); if (m_pRubberStampStruct == NULL) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } m_pRubberStampStruct->m_nStampCount = StampCount; m_pRubberStampStruct->m_strCurrentStamp = strRubberStampApproved; m_pRubberStampStruct->m_uCurrentStampIndex = 0; for (i = 0; i < StampCount; i++) { StampType = TEXT_STAMP; if (i == 0) { // Approved _mbscpy((unsigned char *)AttributeString, (const unsigned char *)strRubberStampApproved.GetBuffer(STAMPSIZE)); _mbscat((unsigned char *)AttributeString, (const unsigned char *)DateMacroString); // " %x" _mbscpy((unsigned char *)RefName, (const unsigned char *)strRubberStampApproved.GetBuffer(STAMPSIZE)); // default font color is dark green FontColorRed = 0; FontColorGreen = 0x80; FontColorBlue = 0; } if (i == 1) { // DRAFT strRubberStampDraft.LoadString(IDS_RUBBERSTAMP_DRAFT); _mbscpy((unsigned char *)AttributeString, (const unsigned char *)strRubberStampDraft.GetBuffer(STAMPSIZE)); _mbscpy((unsigned char *)RefName, (const unsigned char *)strRubberStampDraft.GetBuffer(STAMPSIZE)); // default font color is black FontColorRed = 0; FontColorGreen = 0; FontColorBlue = 0; } if (i == 2) { // Received strRubberStampReceived.LoadString(IDS_RUBBERSTAMP_RECEIVED); _mbscpy((unsigned char *)AttributeString, (const unsigned char *)strRubberStampReceived.GetBuffer(STAMPSIZE)); _mbscat((unsigned char *)AttributeString, (const unsigned char *)DateMacroString); // " %x" _mbscpy((unsigned char *)RefName, (const unsigned char *)strRubberStampReceived.GetBuffer(STAMPSIZE)); // default font color is dark blue FontColorRed = 0; FontColorGreen = 0; FontColorBlue = 0x80; } if (i == 3) { // Rejected strRubberStampRejected.LoadString(IDS_RUBBERSTAMP_REJECTED); _mbscpy((unsigned char *)AttributeString, (const unsigned char *)strRubberStampRejected.GetBuffer(STAMPSIZE)); _mbscat((unsigned char *)AttributeString, (const unsigned char *)DateMacroString); // " %x" _mbscpy((unsigned char *)RefName, (const unsigned char *)strRubberStampRejected.GetBuffer(STAMPSIZE)); // default font color is red FontColorRed = 255; FontColorGreen = 0; FontColorBlue = 0; } // set default reference name, attribute string and stamp type bResult = Registry->SetStampInfo(hAnnotationToolPaletteKey, i + 1, RefName, AttributeString, StampType); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } // add this stamp to internal stamp class bResult = m_pRubberStampStruct->AddStamp(i, RefName, AttributeString, StampType); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } // for rubber stamp we need to find the "STAMP_X" key first before we can use the // font color and font attributes functions. lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, "RUBBER_STAMP_TOOL", 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } _mbscpy((unsigned char *)StampCountString, (const unsigned char *)"STAMP_"); _itoa(i+1, StampCountString+6, 10); bResult = Registry->SetFontColor(hToolKey, StampCountString, FontColorRed, FontColorGreen, FontColorBlue); if (bResult == FALSE) { RegCloseKey(hToolKey); Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } // set the font attributes for the stamp szFontName = strBuffer; uFontSize = DefaultFontSize; bFontBold = TRUE; bFontItalic = bFontStrikeThru = bFontUnderline = FALSE; FontCharSet = bDefaultCharset; bResult = Registry->SetFontAttributes(hToolKey, StampCountString, szFontName, uFontSize, bFontBold, bFontItalic, bFontStrikeThru, bFontUnderline, FontCharSet); if (bResult == FALSE) { RegCloseKey(hToolKey); Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } // add stamp attributes to internal stamp class bResult = m_pRubberStampStruct->UpdateStampAttributes(i, FontColorRed, FontColorGreen, FontColorBlue, (LPCTSTR)szFontName.GetBuffer(LF_FACESIZE), uFontSize, bFontBold, bFontItalic, bFontStrikeThru, bFontUnderline, FontCharSet); if (bResult == FALSE) { RegCloseKey(hToolKey); Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return FALSE; } } // end for } Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return bResult; } LRESULT CMiniToolBox::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) { char FontName[LF_FACESIZE]; switch(message) { case WM_COMMAND: switch(wParam) { case ID_ANNOTATION_SELECTION: // set the annotation type in Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_ANNOTATION_SELECTION, 0L); // send msg to Image/Edit control to fire ToolSelected event. // ToolSelectedId is button + 1, 0 is defined as no tool m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, wParam + 1, 0L); break; case ID_FREEHAND_LINE: m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, OI_OPAQUE, 0L); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_LINESIZE, m_uFL_LineWidth, 0L); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, m_FL_LineColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, m_FL_LineColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, m_FL_LineColorBlue, 0); // set the annotation type in Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_FREEHAND_LINE, 0L); // send msg to Image/Edit control to fire ToolSelected event. m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, wParam + 1, 0L); break; case ID_HIGHLIGHTING_LINE: m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, OI_TRANSPARENT, 0L); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, m_HL_LineColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, m_HL_LineColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, m_HL_LineColorBlue, 0); // set the annotation type in Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_HIGHLIGHT_LINE, 0L); // send msg to Image/Edit control to fire ToolSelected event. m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, wParam + 1, 0L); break; case ID_STRAIGHT_LINE: m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, OI_OPAQUE, 0L); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_LINESIZE, m_uSL_LineWidth, 0L); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, m_SL_LineColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, m_SL_LineColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, m_SL_LineColorBlue, 0); // set the annotation type in Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_STRAIGHT_LINE, 0L); // send msg to Image/Edit control to fire ToolSelected event. m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, wParam + 1, 0L); break; case ID_HOLLOW_RECT: m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, m_uHR_LineStyle, 0L); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_LINESIZE, m_uHR_LineWidth, 0L); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, m_HR_LineColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, m_HR_LineColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, m_HR_LineColorBlue, 0); // set the annotation type in Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_HOLLOW_RECT, 0L); // send msg to Image/Edit control to fire ToolSelected event. m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, wParam + 1, 0L); break; case ID_FILLED_RECT: m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, OI_OPAQUE, 0L); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, m_FR_FillColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, m_FR_FillColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, m_FR_FillColorBlue, 0); // set the annotation type in Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_FILLED_RECT, 0L); // send msg to Image/Edit control to fire ToolSelected event. m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, wParam + 1, 0L); break; case ID_TEXT: // send font name _mbscpy((unsigned char *)FontName, (const unsigned char *)m_strTE_FontName.GetBuffer(LF_FACESIZE)); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTNAME, 0, (LPARAM)FontName); // send font size m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSIZE, 0, m_uTE_FontSize); // send font bold characteristic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTBOLD, m_bTE_FontBold, 0L); // send italic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTITALIC, m_bTE_FontItalic, 0L); // send font strikethru m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSTRIKETHRU, m_bTE_FontStrikeThru, 0L); // send font underline m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTUNDERLINE, m_bTE_FontUnderline, 0L); // send font char set m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTCHARSET, m_TE_FontCharSet, 0L); // send the font color to Image/edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, m_TE_FontColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, m_TE_FontColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, m_TE_FontColorBlue, 0); // set the annotation type in Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_TEXT, 0L); // send msg to Image/Edit control to fire ToolSelected event. m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, wParam + 1, 0L); break; case ID_TEXT_ATTACHMENT: // send font name _mbscpy((unsigned char *)FontName, (const unsigned char *)m_strTA_FontName.GetBuffer(LF_FACESIZE)); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTNAME, 0, (LPARAM)FontName); // send font size m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSIZE, 0, m_uTA_FontSize); // send font bold characteristic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTBOLD, m_bTA_FontBold, 0L); // send italic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTITALIC, m_bTA_FontItalic, 0L); // send font strikethru m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSTRIKETHRU, m_bTA_FontStrikeThru, 0L); // send font underline m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTUNDERLINE, m_bTA_FontUnderline, 0L); // send font char set m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTCHARSET, m_TA_FontCharSet, 0L); // send the font color m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, m_TA_FontColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, m_TA_FontColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, m_TA_FontColorBlue, 0); // send the backcolor m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BACKREDCOLOR, m_TA_BackColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BACKGREENCOLOR, m_TA_BackColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BACKBLUECOLOR, m_TA_BackColorBlue, 0); // send the annotation type m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_TEXT_ATTACHMENT, 0L); // send msg to Image/Edit control to fire ToolSelected event. m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, wParam + 1, 0L); break; case ID_TEXT_FROM_FILE: // send font name _mbscpy((unsigned char *)FontName, (const unsigned char *)m_strTF_FontName.GetBuffer(LF_FACESIZE)); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTNAME, 0, (LPARAM)FontName); // send font size m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSIZE, 0, m_uTF_FontSize); // send font bold characteristic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTBOLD, m_bTF_FontBold, 0L); // send italic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTITALIC, m_bTF_FontItalic, 0L); // send font strikethru m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSTRIKETHRU, m_bTF_FontStrikeThru, 0L); // send font underline m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTUNDERLINE, m_bTF_FontUnderline, 0L); // send font char set m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTCHARSET, m_TF_FontCharSet, 0L); // send the font color m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, m_TF_FontColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, m_TF_FontColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, m_TF_FontColorBlue, 0); // set the annotation type in Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_TEXT_FROM_FILE, 0L); // send msg to Image/Edit control to fire ToolSelected event. m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, wParam + 1, 0L); break; case ID_RUBBER_STAMP: break; default: break; } // end switch break; default: break; } // end switch return CMiniFrameWnd::WindowProc(message, wParam, lParam); } BOOL CMiniToolBox::SelectTool(UINT ToolId) { BOOL bResult; int i; if (ToolId == NO_TOOL) { // turn off selection of all buttons for (i = 0; i <= ID_RUBBER_STAMP; i++) bResult = m_PaletteBar.CheckButton(i, FALSE); // set annotation type to none m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_NO_ANNOTATION, 0L); // send a no tool event m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, NO_TOOL, 0L); } else { // buttons are 0 based not starting at 1 ToolId--; bResult = m_PaletteBar.CheckButton(ToolId, TRUE); // send command msg which will set tool attribtes and tool selected event if (bResult == TRUE) SendMessage(WM_COMMAND, (WPARAM)ToolId, 0L); } return bResult; } void CMiniToolBox::ShowAttribsDialog(UINT ToolId) { OIAN_MARK_ATTRIBUTES Attribute; LPOITP_STAMPS lpStampStruct; LPOITP_STAMP lpStampArray[MAX_STAMPS]; BOOL bChangeStyle,bEmptyString; CUpdateRegistry *Registry; CWnd *Parent, *TopParent; CString CurrentStamp; BYTE FontColorRed, FontColorGreen, FontColorBlue; char RefName[MAXREFNAME_SIZE],AttributeString[300],FontName[LF_FACESIZE]; UINT uFontSize,StampType; BOOL bResult,bFontBold,bFontItalic,bFontStrikeThru,bFontUnderline; BYTE FontCharSet; int RetCode,StampCount,i; long lRet; HKEY hAnnotationToolPaletteKey,hToolKey; char ToolStringKey[50],StampCountString[50]; HINSTANCE hDLLInst; RT_OiUIAttribDlgBox lpOiUIAttribDlgBox; RT_OiUIStampAttribDlgBox lpOiUIStampAttribDlgBox; hDLLInst = LoadLibrary((LPCTSTR)"OIUI400.DLL"); if (hDLLInst == NULL) return; // make modal to top most window TopParent = Parent = m_pImageWnd->GetParent(); while (Parent != NULL) { Parent = Parent->GetParent(); if (Parent != NULL) TopParent = Parent; } // bring up stamp dialog if rubber stamp if (ToolId == ID_RUBBER_STAMP) { // need to setup StampStruct variable for call to StampDialog api StampCount = m_pRubberStampStruct->m_nStampCount; lpStampStruct = (LPOITP_STAMPS) malloc(sizeof(OITP_STAMPS)); if (lpStampStruct == NULL) return; memset(lpStampStruct, 0, sizeof(OITP_STAMPS)); lpStampStruct->uStampCount = (short)StampCount; lpStampStruct->uCurrentStamp = 0; for (i = 0; i < TP_STAMPCNT; i++) { // allocate memory for each stamp lpStampArray[i] = (LPOITP_STAMP) malloc(sizeof(OITP_STAMP)); if (lpStampArray[i] == NULL) { FreeLibrary(hDLLInst); return; } // set the pointer to the new allocated stamp lpStampStruct->Stamps[i] = lpStampArray[i]; } // get and set attributes for each stamp for (i = 0; i < StampCount; i++) { memset(&lpStampArray[i]->StartStruct, 0, sizeof(OIOP_START_OPERATION_STRUCT)); // get attribute info for this stamp bResult = m_pRubberStampStruct->GetStampAttributes(i, RefName, AttributeString, &StampType, &FontColorRed, &FontColorGreen, &FontColorBlue, FontName, &uFontSize, &bFontBold, &bFontItalic, &bFontStrikeThru, &bFontUnderline, &FontCharSet); if (bResult == FALSE) { FreeLibrary(hDLLInst); return; } // set reference name _mbscpy((unsigned char *)lpStampArray[i]->szRefName, (const unsigned char *)RefName); bEmptyString = m_pRubberStampStruct->m_strCurrentStamp.IsEmpty(); if (bEmptyString == FALSE) { // set the current stamp int CmpValue = _mbscmp((const unsigned char *)m_pRubberStampStruct->m_strCurrentStamp.GetBuffer(MAXREFNAME_SIZE), (const unsigned char *)lpStampArray[i]->szRefName); if (CmpValue == 0) lpStampStruct->uCurrentStamp = (short)i; } // set Stamp text or image file name _mbscpy((unsigned char *)lpStampArray[i]->StartStruct.szString, (const unsigned char *)AttributeString); // set attribute type if (StampType == IMAGE_EMBEDDED) lpStampArray[i]->StartStruct.Attributes.uType = OIOP_AN_IMAGE; else lpStampArray[i]->StartStruct.Attributes.uType = OIOP_AN_TEXT_STAMP; // set all the font attributes even if an image stamp because the stamp dialog needs // default stamp values. // set the font color lpStampArray[i]->StartStruct.Attributes.rgbColor1.rgbRed = FontColorRed; lpStampArray[i]->StartStruct.Attributes.rgbColor1.rgbGreen = FontColorGreen; lpStampArray[i]->StartStruct.Attributes.rgbColor1.rgbBlue = FontColorBlue; // set the font attributes // set the font name _mbscpy((unsigned char *)lpStampArray[i]->StartStruct.Attributes.lfFont.lfFaceName, (const unsigned char *)FontName); // set font size lpStampArray[i]->StartStruct.Attributes.lfFont.lfHeight = uFontSize; // set font characteristics if (bFontBold) lpStampArray[i]->StartStruct.Attributes.lfFont.lfWeight = 700; // bold else lpStampArray[i]->StartStruct.Attributes.lfFont.lfWeight = 400; // normal lpStampArray[i]->StartStruct.Attributes.lfFont.lfItalic = (BYTE)bFontItalic; lpStampArray[i]->StartStruct.Attributes.lfFont.lfStrikeOut = (BYTE)bFontStrikeThru; lpStampArray[i]->StartStruct.Attributes.lfFont.lfUnderline = (BYTE)bFontUnderline; lpStampArray[i]->StartStruct.Attributes.lfFont.lfCharSet = FontCharSet; } // end for // get address of stamp dialog lpOiUIStampAttribDlgBox = (RT_OiUIStampAttribDlgBox) GetProcAddress(hDLLInst, (LPCSTR)"OiUIStampAttribDlgBox"); if (lpOiUIStampAttribDlgBox == NULL) { FreeLibrary(hDLLInst); return; } // disable mini toolbox window so user can't click on it and bring up another dialog box EnableWindow(FALSE); // bring up attributes dialog box RetCode = (int) (*lpOiUIStampAttribDlgBox) (TopParent->m_hWnd, lpStampStruct); // enable mini toolbox window EnableWindow(TRUE); FreeLibrary(hDLLInst); if (RetCode != 0) { // probably here bacause cancel was pressed // free stamp memory for (i = 0; i < TP_STAMPCNT; i++) { lpStampArray[i] = lpStampStruct->Stamps[i]; free(lpStampArray[i]); } free(lpStampStruct); return; } // no stamp, set the annotation type as no tool for startop 1/31/96 JCW if (lpStampStruct->uStampCount == 0) { m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_NO_ANNOTATION, 0L); } Registry = new CUpdateRegistry; if (Registry == NULL) { for (i = 0; i < TP_STAMPCNT; i++) { lpStampArray[i] = lpStampStruct->Stamps[i]; free(lpStampArray[i]); } free(lpStampStruct); return; } // open the registry hAnnotationToolPaletteKey = Registry->OpenRegistry(); if (hAnnotationToolPaletteKey == 0) { for (i = 0; i < TP_STAMPCNT; i++) { lpStampArray[i] = lpStampStruct->Stamps[i]; free(lpStampArray[i]); } free(lpStampStruct); delete Registry; return; } StampCount = lpStampStruct->uStampCount; // reset the stamp info list (allocates or deallocates memory as necessary) m_pRubberStampStruct->m_nStampCount = StampCount; m_pRubberStampStruct->m_pRubberStampInfo->SetSize(StampCount); // get the current stamp for (i = 0; i < StampCount; i++) { lpStampArray[i] = lpStampStruct->Stamps[i]; // set default reference name, attribute string and stamp type if (lpStampStruct->uCurrentStamp == i) { CurrentStamp = lpStampArray[i]->szRefName; break; } } // end for // write out stamp count value under "RUBBER_STAMP_TOOL" key if (StampCount > 0) bResult = Registry->SetStampCount(hAnnotationToolPaletteKey, StampCount, CurrentStamp); else bResult = Registry->SetStampCount(hAnnotationToolPaletteKey, StampCount, ""); if (bResult == FALSE) { for (i = 0; i < TP_STAMPCNT; i++) { lpStampArray[i] = lpStampStruct->Stamps[i]; free(lpStampArray[i]); } free(lpStampStruct); Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return; } if (StampCount > 0) { m_pRubberStampStruct->m_strCurrentStamp = CurrentStamp; for (i = 0; i < StampCount; i++) { lpStampArray[i] = lpStampStruct->Stamps[i]; // set default reference name, attribute string and stamp type _mbscpy((unsigned char *)RefName, (const unsigned char *)lpStampArray[i]->szRefName); _mbscpy((unsigned char *)AttributeString, (const unsigned char *)lpStampArray[i]->StartStruct.szString); if (lpStampArray[i]->StartStruct.Attributes.uType == OIOP_AN_IMAGE) StampType = IMAGE_EMBEDDED; else StampType = TEXT_STAMP; // write reference name, attribute string and stamp type to registry bResult = Registry->SetStampInfo(hAnnotationToolPaletteKey, i + 1, RefName, AttributeString, StampType); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return; } // add this stamp to internal stamp class bResult = m_pRubberStampStruct->AddStamp(i, RefName, AttributeString, StampType); if (bResult == FALSE) return; // the stamp dialog box is expecting the font name, size and attributes to be // valid for an image stamp as well, because it will use the last stamp to // create attributes for a new stamp regardless of the last stamp. Therefore // set font attributes for image stamp as well as text stamp. Do not write // font stuff to registry for text stamps. // for rubber stamp we need to find the "STAMP_X" key first before we can use the // font color and font attributes functions. lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, "RUBBER_STAMP_TOOL", 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return; } // set the stamp count string _mbscpy((unsigned char *)StampCountString, (const unsigned char *)"STAMP_"); _itoa(i+1, StampCountString+6, 10); // set font color FontColorRed = lpStampArray[i]->StartStruct.Attributes.rgbColor1.rgbRed; FontColorGreen = lpStampArray[i]->StartStruct.Attributes.rgbColor1.rgbGreen; FontColorBlue = lpStampArray[i]->StartStruct.Attributes.rgbColor1.rgbBlue; // write out font color bResult = Registry->SetFontColor(hToolKey, StampCountString, FontColorRed, FontColorGreen, FontColorBlue); if (bResult == FALSE) { RegCloseKey(hToolKey); Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return; } // set the font name _mbscpy((unsigned char *)FontName, (const unsigned char *)lpStampArray[i]->StartStruct.Attributes.lfFont.lfFaceName); // set font size uFontSize = lpStampArray[i]->StartStruct.Attributes.lfFont.lfHeight; // set font characteristics if (lpStampArray[i]->StartStruct.Attributes.lfFont.lfWeight < 700) bFontBold = FALSE; else bFontBold = TRUE; bFontItalic = lpStampArray[i]->StartStruct.Attributes.lfFont.lfItalic; bFontStrikeThru = lpStampArray[i]->StartStruct.Attributes.lfFont.lfStrikeOut; bFontUnderline = lpStampArray[i]->StartStruct.Attributes.lfFont.lfUnderline; FontCharSet = lpStampArray[i]->StartStruct.Attributes.lfFont.lfCharSet; // write out font attributes bResult = Registry->SetFontAttributes(hToolKey, StampCountString, FontName, uFontSize, bFontBold, bFontItalic, bFontStrikeThru, bFontUnderline, FontCharSet); if (bResult == FALSE) { RegCloseKey(hToolKey); Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return; } // close the "STAMP_X" key RegCloseKey(hToolKey); // add stamp attributes to internal stamp class bResult = m_pRubberStampStruct->UpdateStampAttributes(i, FontColorRed, FontColorGreen, FontColorBlue, FontName, uFontSize, bFontBold, bFontItalic, bFontStrikeThru, bFontUnderline, FontCharSet); if (bResult == FALSE) { Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return; } // send the current stamp attributes to the image/edit control if (lpStampStruct->uCurrentStamp == i) SelectStamp(i, FALSE); } // end for } // end if stamp count > 0 // free stamp memory for (i = 0; i < TP_STAMPCNT; i++) { lpStampArray[i] = lpStampStruct->Stamps[i]; free(lpStampArray[i]); } free(lpStampStruct); Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; return; } // end if rubber stamp _fmemset(&Attribute,0,sizeof(Attribute)); switch(ToolId) { case ID_FREEHAND_LINE: Attribute.uLineSize = m_uFL_LineWidth; Attribute.rgbColor1.rgbRed = m_FL_LineColorRed; Attribute.rgbColor1.rgbGreen = m_FL_LineColorGreen; Attribute.rgbColor1.rgbBlue = m_FL_LineColorBlue; Attribute.uType = OIOP_AN_FREEHAND; break; case ID_HIGHLIGHTING_LINE: Attribute.rgbColor1.rgbRed = m_HL_LineColorRed; Attribute.rgbColor1.rgbGreen = m_HL_LineColorGreen; Attribute.rgbColor1.rgbBlue = m_HL_LineColorBlue; // change to filled rect Attribute.uType = OIOP_AN_FILLED_RECT; Attribute.bHighlighting = TRUE; break; case ID_STRAIGHT_LINE: Attribute.uLineSize = m_uSL_LineWidth; Attribute.rgbColor1.rgbRed = m_SL_LineColorRed; Attribute.rgbColor1.rgbGreen = m_SL_LineColorGreen; Attribute.rgbColor1.rgbBlue = m_SL_LineColorBlue; Attribute.uType = OIOP_AN_LINE; break; case ID_HOLLOW_RECT: Attribute.uLineSize = m_uHR_LineWidth; Attribute.rgbColor1.rgbRed = m_HR_LineColorRed; Attribute.rgbColor1.rgbGreen = m_HR_LineColorGreen; Attribute.rgbColor1.rgbBlue = m_HR_LineColorBlue; if (m_uHR_LineStyle == OI_TRANSPARENT) Attribute.bHighlighting = TRUE; else Attribute.bHighlighting = FALSE; Attribute.uType = OIOP_AN_HOLLOW_RECT; break; case ID_FILLED_RECT: Attribute.rgbColor1.rgbRed = m_FR_FillColorRed; Attribute.rgbColor1.rgbGreen = m_FR_FillColorGreen; Attribute.rgbColor1.rgbBlue = m_FR_FillColorBlue; Attribute.bHighlighting = FALSE; Attribute.uType = OIOP_AN_FILLED_RECT; break; case ID_TEXT: Attribute.rgbColor1.rgbRed = m_TE_FontColorRed; Attribute.rgbColor1.rgbGreen = m_TE_FontColorGreen; Attribute.rgbColor1.rgbBlue = m_TE_FontColorBlue; // set font name _mbscpy((unsigned char *)Attribute.lfFont.lfFaceName, (const unsigned char *)m_strTE_FontName.GetBuffer(LF_FACESIZE)); // set font size Attribute.lfFont.lfHeight = m_uTE_FontSize; // set font characteristics if (m_bTE_FontBold == FALSE) Attribute.lfFont.lfWeight = 400; // normal else Attribute.lfFont.lfWeight = 700; // bold Attribute.lfFont.lfItalic = (BYTE)m_bTE_FontItalic; Attribute.lfFont.lfStrikeOut = (BYTE)m_bTE_FontStrikeThru; Attribute.lfFont.lfUnderline = (BYTE)m_bTE_FontUnderline; Attribute.lfFont.lfCharSet = m_TE_FontCharSet; Attribute.uType = OIOP_AN_TEXT; break; case ID_TEXT_ATTACHMENT: // set back ground color Attribute.rgbColor1.rgbRed = m_TA_BackColorRed; Attribute.rgbColor1.rgbGreen = m_TA_BackColorGreen; Attribute.rgbColor1.rgbBlue = m_TA_BackColorBlue; // set font color Attribute.rgbColor2.rgbRed = m_TA_FontColorRed; Attribute.rgbColor2.rgbGreen = m_TA_FontColorGreen; Attribute.rgbColor2.rgbBlue = m_TA_FontColorBlue; // set font name _mbscpy((unsigned char *)Attribute.lfFont.lfFaceName, (const unsigned char *)m_strTA_FontName.GetBuffer(LF_FACESIZE)); // set font size Attribute.lfFont.lfHeight = m_uTA_FontSize; // set font characteristics if (m_bTA_FontBold == FALSE) Attribute.lfFont.lfWeight = 400; // normal else Attribute.lfFont.lfWeight = 700; // bold Attribute.lfFont.lfItalic = (BYTE)m_bTA_FontItalic; Attribute.lfFont.lfStrikeOut = (BYTE)m_bTA_FontStrikeThru; Attribute.lfFont.lfUnderline = (BYTE)m_bTA_FontUnderline; Attribute.lfFont.lfCharSet = m_TA_FontCharSet; Attribute.uType = OIOP_AN_ATTACH_A_NOTE; break; case ID_TEXT_FROM_FILE: Attribute.rgbColor1.rgbRed = m_TF_FontColorRed; Attribute.rgbColor1.rgbGreen = m_TF_FontColorGreen; Attribute.rgbColor1.rgbBlue = m_TF_FontColorBlue; // set font name _mbscpy((unsigned char *)Attribute.lfFont.lfFaceName, (const unsigned char *)m_strTF_FontName.GetBuffer(LF_FACESIZE)); // set font size Attribute.lfFont.lfHeight = m_uTF_FontSize; // set font characteristics if (m_bTF_FontBold == FALSE) Attribute.lfFont.lfWeight = 400; // normal else Attribute.lfFont.lfWeight = 700; // bold Attribute.lfFont.lfItalic = (BYTE)m_bTF_FontItalic; Attribute.lfFont.lfStrikeOut = (BYTE)m_bTF_FontStrikeThru; Attribute.lfFont.lfUnderline =(BYTE) m_bTF_FontUnderline; Attribute.lfFont.lfCharSet = m_TF_FontCharSet; Attribute.uType = OIOP_AN_TEXT_FROM_A_FILE; break; default: break; } // end switch // if hollow rect or filled rect then allow the user thru the dialog box // to change the line or fill style. if (ToolId == ID_HOLLOW_RECT) bChangeStyle = TRUE; else bChangeStyle = FALSE; EnableWindow(FALSE); lpOiUIAttribDlgBox = (RT_OiUIAttribDlgBox) GetProcAddress(hDLLInst, (LPCSTR)"OiUIAttribDlgBox"); if (lpOiUIAttribDlgBox == NULL) { FreeLibrary(hDLLInst); return; } // bring up attributes dialog box RetCode = (int) (*lpOiUIAttribDlgBox) (TopParent->m_hWnd, bChangeStyle, &Attribute, &m_CurrentColorScheme); EnableWindow(TRUE); FreeLibrary(hDLLInst); if (RetCode != 0) return; Registry = new CUpdateRegistry; if (Registry == NULL) return; hAnnotationToolPaletteKey = Registry->OpenRegistry(); if (hAnnotationToolPaletteKey == 0) { delete Registry; return; } // write out any new colors the user might have chosen Registry->SetColorScheme(hAnnotationToolPaletteKey, &m_CurrentColorScheme); switch(ToolId) { case ID_FREEHAND_LINE: case ID_STRAIGHT_LINE: if (ToolId == ID_FREEHAND_LINE) { _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"FREEHAND_LINE_TOOL"); m_uFL_LineWidth = Attribute.uLineSize; m_FL_LineColorRed = Attribute.rgbColor1.rgbRed; m_FL_LineColorGreen = Attribute.rgbColor1.rgbGreen; m_FL_LineColorBlue = Attribute.rgbColor1.rgbBlue; } else { _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"STRAIGHT_LINE_TOOL"); m_uSL_LineWidth = Attribute.uLineSize; m_SL_LineColorRed = Attribute.rgbColor1.rgbRed; m_SL_LineColorGreen = Attribute.rgbColor1.rgbGreen; m_SL_LineColorBlue = Attribute.rgbColor1.rgbBlue; } // write new line width to registry bResult = Registry->SetLineWidth(hAnnotationToolPaletteKey, ToolStringKey, Attribute.uLineSize); if (bResult == FALSE) break; // write new line color to registry bResult = Registry->SetLineColor(hAnnotationToolPaletteKey, ToolStringKey, Attribute.rgbColor1.rgbRed, Attribute.rgbColor1.rgbGreen, Attribute.rgbColor1.rgbBlue); if (bResult == FALSE) break; // set the attributes in the Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, OI_OPAQUE, 0L); // freehand and straight line is always opaque in tool palette // send the line color m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, Attribute.rgbColor1.rgbRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, Attribute.rgbColor1.rgbGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, Attribute.rgbColor1.rgbBlue, 0); // send the line size m_pImageWnd->SendMessage(STP_SET_ANNOTATION_LINESIZE, Attribute.uLineSize, 0L); // send the annotation type if (ToolId == ID_FREEHAND_LINE) m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_FREEHAND_LINE, 0L); else m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_STRAIGHT_LINE, 0L); break; case ID_HOLLOW_RECT: _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"HOLLOW_RECT_TOOL"); m_uHR_LineWidth = Attribute.uLineSize; if (Attribute.bHighlighting == TRUE) m_uHR_LineStyle = OI_TRANSPARENT; else m_uHR_LineStyle = OI_OPAQUE; m_HR_LineColorRed = Attribute.rgbColor1.rgbRed; m_HR_LineColorGreen = Attribute.rgbColor1.rgbGreen; m_HR_LineColorBlue = Attribute.rgbColor1.rgbBlue; // write new line width to registry bResult = Registry->SetLineWidth(hAnnotationToolPaletteKey, ToolStringKey, m_uHR_LineWidth); if (bResult == FALSE) break; // write new line style to registry bResult = Registry->SetStyle(hAnnotationToolPaletteKey, ToolStringKey, m_uHR_LineStyle); if (bResult == FALSE) break; // write new line color to registry bResult = Registry->SetLineColor(hAnnotationToolPaletteKey, ToolStringKey, m_HR_LineColorRed, m_HR_LineColorGreen, m_HR_LineColorBlue); if (bResult == FALSE) break; // send the line style m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, m_uHR_LineStyle, 0L); // send the line size m_pImageWnd->SendMessage(STP_SET_ANNOTATION_LINESIZE, Attribute.uLineSize, 0L); // send the line color m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, Attribute.rgbColor1.rgbRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, Attribute.rgbColor1.rgbGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, Attribute.rgbColor1.rgbBlue, 0); // send the annotation type m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_HOLLOW_RECT, 0L); break; case ID_HIGHLIGHTING_LINE: _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"HIGHLIGHT_LINE_TOOL"); m_HL_LineColorRed = Attribute.rgbColor1.rgbRed; m_HL_LineColorGreen = Attribute.rgbColor1.rgbGreen; m_HL_LineColorBlue = Attribute.rgbColor1.rgbBlue; // write new line color to registry bResult = Registry->SetLineColor(hAnnotationToolPaletteKey, ToolStringKey, Attribute.rgbColor1.rgbRed, Attribute.rgbColor1.rgbGreen, Attribute.rgbColor1.rgbBlue); if (bResult == FALSE) break; // set the attributes in the Image/Edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, OI_TRANSPARENT, 0L); // highlighting line is always transparent in tool palette // send the line color m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, Attribute.rgbColor1.rgbRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, Attribute.rgbColor1.rgbGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, Attribute.rgbColor1.rgbBlue, 0); // send the annotation type m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_HIGHLIGHT_LINE, 0L); break; case ID_FILLED_RECT: _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"FILLED_RECT_TOOL"); m_FR_FillColorRed = Attribute.rgbColor1.rgbRed; m_FR_FillColorGreen = Attribute.rgbColor1.rgbGreen; m_FR_FillColorBlue = Attribute.rgbColor1.rgbBlue; // write new fill color to registry bResult = Registry->SetFillColor(hAnnotationToolPaletteKey, ToolStringKey, m_FR_FillColorRed, m_FR_FillColorGreen, m_FR_FillColorBlue); if (bResult == FALSE) break; // send the fill style m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, OI_OPAQUE, 0L); // send the fill color m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, Attribute.rgbColor1.rgbRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, Attribute.rgbColor1.rgbGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, Attribute.rgbColor1.rgbBlue, 0); // send the annotation type m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_FILLED_RECT, 0L); break; case ID_TEXT: _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"TEXT_TOOL"); m_TE_FontColorRed = Attribute.rgbColor1.rgbRed; m_TE_FontColorGreen = Attribute.rgbColor1.rgbGreen; m_TE_FontColorBlue = Attribute.rgbColor1.rgbBlue; m_strTE_FontName = Attribute.lfFont.lfFaceName; m_uTE_FontSize = Attribute.lfFont.lfHeight; if (Attribute.lfFont.lfWeight < 700) m_bTE_FontBold = FALSE; else m_bTE_FontBold = TRUE; m_bTE_FontItalic = Attribute.lfFont.lfItalic; m_bTE_FontStrikeThru = Attribute.lfFont.lfStrikeOut; m_bTE_FontUnderline = Attribute.lfFont.lfUnderline; m_TE_FontCharSet = Attribute.lfFont.lfCharSet; // write new font color to registry bResult = Registry->SetFontColor(hAnnotationToolPaletteKey, ToolStringKey, m_TE_FontColorRed, m_TE_FontColorGreen, m_TE_FontColorBlue); if (bResult == FALSE) break; // write font characteristics to registry bResult = Registry->SetFontAttributes(hAnnotationToolPaletteKey, ToolStringKey, m_strTE_FontName, m_uTE_FontSize, m_bTE_FontBold, m_bTE_FontItalic, m_bTE_FontStrikeThru, m_bTE_FontUnderline,m_TE_FontCharSet); if (bResult == FALSE) break; // send the font name _mbscpy((unsigned char *)FontName, (const unsigned char *)m_strTE_FontName.GetBuffer(LF_FACESIZE)); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTNAME, 0, (LPARAM)FontName); // send the font size m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSIZE, 0, m_uTE_FontSize); // send the font bold m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTBOLD, m_bTE_FontBold, 0L); // send the font italic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTITALIC, m_bTE_FontItalic, 0L); // send the font strikethru m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSTRIKETHRU, m_bTE_FontStrikeThru, 0L); // send the font underline m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTUNDERLINE, m_bTE_FontUnderline, 0L); // send the font char set m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTCHARSET, m_TE_FontCharSet, 0L); // send the font color to Image/edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, Attribute.rgbColor1.rgbRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, Attribute.rgbColor1.rgbGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, Attribute.rgbColor1.rgbBlue, 0); // send the annotation type m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_TEXT, 0L); break; case ID_TEXT_ATTACHMENT: _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"ATTACH_A_NOTE_TOOL"); m_TA_BackColorRed = Attribute.rgbColor1.rgbRed; m_TA_BackColorGreen = Attribute.rgbColor1.rgbGreen; m_TA_BackColorBlue = Attribute.rgbColor1.rgbBlue; m_TA_FontColorRed = Attribute.rgbColor2.rgbRed; m_TA_FontColorGreen = Attribute.rgbColor2.rgbGreen; m_TA_FontColorBlue = Attribute.rgbColor2.rgbBlue; m_strTA_FontName = Attribute.lfFont.lfFaceName; m_uTA_FontSize = Attribute.lfFont.lfHeight; if (Attribute.lfFont.lfWeight < 700) m_bTA_FontBold = FALSE; else m_bTA_FontBold = TRUE; m_bTA_FontItalic = Attribute.lfFont.lfItalic; m_bTA_FontStrikeThru = Attribute.lfFont.lfStrikeOut; m_bTA_FontUnderline = Attribute.lfFont.lfUnderline; m_TA_FontCharSet = Attribute.lfFont.lfCharSet; // write new font color to registry bResult = Registry->SetFontColor(hAnnotationToolPaletteKey, ToolStringKey, m_TA_FontColorRed, m_TA_FontColorGreen, m_TA_FontColorBlue); if (bResult == FALSE) break; // write new back color to registry bResult = Registry->SetBackColor(hAnnotationToolPaletteKey, ToolStringKey, m_TA_BackColorRed, m_TA_BackColorGreen, m_TA_BackColorBlue); if (bResult == FALSE) break; // write font characteristics to registry bResult = Registry->SetFontAttributes(hAnnotationToolPaletteKey, ToolStringKey, m_strTA_FontName, m_uTA_FontSize, m_bTA_FontBold, m_bTA_FontItalic, m_bTA_FontStrikeThru, m_bTA_FontUnderline,m_TA_FontCharSet); if (bResult == FALSE) break; // send the font name _mbscpy((unsigned char *)FontName, (const unsigned char *)m_strTA_FontName.GetBuffer(LF_FACESIZE)); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTNAME, 0, (LPARAM)FontName); // send the font size m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSIZE, 0, m_uTA_FontSize); // send the font bold m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTBOLD, m_bTA_FontBold, 0L); // send the font italic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTITALIC, m_bTA_FontItalic, 0L); // send the font strikethru m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSTRIKETHRU, m_bTA_FontStrikeThru, 0L); // send the font underline m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTUNDERLINE, m_bTA_FontUnderline, 0L); // send the font char set m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTCHARSET, m_TA_FontCharSet, 0L); // send the font color to Image/edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, Attribute.rgbColor2.rgbRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, Attribute.rgbColor2.rgbGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, Attribute.rgbColor2.rgbBlue, 0); // send the back color m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BACKREDCOLOR, Attribute.rgbColor1.rgbRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BACKGREENCOLOR, Attribute.rgbColor1.rgbGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BACKBLUECOLOR, Attribute.rgbColor1.rgbBlue, 0); // send the annotation type m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_TEXT_ATTACHMENT, 0L); break; case ID_TEXT_FROM_FILE: _mbscpy((unsigned char *)ToolStringKey, (const unsigned char *)"TEXT_FROM_FILE_TOOL"); m_TF_FontColorRed = Attribute.rgbColor1.rgbRed; m_TF_FontColorGreen = Attribute.rgbColor1.rgbGreen; m_TF_FontColorBlue = Attribute.rgbColor1.rgbBlue; m_strTF_FontName = Attribute.lfFont.lfFaceName; m_uTF_FontSize = Attribute.lfFont.lfHeight; if (Attribute.lfFont.lfWeight < 700) m_bTF_FontBold = FALSE; else m_bTF_FontBold = TRUE; m_bTF_FontItalic = Attribute.lfFont.lfItalic; m_bTF_FontStrikeThru = Attribute.lfFont.lfStrikeOut; m_bTF_FontUnderline = Attribute.lfFont.lfUnderline; m_TF_FontCharSet = Attribute.lfFont.lfCharSet; // write new font color to registry bResult = Registry->SetFontColor(hAnnotationToolPaletteKey, ToolStringKey, m_TF_FontColorRed, m_TF_FontColorGreen, m_TF_FontColorBlue); if (bResult == FALSE) break; // write font characteristics to registry bResult = Registry->SetFontAttributes(hAnnotationToolPaletteKey, ToolStringKey, m_strTF_FontName, m_uTF_FontSize, m_bTF_FontBold, m_bTF_FontItalic, m_bTF_FontStrikeThru, m_bTF_FontUnderline,m_TF_FontCharSet); if (bResult == FALSE) break; // send the font name _mbscpy((unsigned char *)FontName, (const unsigned char *)m_strTF_FontName.GetBuffer(LF_FACESIZE)); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTNAME, 0, (LPARAM)FontName); // send the font size m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSIZE, 0, m_uTF_FontSize); // send the font bold m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTBOLD, m_bTF_FontBold, 0L); // send the font italic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTITALIC, m_bTF_FontItalic, 0L); // send the font strikethru m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSTRIKETHRU, m_bTF_FontStrikeThru, 0L); // send the font underline m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTUNDERLINE, m_bTF_FontUnderline, 0L); // send the font char set m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTCHARSET, m_TF_FontCharSet, 0L); // send the font color to Image/edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, Attribute.rgbColor1.rgbRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, Attribute.rgbColor1.rgbGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, Attribute.rgbColor1.rgbBlue, 0); // send the annotation type m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_TEXT_FROM_FILE, 0L); break; default: break; } // end switch Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; } void CMiniToolBox::SelectStamp(int StampIndex, BOOL bWriteToRegistry) { BYTE FontColorRed, FontColorGreen, FontColorBlue; char RefName[MAXREFNAME_SIZE],AttributeString[300],FontName[LF_FACESIZE]; UINT uFontSize,StampType; BOOL bResult,bFontBold,bFontItalic,bFontStrikeThru,bFontUnderline; BYTE FontCharSet; CUpdateRegistry *Registry; HKEY hAnnotationToolPaletteKey; bResult = m_pRubberStampStruct->GetStampAttributes(StampIndex, RefName, AttributeString, &StampType, &FontColorRed, &FontColorGreen, &FontColorBlue, FontName, &uFontSize, &bFontBold, &bFontItalic, &bFontStrikeThru, &bFontUnderline, &FontCharSet); if (bResult == FALSE) return; // set the current stamp m_pRubberStampStruct->m_strCurrentStamp = RefName; // save current index for when user brings up popup item but doesn't select anything. m_pRubberStampStruct->m_uCurrentStampIndex = StampIndex; // see if image stamp or text stamp if (StampType == IMAGE_EMBEDDED) { // image stamps are always opaque m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STYLE, OI_OPAQUE, 0L); // send name of image m_pImageWnd->SendMessage(STP_SET_ANNOTATION_IMAGE, 0, (LPARAM)AttributeString); // send annotation type - image stamp m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_RUBBER_STAMP, STP_IMAGESTAMP); } else { // send the font name m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTNAME, 0, (LPARAM)FontName); // set the font size m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSIZE, 0, uFontSize); // set font bold characteristic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTBOLD, bFontBold, 0L); // set italic m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTITALIC, bFontItalic, 0L); // set font strikethru m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTSTRIKETHRU, bFontStrikeThru, 0L); // set font underline m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTUNDERLINE, bFontUnderline, 0L); // send font char set m_pImageWnd->SendMessage(STP_SET_ANNOTATION_FONTCHARSET, FontCharSet, 0L); // send the font color to Image/edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_REDCOLOR, FontColorRed, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_GREENCOLOR, FontColorGreen, 0); m_pImageWnd->SendMessage(STP_SET_ANNOTATION_BLUECOLOR, FontColorBlue, 0); // send the stamp text to image/edit control m_pImageWnd->SendMessage(STP_SET_ANNOTATION_STAMPTEXT, 0, (LPARAM)AttributeString); // send annotation type to image/edit control - stamp text m_pImageWnd->SendMessage(STP_SET_ANNOTATION_TYPE, STP_RUBBER_STAMP, STP_TEXTSTAMP); } // send a tool selected event m_pImageWnd->SendMessage(TOOL_SELECTED_EVENT, ID_RUBBER_STAMP + 1, 0L); // write out new current stamp to registry if necessary if (bWriteToRegistry == TRUE) { Registry = new CUpdateRegistry; if (Registry == NULL) return; // open the registry hAnnotationToolPaletteKey = Registry->OpenRegistry(); if (hAnnotationToolPaletteKey == 0) { delete Registry; return; } // write out new stamp bResult = Registry->SetStampCount(hAnnotationToolPaletteKey, m_pRubberStampStruct->m_nStampCount, m_pRubberStampStruct->m_strCurrentStamp); if (bResult == FALSE) return; // close the registry Registry->CloseRegistry(hAnnotationToolPaletteKey); delete Registry; } } CWnd* CMiniToolBox::GetImageWnd() { return m_pImageWnd; } CString CMiniToolBox::GetToolTip(int nID) { CString strToolTipText; switch(nID) { case ID_ANNOTATION_SELECTION: strToolTipText = m_strAnnotationSelectionToolTip; break; case ID_FREEHAND_LINE: strToolTipText = m_strFreehandLineToolTip; break; case ID_HIGHLIGHTING_LINE: strToolTipText = m_strHighlightingLineToolTip; break; case ID_STRAIGHT_LINE: strToolTipText = m_strStraightLineToolTip; break; case ID_HOLLOW_RECT: strToolTipText = m_strHollowRectToolTip; break; case ID_FILLED_RECT: strToolTipText = m_strFilledRectToolTip; break; case ID_TEXT: strToolTipText = m_strTextToolTip; break; case ID_TEXT_ATTACHMENT: strToolTipText = m_strTextAttachmentToolTip; break; case ID_TEXT_FROM_FILE: strToolTipText = m_strTextFromFileToolTip; break; case ID_RUBBER_STAMP: strToolTipText = m_strRubberStampToolTip; break; } // end switch return strToolTipText; } void CMiniToolBox::OnPaint() { HBRUSH hBrush; RECT ClientRect; CPaintDC dc(this); // device context for painting // TODO: Add your message handler code here // hBrush = (HBRUSH) GetStockObject(LTGRAY_BRUSH); hBrush = GetSysColorBrush(COLOR_BTNFACE); CBrush* pBrush = CBrush::FromHandle(hBrush); GetClientRect(&ClientRect); dc.FillRect(&ClientRect, pBrush); } void CMiniToolBox::OnDestroy() { CMiniFrameWnd::OnDestroy(); RECT rect; // get position of tool palette so we know where its last position was GetWindowRect(&rect); m_pImageWnd->SendMessage(TOOLPALETTE_HIDDEN_XPOSITION, 0, (long)rect.left); m_pImageWnd->SendMessage(TOOLPALETTE_HIDDEN_YPOSITION, 0, (long)rect.top); m_pImageWnd->SendMessage(TOOLPALETTE_HIDDEN, 0, 0L); // delete rubber stamp struct delete m_pRubberStampStruct; } CRubberStampStruct::CRubberStampStruct(int StampCount) { m_nStampCount = StampCount; // allocate rubber stamp pointer struct m_pRubberStampInfo = new CPtrArray; if (m_pRubberStampInfo == NULL) return; m_pRubberStampInfo->SetSize(m_nStampCount); } BOOL CRubberStampStruct::AddStamp(int StampIndex, LPCTSTR RefName, LPCTSTR AttributeString, UINT StampType) { CRubberStampInfo *pRubberStampInfo; // create a new rubber stamp pRubberStampInfo = new CRubberStampInfo; if (pRubberStampInfo == NULL) return FALSE; // add rubber stamp to list pRubberStampInfo->m_strRefName = RefName; pRubberStampInfo->m_strString = AttributeString; pRubberStampInfo->m_uStampType = StampType; m_pRubberStampInfo->SetAt(StampIndex, pRubberStampInfo); return TRUE; } BOOL CRubberStampStruct::UpdateStampAttributes(int StampIndex, BYTE FontColorRed, BYTE FontColorGreen, BYTE FontColorBlue, LPCTSTR FontName, UINT uFontSize, BOOL bFontBold, BOOL bFontItalic, BOOL bFontStrikeThru, BOOL bFontUnderline, BYTE FontCharSet) { CRubberStampInfo *pRubberStampInfo; // get existing rubber stamp pRubberStampInfo = (CRubberStampInfo*) m_pRubberStampInfo->GetAt(StampIndex); pRubberStampInfo->m_strFontName = FontName; pRubberStampInfo->m_uFontSize = uFontSize; pRubberStampInfo->m_bFontBold = bFontBold; pRubberStampInfo->m_bFontItalic = bFontItalic; pRubberStampInfo->m_bFontStrikeThru = bFontStrikeThru; pRubberStampInfo->m_bFontUnderline = bFontUnderline; pRubberStampInfo->m_FontCharSet = FontCharSet; pRubberStampInfo->m_FontColorRed = FontColorRed; pRubberStampInfo->m_FontColorGreen = FontColorGreen; pRubberStampInfo->m_FontColorBlue = FontColorBlue; m_pRubberStampInfo->SetAt(StampIndex, pRubberStampInfo); return TRUE; } BOOL CRubberStampStruct::GetStampAttributes(int StampIndex, LPCTSTR RefName, LPCTSTR AttributeString, LPUINT StampType, LPBYTE FontColorRed, LPBYTE FontColorGreen, LPBYTE FontColorBlue, LPCTSTR FontName, LPUINT uFontSize, LPBOOL bFontBold, LPBOOL bFontItalic, LPBOOL bFontStrikeThru, LPBOOL bFontUnderline, LPBYTE FontCharSet) { CRubberStampInfo *pRubberStampInfo; // get existing rubber stamp pRubberStampInfo = (CRubberStampInfo*) m_pRubberStampInfo->GetAt(StampIndex); _mbscpy((unsigned char *)RefName, (const unsigned char *)pRubberStampInfo->m_strRefName.GetBuffer(MAXREFNAME_SIZE)); _mbscpy((unsigned char *)AttributeString, (const unsigned char *)pRubberStampInfo->m_strString.GetBuffer(300)); _mbscpy((unsigned char *)FontName, (const unsigned char *)pRubberStampInfo->m_strFontName.GetBuffer(LF_FACESIZE)); *StampType = pRubberStampInfo->m_uStampType; *uFontSize = pRubberStampInfo->m_uFontSize; *bFontBold = pRubberStampInfo->m_bFontBold; *bFontItalic = pRubberStampInfo->m_bFontItalic; *bFontStrikeThru = pRubberStampInfo->m_bFontStrikeThru; *bFontUnderline = pRubberStampInfo->m_bFontUnderline; *FontCharSet = pRubberStampInfo->m_FontCharSet; *FontColorRed = pRubberStampInfo->m_FontColorRed; *FontColorGreen = pRubberStampInfo->m_FontColorGreen; *FontColorBlue = pRubberStampInfo->m_FontColorBlue; return TRUE; } CRubberStampStruct::~CRubberStampStruct() { int nElements,i; CRubberStampInfo *pRubberStampInfo; if (m_pRubberStampInfo != NULL) { nElements = m_pRubberStampInfo->GetSize(); for (i = (nElements - 1); i >= 0; i--) { // delete elements in array pRubberStampInfo = (CRubberStampInfo*) m_pRubberStampInfo->GetAt(i); if (pRubberStampInfo != NULL) delete pRubberStampInfo; } // delete array m_pRubberStampInfo->SetSize(0); delete m_pRubberStampInfo; } } CRubberStampInfo::CRubberStampInfo() { } CRubberStampInfo::~CRubberStampInfo() { }