#include "stdafx.h" #include "mbstring.h" #include "limits.h" #include #include #include #include #include #include "afxpriv.h" #include "resource.h" extern "C" { #include #include #include #include #include } #include #include #include "toolpal.h" #include "minitlbx.h" #include "imgedit.h" #include "imgedctl.h" #include "resource.h" #ifdef _DEBUG #undef THIS_FILE static char BASED_CODE THIS_FILE[] = __FILE__; #endif static UINT NEAR TIMER_SHOW_TOOLTIP = RegisterWindowMessage("SHOW_TOOLTIP"); static UINT TIMER_CHECK_STATUS = RegisterWindowMessage("CHECK_STATUS"); // 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 CUpdateRegistry::CUpdateRegistry() { } CUpdateRegistry::~CUpdateRegistry() { } BOOL CUpdateRegistry::GetColorValue(LPCTSTR ColorBuffer, LPBYTE RedColor, LPBYTE GreenColor, LPBYTE BlueColor) { char ColorValueBuffer[10]; int i,j,Count,len,ColorValue; len = _mbstrlen(ColorBuffer); i = 0; j = 0; Count = 0; while (i < len) { if (ColorBuffer[i] == ',') { Count++; if (Count > 2) return FALSE; ColorValueBuffer[j] = '\0'; if (Count == 1) { ColorValue = atoi((const char *)ColorValueBuffer); *RedColor = (BYTE)ColorValue; } else { ColorValue = (int)atol((const char *)ColorValueBuffer); *GreenColor = (BYTE)ColorValue; } j = 0; } else { ColorValueBuffer[j] = ColorBuffer[i]; j++; } i++; } // end while if (Count != 2) return FALSE; ColorValueBuffer[j] = '\0'; ColorValue = atoi((const char *)ColorValueBuffer); *BlueColor = (BYTE)ColorValue; return TRUE; } HKEY CUpdateRegistry::OpenRegistry() { HKEY hAnnotationToolPaletteKey; DWORD dwDisposition; long lRet; // initialize to 0 in case we get an error hAnnotationToolPaletteKey = 0; // open the registry and go to SOFTWARE key under HKEY_LOCAL_MACHINE //lRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE", 0, KEY_ALL_ACCESS, &m_hSoftwareKey); //if (lRet != ERROR_SUCCESS) // return hAnnotationToolPaletteKey; lRet = RegOpenKeyEx(HKEY_CURRENT_USER, "SOFTWARE", 0, KEY_ALL_ACCESS, &m_hSoftwareKey); if (lRet != ERROR_SUCCESS) return hAnnotationToolPaletteKey; // go to classes key under SOFTWARE //lRet = RegOpenKeyEx(m_hSoftwareKey, "Classes", 0, KEY_ALL_ACCESS, &m_hClassesKey); //if (lRet != ERROR_SUCCESS) // return hAnnotationToolPaletteKey; lRet = RegOpenKeyEx(m_hSoftwareKey, "Wang", 0, KEY_ALL_ACCESS, &m_hClassesKey); if (lRet != ERROR_SUCCESS) { // create it dude! lRet = RegCreateKeyEx( m_hSoftwareKey, "Wang", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &m_hClassesKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return 0; } // go to WangImage.EditCtrl.1 key under Classes //lRet = RegOpenKeyEx(m_hClassesKey, "WangImage.EditCtrl.1", 0, KEY_ALL_ACCESS, &m_hImgEditKey); //if (lRet != ERROR_SUCCESS) // return hAnnotationToolPaletteKey; lRet = RegOpenKeyEx(m_hClassesKey, "WOI", 0, KEY_ALL_ACCESS, &m_hImgEditKey); if (lRet != ERROR_SUCCESS) { // create it dude! lRet = RegCreateKeyEx( m_hClassesKey, "WOI", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &m_hImgEditKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return 0; } // go to TOOL_PALETTE under WangImage.EditCtrl.1 key lRet = RegOpenKeyEx(m_hImgEditKey, "ANNOTATION_TOOL_PALETTE", 0, KEY_ALL_ACCESS, &hAnnotationToolPaletteKey); if (lRet == ERROR_SUCCESS) return hAnnotationToolPaletteKey; // Create ToolPalette section under WangImage.EditCtrl.1 lRet = RegCreateKeyEx(m_hImgEditKey, "ANNOTATION_TOOL_PALETTE", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAnnotationToolPaletteKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return 0; else return hAnnotationToolPaletteKey; } void CUpdateRegistry::CloseRegistry(HKEY hAnnotationToolPaletteKey) { RegCloseKey(hAnnotationToolPaletteKey); RegCloseKey(m_hImgEditKey); RegCloseKey(m_hClassesKey); RegCloseKey(m_hSoftwareKey); } BOOL CUpdateRegistry::SetColorScheme(HKEY hAnnotationToolPaletteKey, LPOI_UI_ColorStruct ColorScheme) { HKEY hToolKey; long lRet; char AttributeBuffer[300],ColorBuffer[10]; DWORD dwDisposition; int Red,Green,Blue,i; // find tool key, create it if it doesn't exist lRet = RegCreateKeyEx(hAnnotationToolPaletteKey, "COLOR_SCHEME", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; AttributeBuffer[0] = 0; for (i = 0; i < 16; i++) { Red = (int)ColorScheme->rgbCustomColor[i].rgbRed; Green = (int)ColorScheme->rgbCustomColor[i].rgbGreen; Blue = (int)ColorScheme->rgbCustomColor[i].rgbBlue; // convert Red color to string _itoa(Red, (char *)ColorBuffer, 10); // concatinate to other colors if (i != 0) _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)ColorBuffer); // convert Green color to string _itoa(Green, (char *)ColorBuffer, 10); // concatinate to other colors _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)ColorBuffer); // convert Blue color to string _itoa(Blue, (char *)ColorBuffer, 10); // concatinate to other colors _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)ColorBuffer); } // end for // write the stamp count value and current stamp lRet = RegSetValueEx(hToolKey, "COLOR_SCHEME", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } RegCloseKey(hToolKey); return TRUE; } BOOL CUpdateRegistry::GetColorScheme(HKEY hAnnotationToolPaletteKey, LPOI_UI_ColorStruct ColorScheme) { HKEY hToolKey; long lRet; char AttributeBuffer[300],ColorBuffer[300]; int i,j,Color,ColorIndex,RGBIndex; DWORD AttributeBufferCount,dwType; BOOL bResult; // find tool key lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, "COLOR_SCHEME", 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) { // couldn't find key, make default color scheme /* white */ ColorScheme->rgbCustomColor[0].rgbRed = 0xff; ColorScheme->rgbCustomColor[0].rgbGreen = 0xff; ColorScheme->rgbCustomColor[0].rgbBlue = 0xff; /* gray */ ColorScheme->rgbCustomColor[1].rgbRed = 0xc0; ColorScheme->rgbCustomColor[1].rgbGreen = 0xc0; ColorScheme->rgbCustomColor[1].rgbBlue = 0xc0; /* blue */ ColorScheme->rgbCustomColor[2].rgbRed = 0x00; ColorScheme->rgbCustomColor[2].rgbGreen = 0x00; ColorScheme->rgbCustomColor[2].rgbBlue = 0xff; /* light blue */ ColorScheme->rgbCustomColor[3].rgbRed = 0x00; ColorScheme->rgbCustomColor[3].rgbGreen = 0xff; ColorScheme->rgbCustomColor[3].rgbBlue = 0xff; /* green */ ColorScheme->rgbCustomColor[4].rgbRed = 0x00; ColorScheme->rgbCustomColor[4].rgbGreen = 0xff; ColorScheme->rgbCustomColor[4].rgbBlue = 0x00; /* yellow */ ColorScheme->rgbCustomColor[5].rgbRed = 0xff; ColorScheme->rgbCustomColor[5].rgbGreen = 0xff; ColorScheme->rgbCustomColor[5].rgbBlue = 0x00; /* red */ ColorScheme->rgbCustomColor[6].rgbRed = 0xff; ColorScheme->rgbCustomColor[6].rgbGreen = 0x00; ColorScheme->rgbCustomColor[6].rgbBlue = 0x00; /* pink */ ColorScheme->rgbCustomColor[7].rgbRed = 0xff; ColorScheme->rgbCustomColor[7].rgbGreen = 0x00; ColorScheme->rgbCustomColor[7].rgbBlue = 0xff; /* black */ ColorScheme->rgbCustomColor[8].rgbRed = 0x00; ColorScheme->rgbCustomColor[8].rgbGreen = 0x00; ColorScheme->rgbCustomColor[8].rgbBlue = 0x00; /* dark gray */ ColorScheme->rgbCustomColor[9].rgbRed = 0x80; ColorScheme->rgbCustomColor[9].rgbGreen = 0x80; ColorScheme->rgbCustomColor[9].rgbBlue = 0x80; /* dark blue */ ColorScheme->rgbCustomColor[10].rgbRed = 0x00; ColorScheme->rgbCustomColor[10].rgbGreen = 0x00; ColorScheme->rgbCustomColor[10].rgbBlue = 0x80; /* blue/green */ ColorScheme->rgbCustomColor[11].rgbRed = 0x00; ColorScheme->rgbCustomColor[11].rgbGreen = 0x80; ColorScheme->rgbCustomColor[11].rgbBlue = 0x80; /* dark green */ ColorScheme->rgbCustomColor[12].rgbRed = 0x00; ColorScheme->rgbCustomColor[12].rgbGreen = 0x80; ColorScheme->rgbCustomColor[12].rgbBlue = 0x00; /* yellow green */ ColorScheme->rgbCustomColor[13].rgbRed = 0x80; ColorScheme->rgbCustomColor[13].rgbGreen = 0x80; ColorScheme->rgbCustomColor[13].rgbBlue = 0x00; /* off red */ ColorScheme->rgbCustomColor[14].rgbRed = 0x80; ColorScheme->rgbCustomColor[14].rgbGreen = 0x00; ColorScheme->rgbCustomColor[14].rgbBlue = 0x00; /* purple */ ColorScheme->rgbCustomColor[15].rgbRed = 0x80; ColorScheme->rgbCustomColor[15].rgbGreen = 0x40; ColorScheme->rgbCustomColor[15].rgbBlue = 0x40; // write scheme to registry bResult = SetColorScheme(hAnnotationToolPaletteKey, ColorScheme); if (bResult == FALSE) return FALSE; return TRUE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hToolKey, "COLOR_SCHEME", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } i = 0; j = 0; ColorIndex = 0; RGBIndex = 0; // 0 - red, 1 - green, 2 - blue while (AttributeBuffer[i] != '\0') { if (AttributeBuffer[i] != ',') { ColorBuffer[j] = AttributeBuffer[i]; j++; } else { ColorBuffer[j] = '\0'; Color = atoi((const char *)ColorBuffer); if (RGBIndex == 0) { ColorScheme->rgbCustomColor[ColorIndex].rgbRed = (BYTE)Color; RGBIndex = 1; } else if (RGBIndex == 1) { ColorScheme->rgbCustomColor[ColorIndex].rgbGreen = (BYTE)Color; RGBIndex = 2; } else { ColorScheme->rgbCustomColor[ColorIndex].rgbBlue = (BYTE)Color; RGBIndex = 0; ColorIndex++; } j = 0; } i++; } // end while RegCloseKey(hToolKey); return TRUE; } BOOL CUpdateRegistry::GetLineColor(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, LPBYTE RedColor, LPBYTE GreenColor, LPBYTE BlueColor) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD AttributeBufferCount,dwType; BOOL bResult; // find tool key lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) return FALSE; // find line color key lRet = RegOpenKeyEx(hToolKey, "LINE_COLOR", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hAttributeKey, "LINE_COLOR", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } bResult = GetColorValue(AttributeBuffer, RedColor, GreenColor, BlueColor); if (bResult == FALSE) { // key doesn't exist yet, set line color default *RedColor = 0; *GreenColor = 0; *BlueColor = 255; } // close opened keys RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return TRUE; } BOOL CUpdateRegistry::SetLineColor(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, BYTE RedColor, BYTE GreenColor, BYTE BlueColor) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; int len; DWORD dwDisposition; // find tool key, create it if it doesn't exist lRet = RegCreateKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; // find line color key, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "LINE_COLOR", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write the line color key _itoa(RedColor, (char *)AttributeBuffer, 10); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); len = _mbstrlen((const char *)AttributeBuffer); _itoa(GreenColor, (char *)AttributeBuffer+len, 10); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); len = _mbstrlen((const char *)AttributeBuffer); _itoa(BlueColor,(char *)AttributeBuffer+len, 10); lRet = RegSetValueEx(hAttributeKey, "LINE_COLOR", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return FALSE; } RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return TRUE; } BOOL CUpdateRegistry::GetFillColor(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, LPBYTE RedColor, LPBYTE GreenColor, LPBYTE BlueColor) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD AttributeBufferCount,dwType; BOOL bResult; // find tool key lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) return FALSE; // find line color key lRet = RegOpenKeyEx(hToolKey, "FILL_COLOR", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hAttributeKey, "FILL_COLOR", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } bResult = GetColorValue(AttributeBuffer, RedColor, GreenColor, BlueColor); if (bResult == FALSE) { // key doesn't exist yet, set line color default *RedColor = 0; *GreenColor = 0; *BlueColor = 255; } // close opened keys RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return TRUE; } BOOL CUpdateRegistry::SetFillColor(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, BYTE RedColor, BYTE GreenColor, BYTE BlueColor) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD dwDisposition; int len; // find tool key, create it if it doesn't exist lRet = RegCreateKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; // find fill color key, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "FILL_COLOR", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write the fill color key _itoa(RedColor, (char *)AttributeBuffer, 10); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); len = _mbstrlen((const char *)AttributeBuffer); _itoa(GreenColor, (char *)AttributeBuffer+len, 10); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); len = _mbstrlen((const char *)AttributeBuffer); _itoa(BlueColor,(char *)AttributeBuffer+len, 10); lRet = RegSetValueEx(hAttributeKey, "FILL_COLOR", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return FALSE; } RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return TRUE; } BOOL CUpdateRegistry::GetFontColor(HKEY hKey, LPCTSTR ToolStringKey, LPBYTE RedColor, LPBYTE GreenColor, LPBYTE BlueColor) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD AttributeBufferCount,dwType; BOOL bResult; // find tool key lRet = RegOpenKeyEx(hKey, ToolStringKey, 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) return FALSE; // find font color key lRet = RegOpenKeyEx(hToolKey, "FONT_COLOR", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hAttributeKey, "FONT_COLOR", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } bResult = GetColorValue(AttributeBuffer, RedColor, GreenColor, BlueColor); if (bResult == FALSE) { // key doesn't exist yet, set line color default *RedColor = 0; *GreenColor = 0; *BlueColor = 0; } // close opened keys RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return TRUE; } BOOL CUpdateRegistry::SetFontColor(HKEY hKey, LPCTSTR ToolStringKey, BYTE RedColor, BYTE GreenColor, BYTE BlueColor) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD dwDisposition; int len; // find tool key, create it if it doesn't exist lRet = RegCreateKeyEx(hKey, ToolStringKey, 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; // find font color key, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "FONT_COLOR", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write the font color key _itoa(RedColor, (char *)AttributeBuffer, 10); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); len = _mbstrlen((const char *)AttributeBuffer); _itoa(GreenColor, (char *)AttributeBuffer+len, 10); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); len = _mbstrlen((const char *)AttributeBuffer); _itoa(BlueColor,(char *)AttributeBuffer+len, 10); lRet = RegSetValueEx(hAttributeKey, "FONT_COLOR", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return FALSE; } RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return TRUE; } BOOL CUpdateRegistry::GetBackColor(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, LPBYTE RedColor, LPBYTE GreenColor, LPBYTE BlueColor) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD AttributeBufferCount,dwType; BOOL bResult; // find tool key lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) return FALSE; // find line color key lRet = RegOpenKeyEx(hToolKey, "BACKCOLOR", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hAttributeKey, "BACKCOLOR", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } bResult = GetColorValue(AttributeBuffer, RedColor, GreenColor, BlueColor); if (bResult == FALSE) { // key doesn't exist yet, set line color default *RedColor = 0; *GreenColor = 255; *BlueColor = 255; } // close opened keys RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return TRUE; } BOOL CUpdateRegistry::SetBackColor(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, BYTE RedColor, BYTE GreenColor, BYTE BlueColor) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD dwDisposition; int len; // find tool key, create it if it doesn't exist lRet = RegCreateKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; // find backcolor key, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "BACKCOLOR", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write the backcolor key _itoa(RedColor, (char *)AttributeBuffer, 10); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); len = _mbstrlen((const char *)AttributeBuffer); _itoa(GreenColor, (char *)AttributeBuffer+len, 10); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); len = _mbstrlen((const char *)AttributeBuffer); _itoa(BlueColor,(char *)AttributeBuffer+len, 10); lRet = RegSetValueEx(hAttributeKey, "BACKCOLOR", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return FALSE; } RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return TRUE; } BOOL CUpdateRegistry::GetStyle(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, LPUINT Style) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[10]; DWORD AttributeBufferCount,dwType; // find tool key lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) return FALSE; // find style key lRet = RegOpenKeyEx(hToolKey, "STYLE", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found key, get value AttributeBufferCount = 5; lRet = RegQueryValueEx(hAttributeKey, "STYLE", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } *Style = atoi((const char *)AttributeBuffer); // close opened keys RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return TRUE; } BOOL CUpdateRegistry::SetStyle(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, UINT Style) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[10]; DWORD dwDisposition; // find tool key, create it if it doesn't exist lRet = RegCreateKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; // find style, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "STYLE", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write the style key _itoa(Style, (char *)AttributeBuffer, 10); lRet = RegSetValueEx(hAttributeKey, "STYLE", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return FALSE; } RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return TRUE; } BOOL CUpdateRegistry::GetFontAttributes(HKEY hKey, LPCTSTR ToolStringKey, LPCTSTR FontName, LPINT FontSize, LPBOOL FontBold, LPBOOL FontItalic, LPBOOL FontStrikeThru, LPBOOL FontUnderline,LPBYTE FontCharSet) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD AttributeBufferCount,dwType; int len; // find tool key lRet = RegOpenKeyEx(hKey, ToolStringKey, 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) return FALSE; // find font name lRet = RegOpenKeyEx(hToolKey, "FONT_NAME", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hAttributeKey, "FONT_NAME", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } _mbscpy((unsigned char *)FontName, (const unsigned char *)AttributeBuffer); RegCloseKey(hAttributeKey); // get font size lRet = RegOpenKeyEx(hToolKey, "FONT_SIZE", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hAttributeKey, "FONT_SIZE", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } *FontSize = atoi((const char *)AttributeBuffer); RegCloseKey(hAttributeKey); // get font char set lRet = RegOpenKeyEx(hToolKey, "FONT_CHARSET", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hAttributeKey, "FONT_CHARSET", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } *FontCharSet = (BYTE)atoi((const char *)AttributeBuffer); RegCloseKey(hAttributeKey); // get font bold, italic, strikethru and underline lRet = RegOpenKeyEx(hToolKey, "FONT_CHARACTERISTICS", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hAttributeKey, "FONT_CHARACTERISTICS", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } len = _mbstrlen((const char *)AttributeBuffer); // this string is in the format "w,x,y,z" where w is bold, x is italic, // y is strikethru and z is underline if (len == 7) { if (AttributeBuffer[0] == '1') *FontBold = TRUE; else *FontBold = FALSE; if (AttributeBuffer[2] == '1') *FontItalic = TRUE; else *FontItalic = FALSE; if (AttributeBuffer[4] == '1') *FontStrikeThru = TRUE; else *FontStrikeThru = FALSE; if (AttributeBuffer[6] == '1') *FontUnderline = TRUE; else *FontUnderline = FALSE; } else { // use default characteristics *FontBold = FALSE; *FontItalic = FALSE; *FontStrikeThru = FALSE; *FontUnderline = TRUE; *FontCharSet = 1; } // close opened keys RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return TRUE; } BOOL CUpdateRegistry::SetFontAttributes(HKEY hKey, LPCTSTR ToolStringKey, LPCTSTR FontName, INT FontSize, BOOL FontBold, BOOL FontItalic, BOOL FontStrikeThru, BOOL FontUnderline,BYTE FontCharSet) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD dwDisposition; // find tool key, create it if it doesn't exist lRet = RegCreateKeyEx(hKey, ToolStringKey, 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; // find font name, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "FONT_NAME", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write out font name _mbscpy((unsigned char *)AttributeBuffer, (const unsigned char *)FontName); lRet = RegSetValueEx(hAttributeKey, "FONT_NAME", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } RegCloseKey(hAttributeKey); // get font size key, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "FONT_SIZE", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write out font size _itoa(FontSize, (char *)AttributeBuffer, 10); lRet = RegSetValueEx(hAttributeKey, "FONT_SIZE", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } RegCloseKey(hAttributeKey); // get font char set, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "FONT_CHARSET", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write out font char set _itoa(FontCharSet, (char *)AttributeBuffer, 10); lRet = RegSetValueEx(hAttributeKey, "FONT_CHARSET", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } RegCloseKey(hAttributeKey); // get font characteristic key, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "FONT_CHARACTERISTICS", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write the bold,italic,strikethru and underline attribute 0 = False, 1 = True if (FontBold == TRUE) AttributeBuffer[0] = '1'; else AttributeBuffer[0] = '0'; AttributeBuffer[1] = ','; if (FontItalic == TRUE) AttributeBuffer[2] = '1'; else AttributeBuffer[2] = '0'; AttributeBuffer[3] = ','; if (FontStrikeThru == TRUE) AttributeBuffer[4] = '1'; else AttributeBuffer[4] = '0'; AttributeBuffer[5] = ','; if (FontUnderline == TRUE) AttributeBuffer[6] = '1'; else AttributeBuffer[6] = '0'; AttributeBuffer[7] = '\0'; // write out font characteristics lRet = RegSetValueEx(hAttributeKey, "FONT_CHARACTERISTICS", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return TRUE; } BOOL CUpdateRegistry::SetLineWidth(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, INT LineWidth) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD dwDisposition; // find tool key, create it if it doesn't exist lRet = RegCreateKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; // find line width key, create it if it doesn't exist lRet = RegCreateKeyEx(hToolKey, "LINE_WIDTH", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hAttributeKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // write the line width value _itoa(LineWidth, (char *)AttributeBuffer, 10); lRet = RegSetValueEx(hAttributeKey, "LINE_WIDTH", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return FALSE; } RegCloseKey(hAttributeKey); RegCloseKey(hToolKey); return TRUE; } BOOL CUpdateRegistry::GetLineWidth(HKEY hAnnotationToolPaletteKey, LPCTSTR ToolStringKey, LPINT LineWidth) { HKEY hToolKey,hAttributeKey; long lRet; char AttributeBuffer[300]; DWORD AttributeBufferCount,dwType; // find tool key lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, ToolStringKey, 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) return FALSE; // find line width key lRet = RegOpenKeyEx(hToolKey, "LINE_WIDTH", 0, KEY_ALL_ACCESS, &hAttributeKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // found line width, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hAttributeKey, "LINE_WIDTH", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return FALSE; } // close opened keys *LineWidth = atoi((const char *)AttributeBuffer); RegCloseKey(hToolKey); RegCloseKey(hAttributeKey); return TRUE; } BOOL CUpdateRegistry::GetStampCount(HKEY hAnnotationToolPaletteKey, LPINT StampCount, LPCTSTR szCurrentStamp) { HKEY hToolKey; long lRet; char AttributeBuffer[300],StampCountBuffer[10]; DWORD AttributeBufferCount,dwType; int i; // found tool palette key, now find tool key lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, "RUBBER_STAMP_TOOL", 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) return FALSE; // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hToolKey, "RUBBER_STAMP_TOOL", 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } RegCloseKey(hToolKey); // get stamp count for (i = 0; AttributeBuffer[i] != '\0'; i++) { if (AttributeBuffer[i] != ',') StampCountBuffer[i] = AttributeBuffer[i]; else { StampCountBuffer[i] = '\0'; break; } } *StampCount = atoi((const char *)AttributeBuffer); // get current stamp _mbscpy((unsigned char *)szCurrentStamp, (const unsigned char *)AttributeBuffer + i + 1); return TRUE; } BOOL CUpdateRegistry::SetStampCount(HKEY hAnnotationToolPaletteKey, INT StampCount, LPCTSTR szCurrentStamp) { HKEY hToolKey; long lRet; char AttributeBuffer[300]; DWORD dwDisposition; // find tool key, create it if it doesn't exist lRet = RegCreateKeyEx(hAnnotationToolPaletteKey, "RUBBER_STAMP_TOOL", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; // convert number to string _itoa(StampCount, (char *)AttributeBuffer, 10); // concatinate current stamp _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)szCurrentStamp); // write the stamp count value and current stamp lRet = RegSetValueEx(hToolKey, "RUBBER_STAMP_TOOL", 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } RegCloseKey(hToolKey); return TRUE; } BOOL CUpdateRegistry::GetStampInfo(HKEY hAnnotationToolPaletteKey, INT StampIndex, LPCTSTR RefName, LPCTSTR AttributeString, LPINT StampType) { HKEY hToolKey,hStampKey,hStampInfoKey; long lRet; char AttributeBuffer[300],StampCountString[50],Buffer[256]; DWORD AttributeBufferCount,dwType; int j,Count,len,ByteCount; unsigned char *lpTemp1,*lpTemp2; // find rubber stamp key lRet = RegOpenKeyEx(hAnnotationToolPaletteKey, "RUBBER_STAMP_TOOL", 0, KEY_ALL_ACCESS, &hToolKey); if (lRet != ERROR_SUCCESS) return FALSE; // find each stamp key _mbscpy((unsigned char *)StampCountString, (const unsigned char *)"STAMP_"); _itoa(StampIndex, StampCountString+6, 10); lRet = RegOpenKeyEx(hToolKey, StampCountString, 0, KEY_ALL_ACCESS, &hStampKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // find stamp info key _mbscpy((unsigned char *)StampCountString, (const unsigned char *)"STAMP_INFO"); lRet = RegOpenKeyEx(hStampKey, StampCountString, 0, KEY_ALL_ACCESS, &hStampInfoKey); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hStampKey); return FALSE; } // found key, get value AttributeBufferCount = 300; lRet = RegQueryValueEx(hStampInfoKey, StampCountString, 0, (LPDWORD)&dwType, (LPBYTE)AttributeBuffer, (LPDWORD)&AttributeBufferCount); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hStampKey); RegCloseKey(hStampInfoKey); return FALSE; } // parse out ref_name len = _mbstrlen((const char *)AttributeBuffer); for (j = 0, Count = 0; j < len; j++) { if (AttributeBuffer[j] == ',') Count++; } // end for if (Count != 2) { // registry messed up RegCloseKey(hToolKey); RegCloseKey(hStampKey); RegCloseKey(hStampInfoKey); return FALSE; } // get ref_name lpTemp1 = _mbschr((const unsigned char *)AttributeBuffer, (unsigned int)','); ByteCount = lpTemp1 - (unsigned char *)AttributeBuffer; for (j = 0 ; j < ByteCount; j++) Buffer[j] = AttributeBuffer[j]; Buffer[j] = '\0'; _mbscpy((unsigned char *)RefName, (const unsigned char *)Buffer); lpTemp1++; // point to character after comma lpTemp2 = _mbschr((const unsigned char *)lpTemp1, (unsigned int)','); ByteCount = lpTemp2 - lpTemp1; // get attribute string for (j = 0 ; j < ByteCount; j++) Buffer[j] = lpTemp1[j]; Buffer[j] = '\0'; _mbscpy((unsigned char *)AttributeString, (const unsigned char *)Buffer); // get attribute type *StampType = atoi((const char *)lpTemp2+1); RegCloseKey(hToolKey); RegCloseKey(hStampKey); RegCloseKey(hStampInfoKey); return TRUE; } BOOL CUpdateRegistry::SetStampInfo(HKEY hAnnotationToolPaletteKey, INT StampIndex, LPCTSTR RefName, LPCTSTR AttributeString, INT StampType) { HKEY hToolKey,hStampKey,hStampInfoKey; long lRet; char AttributeBuffer[300],StampCountString[50],StampTypeBuffer[20]; DWORD dwDisposition; // find rubber stamp key, create it if it doesn't exist lRet = RegCreateKeyEx(hAnnotationToolPaletteKey, "RUBBER_STAMP_TOOL", 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hToolKey, &dwDisposition); if (lRet != ERROR_SUCCESS) return FALSE; // find stamp key, create it if it doesn't exist _mbscpy((unsigned char *)StampCountString, (const unsigned char *)"STAMP_"); _itoa(StampIndex, StampCountString+6, 10); lRet = RegCreateKeyEx(hToolKey, StampCountString, 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hStampKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); return FALSE; } // find stamp key, create it if it doesn't exist _mbscpy((unsigned char *)StampCountString, (const unsigned char *)"STAMP_INFO"); lRet = RegCreateKeyEx(hStampKey, StampCountString, 0, "REG_SZ", REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hStampInfoKey, &dwDisposition); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hStampKey); return FALSE; } // copy individual strings to one string _mbscpy((unsigned char *)AttributeBuffer, (const unsigned char *)RefName); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)AttributeString); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)","); // put attribute type into a string _itoa(StampType, (char *)StampTypeBuffer, 10); _mbscat((unsigned char *)AttributeBuffer, (const unsigned char *)StampTypeBuffer); // write out stamp info lRet = RegSetValueEx(hStampInfoKey, StampCountString, 0, REG_SZ, (CONST BYTE *)AttributeBuffer, _mbstrlen((const char *)AttributeBuffer)+1); if (lRet != ERROR_SUCCESS) { RegCloseKey(hToolKey); RegCloseKey(hStampKey); RegCloseKey(hStampInfoKey); return FALSE; } RegCloseKey(hToolKey); RegCloseKey(hStampKey); RegCloseKey(hStampInfoKey); return TRUE; } ///////////////////////////////////////////////////////////////////////////// // CPaletteBar CPaletteBar::CPaletteBar() : m_pTBButtons(NULL) { m_bRightButton = FALSE; m_bStampPressed = FALSE; } CPaletteBar::~CPaletteBar() { if (m_pTBButtons) delete []m_pTBButtons; } BEGIN_MESSAGE_MAP(CPaletteBar, CToolBarCtrl) //{{AFX_MSG_MAP(CPaletteBar) ON_WM_RBUTTONDOWN() ON_WM_RBUTTONUP() ON_WM_MOUSEMOVE() ON_WM_LBUTTONDOWN() ON_WM_LBUTTONUP() ON_NOTIFY_RANGE( TTN_NEEDTEXTA, ID_ANNOTATION_SELECTION, ID_RUBBER_STAMP, OnNeedTextA) ON_NOTIFY_RANGE( TTN_NEEDTEXTW, ID_ANNOTATION_SELECTION, ID_RUBBER_STAMP, OnNeedTextW) //}}AFX_MSG_MAP END_MESSAGE_MAP() BOOL CPaletteBar::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, BOOL bShowAttrDialog ) { BOOL bRet = CToolBarCtrl::Create(dwStyle, rect, pParentWnd, nID); m_bShowAttrDialog = bShowAttrDialog; m_nButtonCount = ID_RUBBER_STAMP - ID_ANNOTATION_SELECTION + 1; VERIFY(AddBitmap(m_nButtonCount,IDB_TOOLPAL) != -1); m_pTBButtons = new TBBUTTON[m_nButtonCount]; for (int nIndex = 0; nIndex < m_nButtonCount; nIndex++) { m_pTBButtons[nIndex].fsState = TBSTATE_ENABLED; m_pTBButtons[nIndex].fsStyle = TBSTYLE_CHECKGROUP; m_pTBButtons[nIndex].dwData = 0; m_pTBButtons[nIndex].iBitmap = nIndex; m_pTBButtons[nIndex].idCommand = nIndex + ID_ANNOTATION_SELECTION; // my code - don't need string m_pTBButtons[nIndex].iString = NULL; } for (nIndex = 0; nIndex < m_nButtonCount; nIndex++) { VERIFY(AddButtons(1,&m_pTBButtons[nIndex])); } // my code CRect newrect; SetRows(6, TRUE, &newrect); return bRet; } // Helper function for tooltips /*************************** * Function: MakeUnicodeString * * Description: Creates a UNICODE version of the ANSI input string. * The caller should also call FreeUinicodeString() to * free the UNICODE string after using it. * * Explicit Parameters: AnsiInString - the ANSI input string * lpUniOutString - pointer to UNICODE output string * pLength - pointer to the UNICODE byte length (output) * * Implicit Parameters: None. * * Side Effects: Allocates memory that must later be freed by the caller * (using FreeUnicodeString). * * Return Value: 1 - couldn't alloc memory for UNICODE string * S_OK - success * plus any failure from MultiByteToWideChar * ***************************/ int MakeUnicodeString(LPTSTR AnsiInString, LPOLESTR *lpUniOutString, int * pLength) { int iResult = S_OK; UINT InputStrLen; if(AnsiInString == NULL) { *lpUniOutString = NULL; } else { InputStrLen = lstrlen(AnsiInString)+1; *pLength = InputStrLen*2; //*lpUniOutString = (LPOLESTR)GlobalAlloc(GPTR, (InputStrLen*2)); *lpUniOutString = (LPOLESTR)GlobalAlloc(GPTR, *pLength); if(*lpUniOutString == NULL) { iResult = 1; } else { if(MultiByteToWideChar(CP_ACP, 0, AnsiInString, InputStrLen, (LPWSTR)*lpUniOutString, InputStrLen) == 0 ) { iResult = GetLastError(); } } } return(iResult); } /*************************** * Function: FreeUnicodeString * * Description: Frees a UNICODE string created by MakeUnicodeString. * * Explicit Parameters: lpUniOutString - pointer to the UNICODE string * * Implicit Parameters: None. * * Side Effects: NULLs the string pointer. * * Return Value: None. ***************************/ void FreeUnicodeString(LPOLESTR *lpUniOutString) { if(*lpUniOutString != NULL) { GlobalFree(*lpUniOutString); *lpUniOutString = NULL; } } //*************************************************************************** // // NeedText // //*************************************************************************** CString CPaletteBar::NeedText( UINT nID, NMHDR * pNotifyStruct, LRESULT * lResult ) { CMiniToolBox *pMiniToolBox; CString strToolTipText; LPTOOLTIPTEXT lpTTT = (LPTOOLTIPTEXT)pNotifyStruct; ASSERT(nID == lpTTT->hdr.idFrom); pMiniToolBox = (CMiniToolBox*)GetParent(); strToolTipText = pMiniToolBox->GetToolTip(nID); // szText length is 80 int nLength = (strToolTipText.GetLength() > 79) ? 79 : strToolTipText.GetLength(); strToolTipText = strToolTipText.Left(nLength); return strToolTipText; } //*************************************************************************** // // OnNeedTextW // //*************************************************************************** void CPaletteBar::OnNeedTextW( UINT nID, NMHDR * pNotifyStruct, LRESULT * lResult ) { CMiniToolBox *pMiniToolBox; CString toolTipText = NeedText(nID, pNotifyStruct, lResult); // 9602.29 jar needed for nt int Length = 0; LPOLESTR lpOleString; // LPTOOLTIPTEXTW lpTTT = (LPTOOLTIPTEXTW)pNotifyStruct; LPTOOLTIPTEXTA lpTTT = (LPTOOLTIPTEXTA)pNotifyStruct; // 9602.29 jar unicode THIS! // make this SUCKA unicode MakeUnicodeString( toolTipText.GetBuffer(80), &lpOleString, &Length); toolTipText.ReleaseBuffer(); memcpy( lpTTT->szText, (char *)lpOleString, Length); pMiniToolBox = (CMiniToolBox*)GetParent(); CWnd* pImageWnd = pMiniToolBox->GetImageWnd(); // 9603.11 jar changed to post since the send seems to crash on NT //pImageWnd->SendMessage(TOOLTIP_EVENT, nID + 1, 0L); pImageWnd->PostMessage(TOOLTIP_EVENT, nID + 1, 0L); // 9602.29 jar needed for nt FreeUnicodeString( &lpOleString); } void CPaletteBar::OnNeedTextA( UINT nID, NMHDR * pNotifyStruct, LRESULT * lResult ) { CMiniToolBox *pMiniToolBox; CString toolTipText = NeedText(nID, pNotifyStruct, lResult); LPTOOLTIPTEXT lpTTT = (LPTOOLTIPTEXT)pNotifyStruct; _tcscpy(lpTTT->szText,(LPCTSTR)toolTipText); pMiniToolBox = (CMiniToolBox*)GetParent(); CWnd* pImageWnd = pMiniToolBox->GetImageWnd(); pImageWnd->SendMessage(TOOLTIP_EVENT, nID + 1, 0L); } /////////////////////////////////////////////////////////////////////// // This has been overridden so we can handle the tooltip TTN_NEEDTEXT// // notification message // /////////////////////////////////////////////////////////////////////// BOOL CPaletteBar::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult) { ASSERT(pResult != NULL); NMHDR* pNMHDR = (NMHDR*)lParam; HWND hWndCtrl = pNMHDR->hwndFrom; // get the child ID from the window itself // UINT nID = _AfxGetDlgCtrlID(hWndCtrl); ////////////////////////////////////////////////////////////////// // If TTN_NEEDTEXT we cannot get the ID from the tooltip window // ////////////////////////////////////////////////////////////////// int nCode = pNMHDR->code; // // if it is the following notification message // nID has to obtained from wParam // if (nCode == TTN_NEEDTEXTA || nCode == TTN_NEEDTEXTW) { UINT nID; // = _AfxGetDlgCtrlID(hWndCtrl); nID = (UINT)wParam; ASSERT((UINT)pNMHDR->idFrom == (UINT)wParam); UNUSED(wParam); // not used in release build ASSERT(hWndCtrl != NULL); ASSERT(::IsWindow(hWndCtrl)); if (AfxGetThreadState()->m_hLockoutNotifyWindow == m_hWnd) return TRUE; // locked out - ignore control notification // reflect notification to child window control if (ReflectLastMsg(hWndCtrl, pResult)) return TRUE; // eaten by child AFX_NOTIFY notify; notify.pResult = pResult; notify.pNMHDR = pNMHDR; return OnCmdMsg(nID, MAKELONG(nCode, WM_NOTIFY), ¬ify, NULL); } return CToolBarCtrl::OnNotify(wParam, lParam, pResult); } void CPaletteBar::OnRButtonDown(UINT nFlags, CPoint point) { RECT ButtonRect; int index; // don't show attributes dialogs if user didn't ask for it if (m_bShowAttrDialog == FALSE) { CToolBarCtrl::OnRButtonDown(nFlags, point); return; } SetCapture(); // find which button was pressed for (index = 0, m_nButtonIndex = -1; index < m_nButtonCount; index++) { GetItemRect(index, &ButtonRect); if ((point.x >= ButtonRect.left) && (point.x <= ButtonRect.right) && (point.y >= ButtonRect.top) && (point.y <= ButtonRect.bottom)) { m_nButtonIndex = index; break; } } // end for // no button pressed, don't do anything if (m_nButtonIndex == -1) { CToolBarCtrl::OnRButtonDown(nFlags, point); return; } // press the button PressButton(m_nButtonIndex, TRUE); // set flag that button has been pressed m_bRightButton = TRUE; CToolBarCtrl::OnRButtonDown(nFlags, point); } void CPaletteBar::OnRButtonUp(UINT nFlags, CPoint point) { RECT ButtonRect; int ButtonIndex,index; BOOL bButtonPressed; POINT CurrentCursorPos; CMenu *ToolPalettePopupMenu; BOOL bResult; UINT uMenuItemId; CString strProperties; CMiniToolBox *pMiniToolBox; ReleaseCapture(); m_bRightButton = FALSE; // user not over any button, don't do anything if (m_nButtonIndex == -1) { CToolBarCtrl::OnRButtonUp(nFlags, point); return; } // see which button user is over for (index = 0, ButtonIndex = -1; index < m_nButtonCount; index++) { GetItemRect(index, &ButtonRect); if ((point.x >= ButtonRect.left) && (point.x <= ButtonRect.right) && (point.y >= ButtonRect.top) && (point.y <= ButtonRect.bottom)) { ButtonIndex = index; break; } } // end for // if user over same button as rbutton down then check button bButtonPressed = FALSE; if (ButtonIndex != -1) { bButtonPressed = IsButtonPressed(ButtonIndex); if (bButtonPressed) { // check button, user still over same button CheckButton(ButtonIndex, TRUE); // remove pressed state PressButton(ButtonIndex, FALSE); // uncheck all other buttons for (index = 0; index < m_nButtonCount; index++) { if (ButtonIndex != index) CheckButton(index, FALSE); } // end for } } if (bButtonPressed == FALSE) { // remove pressed button if any for (index = 0; index < m_nButtonCount; index++) { bButtonPressed = IsButtonPressed(index); if (bButtonPressed) PressButton(index, FALSE); } // end for } else { switch(ButtonIndex) { case ID_FREEHAND_LINE: uMenuItemId = IDM_FREEHAND_LINE; break; case ID_HIGHLIGHTING_LINE: uMenuItemId = IDM_HIGHLIGHTING_LINE; break; case ID_STRAIGHT_LINE: uMenuItemId = IDM_STRAIGHT_LINE; break; case ID_HOLLOW_RECT: uMenuItemId = IDM_HOLLOW_RECT; break; case ID_FILLED_RECT: uMenuItemId = IDM_FILLED_RECT; break; case ID_TEXT: uMenuItemId = IDM_TEXT; break; case ID_TEXT_ATTACHMENT: uMenuItemId = IDM_TEXT_ATTACHMENT; break; case ID_TEXT_FROM_FILE: uMenuItemId = IDM_TEXT_FROM_FILE; break; case ID_RUBBER_STAMP: uMenuItemId = IDM_RUBBER_STAMP; break; case ID_ANNOTATION_SELECTION: default: CToolBarCtrl::OnRButtonUp(nFlags, point); return; } // end switch // select the tool or stamp incase user does not press the popup menu pMiniToolBox = (CMiniToolBox*)GetParent(); if (ButtonIndex == ID_RUBBER_STAMP) { if (pMiniToolBox->m_pRubberStampStruct->m_nStampCount > 0) pMiniToolBox->SelectStamp((UINT)pMiniToolBox->m_pRubberStampStruct->m_uCurrentStampIndex, FALSE); } else pMiniToolBox->SendMessage(WM_COMMAND, (WPARAM)ButtonIndex, 0L); // create popup memu ToolPalettePopupMenu = new CMenu; bResult = ToolPalettePopupMenu->CreatePopupMenu(); if (bResult == TRUE) { // popup menu created, add menu items to it strProperties.LoadString(IDS_TOOLPALETTE_PROPERTIES); bResult = ToolPalettePopupMenu->AppendMenu(MF_ENABLED | MF_STRING, uMenuItemId, strProperties); // get current cursor position in screen coordinates GetCursorPos(&CurrentCursorPos); // track popup menu bResult = ToolPalettePopupMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, CurrentCursorPos.x, CurrentCursorPos.y, this, NULL); } delete ToolPalettePopupMenu; } CToolBarCtrl::OnRButtonUp(nFlags, point); } void CPaletteBar::OnMouseMove(UINT nFlags, CPoint point) { RECT ButtonRect; int index; BOOL bButtonPressed; // if right mouse down has occured then see if mouse position still over same button. if (m_bRightButton == TRUE) { // see which button user is over for (index = 0; index < m_nButtonCount; index++) { GetItemRect(index, &ButtonRect); if ((point.x >= ButtonRect.left) && (point.x <= ButtonRect.right) && (point.y >= ButtonRect.top) && (point.y <= ButtonRect.bottom)) { // over some button, see if the same as when button was down if (m_nButtonIndex == index) { // over same button, if pressed already don't do anything bButtonPressed = IsButtonPressed(index); if (bButtonPressed == FALSE) PressButton(index, TRUE); // press again break; } else { // no longer over same button, make it not presses PressButton(m_nButtonIndex, FALSE); break; } } } // end for } CToolBarCtrl::OnMouseMove(nFlags, point); } LRESULT CPaletteBar::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) { CMiniToolBox *pMiniToolBox; switch(message) { case WM_COMMAND: switch(wParam) { case IDM_STAMP1: case IDM_STAMP2: case IDM_STAMP3: case IDM_STAMP4: case IDM_STAMP5: case IDM_STAMP6: case IDM_STAMP7: case IDM_STAMP8: case IDM_STAMP9: case IDM_STAMP10: case IDM_STAMP11: case IDM_STAMP12: case IDM_STAMP13: case IDM_STAMP14: case IDM_STAMP15: case IDM_STAMP16: case IDM_STAMP17: case IDM_STAMP18: case IDM_STAMP19: case IDM_STAMP20: case IDM_STAMP21: case IDM_STAMP22: case IDM_STAMP23: case IDM_STAMP24: case IDM_STAMP25: case IDM_STAMP26: case IDM_STAMP27: case IDM_STAMP28: case IDM_STAMP29: case IDM_STAMP30: case IDM_STAMP31: case IDM_STAMP32: // select this stamp pMiniToolBox = (CMiniToolBox*)GetParent(); pMiniToolBox->SelectStamp((UINT)(wParam - RUBBER_STAMP_BASE), TRUE); break; case IDM_FREEHAND_LINE: case IDM_HIGHLIGHTING_LINE: case IDM_STRAIGHT_LINE: case IDM_FILLED_RECT: case IDM_HOLLOW_RECT: case IDM_TEXT: case IDM_TEXT_ATTACHMENT: case IDM_TEXT_FROM_FILE: case IDM_RUBBER_STAMP: pMiniToolBox = (CMiniToolBox*)GetParent(); pMiniToolBox->ShowAttribsDialog((UINT)(wParam - TOOL_BASE)); break; } // end switch WM_COMMAND msg } // end switch return CToolBarCtrl::WindowProc(message, wParam, lParam); } void CPaletteBar::OnLButtonDown(UINT nFlags, CPoint point) { RECT ButtonRect; int index,ButtonIndex; SetCapture(); // find which button was pressed for (index = 0, ButtonIndex = -1; index < m_nButtonCount; index++) { GetItemRect(index, &ButtonRect); if ((point.x >= ButtonRect.left) && (point.x <= ButtonRect.right) && (point.y >= ButtonRect.top) && (point.y <= ButtonRect.bottom)) { ButtonIndex = index; break; } } // end for // no button pressed, don't do anything if (ButtonIndex == ID_RUBBER_STAMP) // set flag that stamp button has been pressed m_bStampPressed = TRUE; else m_bStampPressed = FALSE; CToolBarCtrl::OnLButtonDown(nFlags, point); } void CPaletteBar::OnLButtonUp(UINT nFlags, CPoint point) { RECT ButtonRect; int index,ButtonIndex,StampIndex,i,StampCount; POINT CurrentCursorPos; BOOL bResult,bFontBold,bFontItalic,bFontStrikeThru,bFontUnderline; char RefName[MAXREFNAME_SIZE],AttributeString[300],FontName[LF_FACESIZE]; BYTE FontColorRed, FontColorGreen, FontColorBlue, FontCharSet; UINT uMenuItemId,StampType,uFontSize; CMenu *RubberStampPopupMenu; CMiniToolBox *pMiniToolBox; ReleaseCapture(); // if on left mouse down user not over rubber stamp then don't do anything if (m_bStampPressed == FALSE) { CToolBarCtrl::OnLButtonUp(nFlags, point); return; } // make sure user is still over rubber stamp for (index = 0, ButtonIndex = -1; index < m_nButtonCount; index++) { GetItemRect(index, &ButtonRect); if ((point.x >= ButtonRect.left) && (point.x <= ButtonRect.right) && (point.y >= ButtonRect.top) && (point.y <= ButtonRect.bottom)) { ButtonIndex = index; break; } } // end for // no button pressed, don't do anything if (ButtonIndex != ID_RUBBER_STAMP) { CToolBarCtrl::OnLButtonUp(nFlags, point); return; } m_bStampPressed = FALSE; // create the popup menu RubberStampPopupMenu = new CMenu; RubberStampPopupMenu->CreatePopupMenu(); // get pointer to parent class pMiniToolBox = (CMiniToolBox *) GetParent(); StampIndex = 0; // shouldn't have to do this but just in case default to first one StampCount = pMiniToolBox->m_pRubberStampStruct->m_nStampCount; if (StampCount > 0) { for (i = 0; i < StampCount; i++) { bResult = pMiniToolBox->m_pRubberStampStruct->GetStampAttributes(i, RefName, AttributeString, &StampType, &FontColorRed, &FontColorGreen, &FontColorBlue, FontName, &uFontSize, &bFontBold, &bFontItalic, &bFontStrikeThru, &bFontUnderline, &FontCharSet); if (bResult == FALSE) break; uMenuItemId = RUBBER_STAMP_BASE + i; RubberStampPopupMenu->AppendMenu(MF_ENABLED | MF_STRING, uMenuItemId, RefName); // check the current stamp int CmpValue = _mbscmp((const unsigned char *)pMiniToolBox->m_pRubberStampStruct->m_strCurrentStamp.GetBuffer(MAXREFNAME_SIZE), (const unsigned char *)RefName); if (CmpValue == 0) { StampIndex = i; RubberStampPopupMenu->CheckMenuItem(i, MF_BYPOSITION | MF_CHECKED); } } // end for GetCursorPos(&CurrentCursorPos); // track popup menu RubberStampPopupMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON, CurrentCursorPos.x, CurrentCursorPos.y, this, NULL); // delete menu delete RubberStampPopupMenu; // select the current stamp here in case user did not click on popup menu item. pMiniToolBox = (CMiniToolBox*)GetParent(); pMiniToolBox->SelectStamp((UINT)pMiniToolBox->m_pRubberStampStruct->m_uCurrentStampIndex, FALSE); } // end if stamp > 0 CToolBarCtrl::OnLButtonUp(nFlags, point); return; }