BOOL AP_Win32Dialog_Columns::_onDeltaPos(NM_UPDOWN * pnmud)
{
wchar_t buf[BUFSIZE];
UT_Win32LocaleString str;
switch( pnmud->hdr.idFrom )
{
case AP_RID_DIALOG_COLUMN_SPIN_NUMCOLUMNS:
if( pnmud->iDelta < 0 )
{
setColumns( getColumns() + 1 );
}
else
{
if( getColumns() > 1 )
{
setColumns( getColumns() - 1 );
}
}
SetDlgItemTextW(m_hDlg, AP_RID_DIALOG_COLUMN_EDIT_NUMCOLUMNS, _itow(getColumns(),buf,10));
checkButton(AP_RID_DIALOG_COLUMN_RADIO_ONE, (getColumns()==1));
checkButton(AP_RID_DIALOG_COLUMN_RADIO_TWO, (getColumns()==2));
checkButton(AP_RID_DIALOG_COLUMN_RADIO_THREE, (getColumns()==3));
return 1;
case AP_RID_DIALOG_COLUMN_SPIN_SPACEAFTER:
if( pnmud->iDelta < 0 )
{
incrementSpaceAfter( true );
}
else
{
incrementSpaceAfter( false );
}
str.fromUTF8 (getSpaceAfterString());
SetDlgItemTextW(m_hDlg, AP_RID_DIALOG_COLUMN_EDIT_SPACEAFTER, str.c_str ());
return 1;
case AP_RID_DIALOG_COLUMN_SPIN_MAXSIZE:
if( pnmud->iDelta < 0 )
{
incrementMaxHeight( true );
}
else
{
incrementMaxHeight( false );
}
str.fromUTF8 (getHeightString());
SetDlgItemTextW(m_hDlg, AP_RID_DIALOG_COLUMN_EDIT_MAXSIZE, str.c_str ());
return 1;
default:
return 0;
}
}
void AP_Win32Dialog_Field::SetFieldsList(void)
{
fp_FieldTypesEnum FType = fp_FieldTypes[m_iTypeIndex].m_Type;
SendMessageW(m_hwndFormats, LB_RESETCONTENT, 0, 0);
int i;
for (i = 0;fp_FieldFmts[i].m_Tag != NULL;i++)
{
if( fp_FieldFmts[i].m_Type == FType )
break;
}
UT_Win32LocaleString str;
for (;fp_FieldFmts[i].m_Tag != NULL && fp_FieldFmts[i].m_Type == FType;i++)
{
if((fp_FieldFmts[i].m_Num != FPFIELD_endnote_anch) &&
(fp_FieldFmts[i].m_Num != FPFIELD_endnote_ref) &&
(fp_FieldFmts[i].m_Num != FPFIELD_footnote_anch) &&
(fp_FieldFmts[i].m_Num != FPFIELD_footnote_ref))
{
str.fromUTF8(fp_FieldFmts[i].m_Desc);
UT_sint32 index = SendMessageW(m_hwndFormats, LB_ADDSTRING, 0, (LPARAM)str.c_str());
if (index != LB_ERR && index != LB_ERRSPACE)
{
SendMessageW(m_hwndFormats, LB_SETITEMDATA, (WPARAM)index, (LPARAM)i);
}
}
}
SendMessageW(m_hwndFormats, LB_SETCURSEL, 0, 0);
_FormatListBoxChange();
}
void XAP_Win32DialogBase::setDialogTitle(const char* uft8_str)
{
UT_return_if_fail(IsWindow(m_hDlg));
UT_Win32LocaleString str;
str.fromUTF8 (uft8_str);
SetWindowTextW (m_hDlg, str.c_str());
}
int XAP_Win32DialogBase::addItemToCombo(UT_sint32 controlId, LPCSTR p_str)
{
UT_return_val_if_fail(IsWindow(m_hDlg), CB_ERR);
UT_Win32LocaleString str;
str.fromUTF8 (p_str);
return SendDlgItemMessageW(m_hDlg, controlId, CB_ADDSTRING, 0, (LPARAM)str.c_str());
}
bool XAP_Win32DialogBase::setDlgItemText(HWND hWnd, int nIDDlgItem, const char* uft8_str)
{
UT_return_val_if_fail(IsWindow(hWnd), false);
UT_Win32LocaleString str;
str.fromUTF8 (uft8_str);
return (bool) SetDlgItemTextW (hWnd, nIDDlgItem, str.c_str());
}
/*
Draws the Format button with an arrow
*/
void AP_Win32Dialog_Styles::_onDrawButton(LPDRAWITEMSTRUCT lpDrawItemStruct, HWND hWnd)
{
UINT uiState = lpDrawItemStruct->itemState;
HPEN hPen;
HPEN pOldPen;
HDC hdc = lpDrawItemStruct->hDC;
int nWidth;
int nHeight;
int x, xEnd, xStart;
int y;
POINT p;
const char* pText;
HWND hParent;
LONG lData;
UT_Win32LocaleString str;
const XAP_StringSet * pSS = m_pApp->getStringSet();
pText= pSS->getValue(AP_STRING_ID_DLG_Styles_ModifyFormat);
nWidth = lpDrawItemStruct->rcItem.right - lpDrawItemStruct->rcItem.left;
nHeight = lpDrawItemStruct->rcItem.bottom - lpDrawItemStruct->rcItem.top;
// set the pen color
if (uiState&ODS_DISABLED)
hPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_GRAYTEXT));
else
hPen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_BTNTEXT));
pOldPen = (HPEN) SelectObject(hdc, hPen);
// draw the border of the button
if(uiState&ODS_SELECTED)
DrawFrameControl(hdc, &lpDrawItemStruct->rcItem, DFC_BUTTON, DFCS_BUTTONPUSH|DFCS_PUSHED);
else
DrawFrameControl(hdc, &lpDrawItemStruct->rcItem, DFC_BUTTON, DFCS_BUTTONPUSH);
// Draw arrow
y = nHeight/2;
xStart = (nWidth/6)*5;
for (int i=0; i<4; i++)
{
x = xStart + i;
xEnd = xStart + 7 - i;
::MoveToEx(hdc, x, y, &p);
::LineTo(hdc, xEnd, y);
y++;
}
str.fromUTF8(pText);
ExtTextOutW(hdc, (nWidth/6)*1, ((nHeight/4)), 0, NULL, str.c_str(), str.length(), NULL);
// Clean Up
SelectObject(hdc, pOldPen);
DeleteObject(hPen);
}
// cmdline processing call back I reckon
void AP_Win32App::errorMsgBadArg(const char *msg)
{
char *pszMessage;
UT_Win32LocaleString str;
pszMessage = g_strdup_printf ("%s\nRun with --help' to see a full list of available command line options.\n", msg);
str.fromUTF8(pszMessage);
MessageBoxW(NULL, str.c_str(), L"Command Line Option Error", MB_OK|MB_ICONERROR);
g_free( pszMessage );
}
void AP_Win32Dialog_Field::SetTypesList(void)
{
UT_Win32LocaleString str;
for (int i = 0;fp_FieldTypes[i].m_Desc != NULL;i++)
{
str.fromUTF8(fp_FieldTypes[i].m_Desc);
SendMessageW(m_hwndTypes, LB_ADDSTRING, (WPARAM)0, (LPARAM)str.c_str());
}
SendMessageW(m_hwndTypes, LB_SETCURSEL, (WPARAM)0, (LPARAM)0);
m_iTypeIndex = 0;
}
void AP_Win32Dialog_CollaborationAccounts::_populateWindowData()
{
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_if_fail(pManager);
m_bPopulating = true;
// clear out the old contents, if any
ListView_DeleteAllItems(m_hAccountList);
for (UT_uint32 i = 0; i < pManager->getAccounts().size(); i++)
{
AccountHandler* pAccount = pManager->getAccounts()[i];
UT_continue_if_fail(pAccount);
UT_Win32LocaleString sAccountText = AP_Win32App::s_fromUTF8ToWinLocale(pAccount->getDescription().utf8_str());
UT_Win32LocaleString sAccountTypeText = AP_Win32App::s_fromUTF8ToWinLocale(pAccount->getDisplayType().utf8_str());
// insert a new account record
LVITEMW lviAccount;
lviAccount.mask = LVIF_STATE | LVIF_IMAGE | LVIF_PARAM;
lviAccount.state = 1;
lviAccount.iItem = i;
lviAccount.iSubItem = 0;
lviAccount.lParam = (LPARAM)pAccount;
SendMessageW(m_hAccountList, LVM_INSERTITEMW, 0, (LPARAM) &lviAccount);
ListView_SetCheckState(m_hAccountList, i, pAccount->isOnline());
lviAccount.iSubItem=1;
lviAccount.pszText= const_cast<LPWSTR>(sAccountText.c_str());
SendMessageW(m_hAccountList, LVM_SETITEMTEXTW, i, (LPARAM) &lviAccount);
lviAccount.iSubItem=2;
lviAccount.pszText= const_cast<LPWSTR>(sAccountTypeText.c_str());
SendMessageW(m_hAccountList, LVM_SETITEMTEXTW, i, (LPARAM) &lviAccount);
}
_updateSelection();
m_bPopulating = false;
}
static bool s_createDirectoryIfNecessary(const char * szDir)
{
struct _stat statbuf;
UT_Win32LocaleString str;
str.fromUTF8(szDir);
if (_wstat(str.c_str(),&statbuf) == 0) // if it exists
{
if ( (statbuf.st_mode & _S_IFDIR) == _S_IFDIR ) // and is a directory
return true;
UT_DEBUGMSG(("Pathname [%s] is not a directory.\n",szDir));
return false;
}
if (CreateDirectoryW(str.c_str(),NULL))
return true;
UT_DEBUGMSG(("Could not create Directory [%s].\n",szDir));
return false;
}
bool AP_Win32LeftRuler::registerClass(XAP_Win32App * app)
{
ATOM a;
UT_Win32LocaleString str;
str.fromASCII (app->getApplicationName());
// register class for the left ruler
swprintf(s_LeftRulerWndClassName, L"%sLeftRuler", str.c_str());
a = UT_RegisterClassEx(CS_DBLCLKS | CS_OWNDC, AP_Win32LeftRuler::_LeftRulerWndProc, app->getInstance(),
NULL, LoadCursor(NULL, IDC_ARROW), GetSysColorBrush(COLOR_BTNFACE), NULL,
NULL, s_LeftRulerWndClassName);
UT_ASSERT_HARMLESS(a);
return true;
}
/*
Does a stringSet exist on disk?
*/
bool AP_Win32App::doesStringSetExist(const char* pLocale)
{
HANDLE in;
const char * szDirectory = NULL;
UT_return_val_if_fail(pLocale, false);
getPrefsValueDirectory(true,AP_PREF_KEY_StringSetDirectory,&szDirectory);
UT_return_val_if_fail(((szDirectory) && (*szDirectory)), false);
char *szPathname = (char*) UT_calloc(sizeof(char),strlen(szDirectory)+strlen(pLocale)+100);
UT_return_val_if_fail(szPathname, false);
char *szDest = szPathname;
strcpy(szDest, szDirectory);
szDest += strlen(szDest);
if ((szDest > szPathname) && (szDest[-1]!='\\'))
*szDest++='\\';
lstrcpyA(szDest,pLocale);
lstrcatA(szDest,".strings");
UT_Win32LocaleString wsFilename;
wsFilename.fromUTF8(szPathname);
in = CreateFileW(wsFilename.c_str(),0,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,
OPEN_EXISTING,0,NULL);
g_free (szPathname);
if (in!=INVALID_HANDLE_VALUE)
{
CloseHandle(in);
return true;
}
return false;
}
BOOL AP_Win32Dialog_Paragraph::_onInitDialog(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
const XAP_StringSet * pSS = m_pApp->getStringSet();
setDialogTitle (pSS->getValue(AP_STRING_ID_DLG_Para_ParaTitle));
// localize controls
_DSX(PARA_BTN_OK, DLG_OK);
_DSX(PARA_BTN_CANCEL, DLG_Cancel);
_DS(PARA_BTN_TABS, DLG_Para_ButtonTabs);
// setup the tabs
{
TabParam tp;
TCITEMW tie;
XAP_Win32App * pWin32App = static_cast<XAP_Win32App *>(m_pApp);
HINSTANCE hinst = pWin32App->getInstance();
DLGTEMPLATE * pTemplate = NULL;
HWND w = NULL;
tp.pThis = this;
// remember the windows we're using
m_hwndDlg = hWnd;
m_hwndTab = GetDlgItem(hWnd, AP_RID_DIALOG_PARA_TAB);
// add a tab for each of the child dialog boxes
UT_Win32LocaleString str;
tie.mask = TCIF_TEXT | TCIF_IMAGE | TCIF_PARAM;
tie.iImage = -1;
str.fromUTF8(_GV(DLG_Para_TabLabelIndentsAndSpacing));
tie.pszText = (LPWSTR)str.c_str();
tie.lParam = AP_RID_DIALOG_PARA_TAB1;
SendMessageW(m_hwndTab, TCM_INSERTITEMW, 0, (LPARAM)&tie);
str.fromUTF8(_GV(DLG_Para_TabLabelLineAndPageBreaks));
tie.pszText = (LPWSTR)str.c_str();
tie.lParam = AP_RID_DIALOG_PARA_TAB2;
SendMessageW(m_hwndTab, TCM_INSERTITEMW, 1, (LPARAM)&tie);
// finally, create the (modeless) child dialogs
tp.which = AP_RID_DIALOG_PARA_TAB1;
pTemplate = UT_LockDlgRes(hinst, MAKEINTRESOURCEW(tp.which));
w = CreateDialogIndirectParamW(hinst, pTemplate, m_hwndTab,
(DLGPROC)s_tabProc, (LPARAM)&tp);
UT_ASSERT_HARMLESS((w && (w == m_hwndSpacing)));
tp.which = AP_RID_DIALOG_PARA_TAB2;
pTemplate = UT_LockDlgRes(hinst, MAKEINTRESOURCEW(tp.which));
w = CreateDialogIndirectParamW(hinst, pTemplate, m_hwndTab,
(DLGPROC)s_tabProc, (LPARAM)&tp);
UT_ASSERT_HARMLESS((w && (w == m_hwndBreaks)));
}
// HACK: make sure the first tab is visible
// TODO: trigger selchange logic instead
ShowWindow(m_hwndSpacing, SW_SHOW);
// sync all controls once to get started
// HACK: the first arg gets ignored
_syncControls(id_MENU_ALIGNMENT, true);
centerDialog();
return 1; // 1 == we did not call SetFocus()
}
BOOL AP_Win32Dialog_Styles::_onCommand(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
WORD wNotifyCode = HIWORD(wParam);
WORD wId = LOWORD(wParam);
HWND hWndCtrl = (HWND)lParam;
switch (wId)
{
case AP_RID_DIALOG_STYLES_TOP_BUTTON_APPLY:
{
const gchar * szStyle = getCurrentStyle();
if(szStyle && *szStyle)
{
getView()->setStyle(szStyle);
}
}
m_answer = a_OK;
return 1;
case AP_RID_DIALOG_STYLES_TOP_BUTTON_CLOSE:
case IDCANCEL:
m_answer = a_CANCEL;
EndDialog(hWnd,0);
return 1;
case IDOK:
{
const XAP_StringSet * pSS = m_pApp->getStringSet ();
WCHAR stylename[MAX_EBX_LENGTH+1];
// Verfiy a name value for the style
// TODO - Verify unique name value
GetDlgItemTextW(hWnd,AP_RID_DIALOG_STYLES_NEWMODIFY_EBX_NAME,stylename,MAX_EBX_LENGTH);
/*_win32DialogNewModify.getControlText( AP_RID_DIALOG_STYLES_NEWMODIFY_EBX_NAME,
m_newStyleName,
MAX_EBX_LENGTH );*/
UT_UTF8String str;
str.appendUCS2((const UT_UCS2Char*)stylename,0);
strcpy(m_newStyleName,str.utf8_str());
if( !m_newStyleName || !strlen(m_newStyleName) )
{
getFrame()->showMessageBox( pSS->getValue (AP_STRING_ID_DLG_Styles_ErrBlankName),
XAP_Dialog_MessageBox::b_O,
XAP_Dialog_MessageBox::a_OK);
return 1;
}
//strcpy (m_newStyleName, (AP_Win32App::s_fromWinLocaleToUTF8(m_newStyleName)).utf8_str());
}
m_answer = a_OK;
EndDialog(hWnd,0);
return 1;
case AP_RID_DIALOG_STYLES_TOP_COMBO_LIST:
if( wNotifyCode == CBN_SELCHANGE )
{
switch(_win32Dialog.getComboSelectedIndex(AP_RID_DIALOG_STYLES_TOP_COMBO_LIST))
{
case 0:
m_whichType = USED_STYLES;
break;
case 1:
m_whichType = ALL_STYLES;
break;
case 2:
m_whichType = USER_STYLES;
break;
}
_populateWindowData();
}
return 1;
case AP_RID_DIALOG_STYLES_TOP_LIST_STYLES:
if (wNotifyCode == LBN_SELCHANGE)
{
UT_uint32 nData = -1;
const char* name;
const PD_Style * pcStyle = NULL;
int row = _win32Dialog.getListSelectedIndex(AP_RID_DIALOG_STYLES_TOP_LIST_STYLES);
nData = _win32Dialog.getListDataItem( AP_RID_DIALOG_STYLES_TOP_LIST_STYLES, row);
if (row!=LB_ERR)
{
getDoc()->enumStyles(nData, &name, &pcStyle);
m_selectedStyle = name;
m_nSelectedStyleIdx = nData;
// refresh the previews
_populatePreviews(false);
}
break;
}
return 1;
case AP_RID_DIALOG_STYLES_TOP_BUTTON_DELETE:
{
if( m_selectedStyle != "" )
{
if ( !getDoc()->removeStyle(m_selectedStyle.c_str()) ) // actually remove the style
{
const XAP_StringSet * pSS = m_pApp->getStringSet();
getFrame()->showMessageBox( pSS->getValue (AP_STRING_ID_DLG_Styles_ErrStyleCantDelete),
XAP_Dialog_MessageBox::b_O,
XAP_Dialog_MessageBox::a_OK );
return 1;
}
getFrame()->repopulateCombos();
_populateWindowData(); // force a refresh
getDoc()->signalListeners(PD_SIGNAL_UPDATE_LAYOUT);
m_selectedStyle = "";
}
}
return 1;
case AP_RID_DIALOG_STYLES_TOP_BUTTON_NEW:
{
m_bisNewStyle = true;
//_win32Dialog.showWindow(SW_HIDE);
XAP_Frame* pFrame = getFrame();
//_win32DialogNewModify.runModal(pFrame, AP_DIALOG_ID_STYLES, AP_RID_DIALOG_STYLES_NEWMODIFY, this);
createModal(pFrame, MAKEINTRESOURCEW(AP_RID_DIALOG_STYLES_NEWMODIFY));
if(m_answer == AP_Dialog_Styles::a_OK)
{
createNewStyle((gchar *) m_newStyleName);
_populateCList();
}
destroyAbiPreview();
DELETEP(m_pAbiPreviewWidget);
//_win32Dialog.showWindow(SW_SHOW);
}
return 1;
case AP_RID_DIALOG_STYLES_TOP_BUTTON_MODIFY:
{
// Verify that a style is selected
if( m_selectedStyle == "" )
{
XAP_Frame * pFrame = getFrame();
const XAP_StringSet * pSS = m_pApp->getStringSet();
pFrame->showMessageBox( pSS->getValue(AP_STRING_ID_DLG_Styles_ErrNoStyle),
XAP_Dialog_MessageBox::b_O,
XAP_Dialog_MessageBox::a_OK);
m_answer = AP_Dialog_Styles::a_CANCEL;
return 1;
}
else
{
PD_Style * pStyle = NULL;
getDoc()->getStyle(m_selectedStyle.c_str(), &pStyle);
m_bisNewStyle = false;
XAP_Frame* pFrame = getFrame();
XAP_Win32App * pWin32App = static_cast<XAP_Win32App *>(getApp());
createModal (pFrame, MAKEINTRESOURCEW(AP_RID_DIALOG_STYLES_NEWMODIFY));
/*LPCWSTR lpTemplate = MAKEINTRESOURCEW(AP_RID_DIALOG_STYLES_NEWMODIFY);
int result = DialogBoxParamW(pWin32App->getInstance(), lpTemplate,
static_cast<XAP_Win32FrameImpl*>(pFrame->getFrameImpl())->getTopLevelWindow(),
(DLGPROC)s_dlgProc, (LPARAM)this);*/
if(m_answer == AP_Dialog_Styles::a_OK)
{
applyModifiedStyleToDoc();
getDoc()->updateDocForStyleChange(getCurrentStyle(),true);
getDoc()->signalListeners(PD_SIGNAL_UPDATE_LAYOUT);
}
destroyAbiPreview();
DELETEP(m_pAbiPreviewWidget);
}
}
return 1;
case AP_RID_DIALOG_STYLES_NEWMODIFY_BTN_REMOVE:
{
char szTemp[128];
_win32DialogNewModify.getControlText( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_REMOVE,
szTemp,
sizeof(szTemp) );
removeVecProp(szTemp);
rebuildDeleteProps();
updateCurrentStyle();
}
return 1;
case AP_RID_DIALOG_STYLES_NEWMODIFY_BTN_TOGGLEITEMS:
{
RECT rect;
HMENU hMenu;
int x,y;
HWND hWndButton;
static int menu_items[]={AP_STRING_ID_DLG_Styles_ModifyParagraph,
AP_STRING_ID_DLG_Styles_ModifyFont,
AP_STRING_ID_DLG_Styles_ModifyTabs,
AP_STRING_ID_DLG_Styles_ModifyNumbering,
AP_STRING_ID_DLG_Styles_ModifyLanguage
};
UT_Win32LocaleString str;
hWndButton = GetDlgItem(hWnd, AP_RID_DIALOG_STYLES_NEWMODIFY_BTN_TOGGLEITEMS);
XAP_Win32App * app = static_cast<XAP_Win32App *> (m_pApp);
const XAP_StringSet * pSS = m_pApp->getStringSet();
// Get button position
GetWindowRect(hWndButton, &rect);
x = rect.left;
y = rect.bottom;
// Menu creation
hMenu = CreatePopupMenu();
str;
for (int i=0; i<5; i++) {
str.fromUTF8(pSS->getValue(menu_items[i]));
AppendMenuW(hMenu, MF_ENABLED|MF_STRING, i+1, (LPCWSTR)str.c_str());
}
// show and track the menu
m_selectToggle = TrackPopupMenu(hMenu, TPM_LEFTALIGN|TPM_LEFTBUTTON|TPM_NONOTIFY|TPM_RETURNCMD,
x,y,0, hWndButton, NULL);
switch(m_selectToggle)
{
case 0: // user has cancelled
break;
case 1:
ModifyParagraph();
break;
case 2:
ModifyFont();
break;
case 3:
ModifyTabs();
break;
case 4:
ModifyLists();
break;
case 5:
ModifyLang();
break;
default:
break;
}
rebuildDeleteProps();
updateCurrentStyle();
DestroyMenu(hMenu);
return 1;
}
case AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON:
if( wNotifyCode == CBN_SELCHANGE )
{
eventBasedOn();
rebuildDeleteProps();
}
return 1;
case AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA:
if( wNotifyCode == CBN_SELCHANGE )
{
eventFollowedBy();
}
return 1;
case AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_TYPE:
if( wNotifyCode == CBN_SELCHANGE )
{
eventStyleType();
}
return 1;
default: // we did not handle this notification
UT_DEBUGMSG(("WM_Command for id %ld\n",wId));
return 0; // return zero to let windows take care of it.
}
return 0; // return zero to let windows take care of it.
}
BOOL AP_Win32Dialog_Styles::_onInitDialog(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
XAP_Win32App * app = static_cast<XAP_Win32App *> (m_pApp);
UT_return_val_if_fail (app,0);
const XAP_StringSet * pSS = m_pApp->getStringSet();
WCHAR szTemp[20];
GetWindowTextW(hWnd, szTemp, 20 );
m_hDlg=hWnd;
// Regular dialog box
if( lstrcmpW(szTemp, L"Styles") == 0 )
{
setDialogTitle (pSS->getValue(AP_STRING_ID_DLG_Styles_StylesTitle));
// localize controls
_DS(STYLES_TOP_TEXT_LIST, DLG_Styles_List);
_DS(STYLES_TOP_TEXT_PARAGRAPH_PREVIEW, DLG_Styles_ParaPrev);
_DS(STYLES_TOP_TEXT_CHARACTER_PREVIEW, DLG_Styles_CharPrev);
_DS(STYLES_TOP_TEXT_DESCRIPTION, DLG_Styles_Description);
_DS(STYLES_TOP_BUTTON_DELETE, DLG_Styles_Delete);
_DS(STYLES_TOP_BUTTON_MODIFY, DLG_Styles_Modify);
_DS(STYLES_TOP_BUTTON_NEW, DLG_Styles_New);
_DS(STYLES_TOP_TEXT_AVAILABLE, DLG_Styles_Available); // "Available Styles" GROUPBOX
_DSX(STYLES_TOP_BUTTON_APPLY, DLG_Apply);
_DSX(STYLES_TOP_BUTTON_CLOSE, DLG_Close);
// Set the list combo.
_win32Dialog.addItemToCombo(AP_RID_DIALOG_STYLES_TOP_COMBO_LIST,
pSS->getValue (AP_STRING_ID_DLG_Styles_LBL_InUse));
_win32Dialog.addItemToCombo(AP_RID_DIALOG_STYLES_TOP_COMBO_LIST,
pSS->getValue(AP_STRING_ID_DLG_Styles_LBL_All));
_win32Dialog.addItemToCombo(AP_RID_DIALOG_STYLES_TOP_COMBO_LIST,
pSS->getValue(AP_STRING_ID_DLG_Styles_LBL_UserDefined));
_win32Dialog.selectComboItem(AP_RID_DIALOG_STYLES_TOP_COMBO_LIST, (int)m_whichType);
// Create a preview windows.
HWND hwndChild = GetDlgItem(hWnd, AP_RID_DIALOG_STYLES_TOP_TEXT_PARAGRAPH_PREVIEW);
m_pParaPreviewWidget = new XAP_Win32PreviewWidget(static_cast<XAP_Win32App *>(m_pApp),
hwndChild,
0);
UT_uint32 w,h;
m_pParaPreviewWidget->getWindowSize(&w,&h);
_createParaPreviewFromGC(m_pParaPreviewWidget->getGraphics(), w, h);
m_pParaPreviewWidget->setPreview(m_pParaPreview);
hwndChild = GetDlgItem(hWnd, AP_RID_DIALOG_STYLES_TOP_TEXT_CHARACTER_PREVIEW);
m_pCharPreviewWidget = new XAP_Win32PreviewWidget(static_cast<XAP_Win32App *>(m_pApp),
hwndChild,
0);
m_pCharPreviewWidget->getWindowSize(&w,&h);
_createCharPreviewFromGC(m_pCharPreviewWidget->getGraphics(), w, h);
m_pCharPreviewWidget->setPreview(m_pCharPreview);
_populateWindowData();
}
// This is either the new or Modify sub dialog of styles
else
{
_win32DialogNewModify.setHandle(hWnd);
// Localize the controls Labels etc...
setWindowText(hWnd, pSS->getValue( (m_bisNewStyle) ?
AP_STRING_ID_DLG_Styles_NewTitle :
AP_STRING_ID_DLG_Styles_ModifyTitle ));
#define _DS(c,s) setDlgItemText(hWnd, AP_RID_DIALOG_##c,pSS->getValue(AP_STRING_ID_##s))
#define _DSX(c,s) setDlgItemText(hWnd, AP_RID_DIALOG_##c,pSS->getValue(XAP_STRING_ID_##s))
_DS(STYLES_NEWMODIFY_LBL_NAME, DLG_Styles_ModifyName);
_DS(STYLES_NEWMODIFY_LBL_BASEDON, DLG_Styles_ModifyBasedOn);
_DS(STYLES_NEWMODIFY_LBL_TYPE, DLG_Styles_ModifyType);
_DS(STYLES_NEWMODIFY_LBL_FOLLOWPARA, DLG_Styles_ModifyFollowing);
_DS(STYLES_NEWMODIFY_LBL_REMOVE, DLG_Styles_RemoveLab);
_DS(STYLES_NEWMODIFY_GBX_PREVIEW, DLG_Styles_ModifyPreview);
_DS(STYLES_NEWMODIFY_GBX_DESC, DLG_Styles_ModifyDescription);
_DS(STYLES_NEWMODIFY_BTN_REMOVE, DLG_Styles_RemoveButton);
_DS(STYLES_NEWMODIFY_BTN_SHORTCUT, DLG_Styles_ModifyShortCut);
_DSX(STYLES_NEWMODIFY_BTN_OK, DLG_OK);
_DSX(STYLES_NEWMODIFY_BTN_CANCEL, DLG_Cancel);
#undef _DSX
#undef _DS
// Changes basic controls based upon either New or Modify Dialog
_win32DialogNewModify.showControl( AP_RID_DIALOG_STYLES_NEWMODIFY_EBX_TYPE ,
(m_bisNewStyle) ? SW_HIDE : SW_SHOW );
_win32DialogNewModify.showControl( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_TYPE ,
(m_bisNewStyle) ? SW_SHOW : SW_HIDE );
// Initialize the controls with appropriate data
size_t nStyles = getDoc()->getStyleCount();
const char * name = NULL;
const char * pLocalised = NULL;
const PD_Style * pcStyle = NULL;
int nIndex;
UT_Win32LocaleString str;
UT_UTF8String utf8;
UT_GenericVector<PD_Style*> * pStyles = NULL;
getDoc()->enumStyles(pStyles);
UT_return_val_if_fail( pStyles, FALSE );
for (UT_uint32 i = 0; i < nStyles; i++)
{
pcStyle = pStyles->getNthItem(i);
UT_return_val_if_fail( pcStyle, FALSE );
name = pcStyle->getName();
pt_PieceTable::s_getLocalisedStyleName(name, utf8);
pLocalised = utf8.utf8_str();
nIndex = _win32DialogNewModify.addItemToCombo(AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON, pLocalised);
_win32DialogNewModify.setComboDataItem(AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON,
nIndex, i);
nIndex = _win32DialogNewModify.addItemToCombo(AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA, pLocalised);
_win32DialogNewModify.setComboDataItem(AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA,
nIndex, i);
}
delete pStyles;
// Strings (not styles names)
const char* pDefCurrent = pSS->getValue(AP_STRING_ID_DLG_Styles_DefCurrent);
const char* pDefNone = pSS->getValue(AP_STRING_ID_DLG_Styles_DefNone);
nIndex = _win32DialogNewModify.addItemToCombo( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA,
pDefCurrent );
_win32DialogNewModify.setComboDataItem(AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA,
nIndex, (DWORD)-1);
nIndex = _win32DialogNewModify.addItemToCombo( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON,
pDefNone);
_win32DialogNewModify.setComboDataItem(AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON,
nIndex, (DWORD)-1);
if( m_bisNewStyle )
{
const char* p = pSS->getValue(AP_STRING_ID_DLG_Styles_ModifyParagraph);
_win32DialogNewModify.addItemToCombo( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_TYPE,
p );
p = pSS->getValue(AP_STRING_ID_DLG_Styles_ModifyCharacter);
_win32DialogNewModify.addItemToCombo( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_TYPE,
p);
// Set the Default syltes: none, default current
UT_sint32 result;
str.fromUTF8(pSS->getValue(AP_STRING_ID_DLG_Styles_DefNone));
result = SendDlgItemMessageW(hWnd, AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON, CB_FINDSTRING, -1,
(LPARAM) str.c_str());
_win32DialogNewModify.selectComboItem( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON, result );
str.fromUTF8(pSS->getValue(AP_STRING_ID_DLG_Styles_DefCurrent));
result = SendDlgItemMessageW(hWnd, AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA, CB_FINDSTRING, -1,
(LPARAM) str.c_str());
_win32DialogNewModify.selectComboItem( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA, result );
str.fromUTF8(pSS->getValue(AP_STRING_ID_DLG_Styles_ModifyParagraph));
result = SendDlgItemMessageW(hWnd, AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_TYPE, CB_FINDSTRING, -1,
(LPARAM) str.c_str());
_win32DialogNewModify.selectComboItem( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_TYPE, result );
eventBasedOn();
eventFollowedBy();
eventStyleType();
fillVecFromCurrentPoint();
}
else
{
const char * szCurrentStyle = NULL;
const char * szBasedOn = NULL;
const char * szFollowedBy = NULL;
const char * pLocalised = NULL;
PD_Style * pStyle = NULL;
PD_Style * pBasedOnStyle = NULL;
PD_Style * pFollowedByStyle = NULL;
szCurrentStyle = m_selectedStyle.c_str();
pt_PieceTable::s_getLocalisedStyleName(szCurrentStyle, utf8);
pLocalised = utf8.utf8_str();
_win32DialogNewModify.setControlText( AP_RID_DIALOG_STYLES_NEWMODIFY_EBX_NAME,
pLocalised);
if(szCurrentStyle)
getDoc()->getStyle(szCurrentStyle,&pStyle);
if(!pStyle)
{
XAP_Frame * pFrame = getFrame();
pFrame->showMessageBox( pSS->getValue(AP_STRING_ID_DLG_Styles_ErrNoStyle),
XAP_Dialog_MessageBox::b_O,
XAP_Dialog_MessageBox::a_OK);
m_answer = AP_Dialog_Styles::a_CANCEL;
return false;
}
//
// Valid style get the Based On and followed by values
//
pBasedOnStyle = pStyle->getBasedOn();
pFollowedByStyle = pStyle->getFollowedBy();
size_t nStyles = getDoc()->getStyleCount();
const char * name = NULL;
const PD_Style * pcStyle = NULL;
UT_GenericVector<PD_Style*> * pStyles = NULL;
getDoc()->enumStyles(pStyles);
UT_return_val_if_fail( pStyles, FALSE );
for (UT_uint32 i = 0; i < nStyles; i++)
{
pcStyle = pStyles->getNthItem(i);
UT_return_val_if_fail( pcStyle, FALSE );
name = pcStyle->getName();
if(pBasedOnStyle && pcStyle == pBasedOnStyle)
{
szBasedOn = name;
}
if(pFollowedByStyle && pcStyle == pFollowedByStyle)
{
szFollowedBy = name;
}
}
delete pStyles;
if(pBasedOnStyle != NULL)
{
pt_PieceTable::s_getLocalisedStyleName(szBasedOn, utf8);
pLocalised = utf8.utf8_str();
str = AP_Win32App::s_fromUTF8ToWinLocale(pLocalised);
UT_uint32 result = SendDlgItemMessageW(hWnd, AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON, CB_FINDSTRING, -1,
(LPARAM)str.c_str());
_win32DialogNewModify.selectComboItem( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON, result );
}
else
{
// Not a style name
str.fromUTF8(pSS->getValue(AP_STRING_ID_DLG_Styles_DefNone));
UT_uint32 result = SendDlgItemMessageW(hWnd, AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON, CB_FINDSTRING, -1,
(LPARAM) str.c_str());
_win32DialogNewModify.selectComboItem( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_BASEDON, result );
}
if(pFollowedByStyle != NULL)
{
pt_PieceTable::s_getLocalisedStyleName(szFollowedBy, utf8);
pLocalised = utf8.utf8_str();
str = AP_Win32App::s_fromUTF8ToWinLocale(pLocalised);
UT_uint32 result = SendDlgItemMessageW(hWnd, AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA, CB_FINDSTRING, -1,
(LPARAM)str.c_str());
_win32DialogNewModify.selectComboItem( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA, result );
}
else
{
pt_PieceTable::s_getLocalisedStyleName(pSS->getValue(AP_STRING_ID_DLG_Styles_DefCurrent), utf8);
pLocalised = utf8.utf8_str();
str = AP_Win32App::s_fromUTF8ToWinLocale(pLocalised);
UT_uint32 result = SendDlgItemMessageW(hWnd, AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA, CB_FINDSTRING, -1,
(LPARAM) str.c_str());
_win32DialogNewModify.selectComboItem( AP_RID_DIALOG_STYLES_NEWMODIFY_CBX_FOLLOWPARA, result );
}
if(strstr(getAttsVal("type"),"P") != 0)
{
_win32DialogNewModify.setControlText( AP_RID_DIALOG_STYLES_NEWMODIFY_EBX_TYPE,
pSS->getValue(AP_STRING_ID_DLG_Styles_ModifyParagraph) );
}
else
{
_win32DialogNewModify.setControlText( AP_RID_DIALOG_STYLES_NEWMODIFY_EBX_TYPE,
pSS->getValue(AP_STRING_ID_DLG_Styles_ModifyCharacter) );
}
// Disable for editing top controls in Modify Dialog
_win32DialogNewModify.enableControl( AP_RID_DIALOG_STYLES_NEWMODIFY_EBX_NAME, false );
_win32DialogNewModify.enableControl( AP_RID_DIALOG_STYLES_NEWMODIFY_EBX_TYPE, false );
fillVecWithProps(szCurrentStyle,true);
}
// Generate the Preview class
HWND hwndChild = GetDlgItem( hWnd, AP_RID_DIALOG_STYLES_NEWMODIFY_CTL_PREVIEW );
m_pAbiPreviewWidget = new XAP_Win32PreviewWidget(static_cast<XAP_Win32App *>(m_pApp),
hwndChild,
0);
UT_uint32 w,h;
m_pAbiPreviewWidget->getWindowSize(&w,&h);
_createAbiPreviewFromGC(m_pAbiPreviewWidget->getGraphics(), w, h);
_populateAbiPreview(m_bisNewStyle);
m_pAbiPreviewWidget->setPreview(m_pAbiPreview);
rebuildDeleteProps();
_populatePreviews(true);
}
XAP_Win32DialogHelper::s_centerDialog(hWnd);
return 1; // 1 == we did not call SetFocus()
}
bool AP_Win32App::initialize(void)
{
bool bSuccess = true;
const char * szUserPrivateDirectory = getUserPrivateDirectory();
bool bVerified = s_createDirectoryIfNecessary(szUserPrivateDirectory);
UT_return_val_if_fail (bVerified, false);
// create templates directory
UT_String sTemplates = szUserPrivateDirectory;
sTemplates += "/templates";
s_createDirectoryIfNecessary(sTemplates.c_str());
// load the preferences.
m_prefs = new AP_Win32Prefs();
UT_return_val_if_fail (m_prefs, false);
m_prefs->fullInit();
// now that preferences are established, let the xap init
m_pClipboard = new AP_Win32Clipboard();
UT_return_val_if_fail (m_pClipboard, false);
m_pEMC = AP_GetEditMethods();
UT_return_val_if_fail (m_pEMC, false);
m_pBindingSet = new AP_BindingSet(m_pEMC);
UT_return_val_if_fail (m_pBindingSet, false);
m_pMenuActionSet = AP_CreateMenuActionSet();
UT_return_val_if_fail (m_pMenuActionSet,false);
m_pToolbarActionSet = AP_CreateToolbarActionSet();
UT_return_val_if_fail (m_pToolbarActionSet,false);
//////////////////////////////////////////////////////////////////
// load the dialog and message box strings
//////////////////////////////////////////////////////////////////
{
// assume we will be using the builtin set (either as the main
// set or as the fallback set).
AP_BuiltinStringSet * pBuiltinStringSet = new AP_BuiltinStringSet(this,AP_PREF_DEFAULT_StringSet);
UT_return_val_if_fail (pBuiltinStringSet, false);
m_pStringSet = pBuiltinStringSet;
// see if we should load an alternate set from the disk
const char * szDirectory = NULL;
const char * szStringSet = NULL;
if ( (getPrefsValue(AP_PREF_KEY_StringSet,&szStringSet))
&& (szStringSet)
&& (*szStringSet)
&& (g_ascii_strcasecmp(szStringSet,AP_PREF_DEFAULT_StringSet) != 0))
{
getPrefsValueDirectory(true,AP_PREF_KEY_StringSetDirectory,&szDirectory);
UT_return_val_if_fail ((szDirectory) && (*szDirectory), false);
char * szPathname = (char *)UT_calloc(sizeof(char),strlen(szDirectory)+strlen(szStringSet)+100);
UT_return_val_if_fail (szPathname, false);
sprintf(szPathname,"%s%s%s.strings",
szDirectory,
((szDirectory[strlen(szDirectory)-1]=='\\') ? "" : "\\"),
szStringSet);
AP_DiskStringSet * pDiskStringSet = new AP_DiskStringSet(this);
UT_return_val_if_fail (pDiskStringSet, false);
if (pDiskStringSet->loadStringsFromDisk(szPathname))
{
pDiskStringSet->setFallbackStringSet(m_pStringSet);
m_pStringSet = pDiskStringSet;
UT_Language_updateLanguageNames();
UT_DEBUGMSG(("Using StringSet [%s]\n",szPathname));
}
else
{
UT_DEBUGMSG(("Unable to load StringSet [%s] -- using builtin strings instead.\n",szPathname));
DELETEP(pDiskStringSet);
}
g_free(szPathname);
}
}
// AP_App::initilize() calls for us XAP_Win32App::initialize()
if (! AP_App::initialize())
return false;
// let various window types register themselves
if (!AP_Win32Frame::RegisterClass(this))
{
UT_DEBUGMSG(("couldn't register class\n"));
return false;
}
//////////////////////////////////////////////////////////////////
// Initialize the importers/exporters
//////////////////////////////////////////////////////////////////
IE_ImpExp_RegisterXP ();
//////////////////////////////////////////////////////////////////
// initializes the spell checker.
//////////////////////////////////////////////////////////////////
{
#if ENABLE_SPELL
SpellManager::instance();
#endif
}
// Now we have the strings loaded we can populate the field names correctly
int i;
for (i = 0; fp_FieldTypes[i].m_Type != FPFIELDTYPE_END; i++)
{
(&fp_FieldTypes[i])->m_Desc = m_pStringSet->getValue(fp_FieldTypes[i].m_DescId);
UT_DEBUGMSG(("Setting field type desc for type %d, desc=%s\n", fp_FieldTypes[i].m_Type, fp_FieldTypes[i].m_Desc));
}
for (i = 0; fp_FieldFmts[i].m_Tag != NULL; i++)
{
(&fp_FieldFmts[i])->m_Desc = m_pStringSet->getValue(fp_FieldFmts[i].m_DescId);
UT_DEBUGMSG(("Setting field desc for field %s, desc=%s\n", fp_FieldFmts[i].m_Tag, fp_FieldFmts[i].m_Desc));
}
///////////////////////////////////////////////////////////////////////
/// Build a labelset so the plugins can add themselves to something ///
///////////////////////////////////////////////////////////////////////
const char * szMenuLabelSetName = NULL;
if (getPrefsValue( AP_PREF_KEY_StringSet, (const gchar**)&szMenuLabelSetName)
&& (szMenuLabelSetName) && (*szMenuLabelSetName))
{
;
}
else
szMenuLabelSetName = AP_PREF_DEFAULT_StringSet;
getMenuFactory()->buildMenuLabelSet(szMenuLabelSetName);
//////////////////////////////////////////////////////////////////
// Check for necessary DLLs now that we can do localized error messages
//////////////////////////////////////////////////////////////////
// Ensure that common control DLL is loaded
HINSTANCE hinstCC = LoadLibraryW(L"comctl32.dll");
UT_return_val_if_fail (hinstCC, false);
InitCommonControlsEx_fn pInitCommonControlsEx = NULL;
if( hinstCC != NULL )
pInitCommonControlsEx = (InitCommonControlsEx_fn)GetProcAddress( hinstCC, "InitCommonControlsEx");
if( pInitCommonControlsEx != NULL )
{
INITCOMMONCONTROLSEX icex;
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
icex.dwICC = ICC_COOL_CLASSES | ICC_BAR_CLASSES // load the rebar and toolbar
| ICC_TAB_CLASSES | ICC_UPDOWN_CLASS // and tab and spin controls
| ICC_STANDARD_CLASSES;
pInitCommonControlsEx(&icex);
}
else
{
InitCommonControls();
UT_Win32LocaleString err;
err.fromUTF8 (m_pStringSet->getValue(AP_STRING_ID_WINDOWS_COMCTL_WARNING));
MessageBoxW(NULL, err.c_str(), NULL, MB_OK);
}
//////////////////////////////////////////////////////////////////
// load the all Plugins from the correct directory
//////////////////////////////////////////////////////////////////
#ifndef DISABLE_BUILTIN_PLUGINS
abi_register_builtin_plugins();
#endif
bool bLoadPlugins = true;
bool bFound = getPrefsValueBool(XAP_PREF_KEY_AutoLoadPlugins,&bLoadPlugins);
if(bLoadPlugins || !bFound)
{
WCHAR szPath[PATH_MAX];
WCHAR szPlugin[PATH_MAX];
_getExeDir( szPath, PATH_MAX);
#ifdef _MSC_VER
lstrcatW(szPath, L"..\\plugins\\*.dll");
#else
#define ABI_WIDE_STRING(t) L ## t
lstrcatW(szPath, ABI_WIDE_STRING("..\\lib\\" PACKAGE L"-" ABIWORD_SERIES L"\\plugins\\*.dll"));
#endif
WIN32_FIND_DATAW cfile;
HANDLE findtag = FindFirstFileW( szPath, &cfile );
if( findtag != INVALID_HANDLE_VALUE )
{
do
{
_getExeDir( szPlugin, PATH_MAX );
#ifdef _MSC_VER
lstrcatW( szPlugin, L"..\\plugins\\" );
#else
lstrcatW( szPlugin, ABI_WIDE_STRING("..\\lib\\" PACKAGE L"-" ABIWORD_SERIES L"\\plugins\\" ));
#endif
lstrcatW( szPlugin, cfile.cFileName );
XAP_ModuleManager::instance().loadModule( getUTF8String(szPlugin) );
} while( FindNextFileW ( findtag, &cfile ) );
FindClose( findtag );
}
UT_String pluginName( getUserPrivateDirectory() );
UT_String pluginDir( getUserPrivateDirectory() );
pluginDir += "\\AbiWord\\plugins\\*.dll";
UT_Win32LocaleString str;
str.fromUTF8(pluginDir.c_str());
findtag = FindFirstFileW( str.c_str(), &cfile );
if( findtag != INVALID_HANDLE_VALUE )
{
do
{
pluginName = getUserPrivateDirectory();
pluginName += "\\AbiWord\\plugins\\";
pluginName += getUTF8String(cfile.cFileName);
XAP_ModuleManager::instance().loadModule( pluginName.c_str() );
} while( FindNextFileW( findtag, &cfile ) );
FindClose( findtag );
}
}
return bSuccess;
}
BOOL AP_Win32Dialog_Columns::_onCommand(HWND hWnd, WPARAM wParam, LPARAM /*lParam*/)
{
WORD wNotifyCode = HIWORD(wParam);
WORD wId = LOWORD(wParam);
wchar_t buf[BUFSIZE];
UT_Win32LocaleString str;
switch (wId)
{
case IDCANCEL: // also AP_RID_DIALOG_COLUMN_BTN_CANCEL
m_answer = a_CANCEL;
// fall through
case IDOK: // also AP_RID_DIALOG_COLUMN_BTN_OK
EndDialog(hWnd,0);
return 1;
case AP_RID_DIALOG_COLUMN_RADIO_ONE:
setColumns(1);
checkButton(AP_RID_DIALOG_COLUMN_RADIO_TWO, false);
checkButton(AP_RID_DIALOG_COLUMN_RADIO_THREE, false);
SetDlgItemTextW(m_hDlg, AP_RID_DIALOG_COLUMN_EDIT_NUMCOLUMNS, _itow(getColumns(),buf,10));
return 1;
case AP_RID_DIALOG_COLUMN_RADIO_TWO:
setColumns(2);
checkButton(AP_RID_DIALOG_COLUMN_RADIO_ONE, false);
checkButton(AP_RID_DIALOG_COLUMN_RADIO_THREE, false);
SetDlgItemTextW(m_hDlg, AP_RID_DIALOG_COLUMN_EDIT_NUMCOLUMNS, _itow(getColumns(),buf,10));
return 1;
case AP_RID_DIALOG_COLUMN_RADIO_THREE:
setColumns(3);
checkButton(AP_RID_DIALOG_COLUMN_RADIO_ONE, false);
checkButton(AP_RID_DIALOG_COLUMN_RADIO_TWO, false);
SetDlgItemTextW(m_hDlg, AP_RID_DIALOG_COLUMN_EDIT_NUMCOLUMNS, _itow(getColumns(),buf,10));
return 1;
case AP_RID_DIALOG_COLUMN_CHECK_LINE_BETWEEN:
setLineBetween( isChecked(AP_RID_DIALOG_COLUMN_CHECK_LINE_BETWEEN)==BST_CHECKED );
return 1;
case AP_RID_DIALOG_COLUMN_EDIT_NUMCOLUMNS:
if( wNotifyCode == EN_KILLFOCUS )
{
GetDlgItemTextW( hWnd, wId, buf, BUFSIZE );
if( _wtoi( buf ) > 0 && _wtoi(buf) != (signed) getColumns() )
{
setColumns( _wtoi(buf) );
}
SetDlgItemTextW(m_hDlg, wId, _itow(getColumns(),buf,10));
checkButton(AP_RID_DIALOG_COLUMN_RADIO_ONE, (getColumns()==1));
checkButton(AP_RID_DIALOG_COLUMN_RADIO_TWO, (getColumns()==2));
checkButton(AP_RID_DIALOG_COLUMN_RADIO_THREE, (getColumns()==3));
}
return 1;
case AP_RID_DIALOG_COLUMN_EDIT_SPACEAFTER:
if( wNotifyCode == EN_KILLFOCUS )
{
GetDlgItemTextW( hWnd, wId, buf, BUFSIZE );
str.fromLocale (buf);
setSpaceAfter( str.utf8_str().utf8_str() );
str.fromUTF8 (getSpaceAfterString ());
SetDlgItemTextW(m_hDlg, wId, str.c_str ());
}
return 1;
case AP_RID_DIALOG_COLUMN_EDIT_MAXSIZE:
if( wNotifyCode == EN_KILLFOCUS )
{
GetDlgItemTextW( hWnd, wId, buf, BUFSIZE );
str.fromLocale (buf);
setMaxHeight( str.utf8_str().utf8_str() );
str.fromUTF8 (getHeightString());
SetDlgItemTextW(m_hDlg, wId, str.c_str ());
}
return 1;
case AP_RID_DIALOG_COLUMN_CHECK_RTL_ORDER:
setColumnOrder( (UT_uint32) (isChecked(AP_RID_DIALOG_COLUMN_CHECK_RTL_ORDER) == BST_CHECKED) );
return 1;
default: // we did not handle this notification
UT_DEBUGMSG(("WM_Command for id %ld\n",wId));
return 0; // return zero to let windows take care of it.
}
}
void XAP_Win32Dialog_FontChooser::runModal(XAP_Frame * pFrame)
{
UT_return_if_fail(pFrame);
XAP_Win32App * pApp = static_cast<XAP_Win32App *>(XAP_App::getApp());
UT_return_if_fail(pApp);
const XAP_EncodingManager *pEncMan = pApp->getEncodingManager();
UT_return_if_fail(pEncMan);
UT_Win32LocaleString family;
UT_DEBUGMSG(("FontChooserStart: Family[%s] Size[%s] Weight[%s] Style[%s] Color[%s] Underline[%d] StrikeOut[%d]\n",
m_sFontFamily.c_str(),
m_sFontSize.c_str(),
m_sFontWeight.c_str(),
m_sFontStyle.c_str(),
m_sColor.c_str(),
m_bUnderline,
m_bStrikeout));
m_bWin32Overline = m_bOverline;
m_bWin32Hidden = m_bHidden;
m_bWin32SuperScript = m_bSuperScript;
m_bWin32SubScript = m_bSubScript;
/*
WARNING: any changes to this function should be closely coordinated
with the equivalent logic in Win32Graphics::FindFont()
*/
LOGFONTW lf;
memset(&lf, 0, sizeof(lf));
CHOOSEFONTW cf;
memset(&cf, 0, sizeof(cf));
cf.lStructSize = sizeof(cf);
cf.hwndOwner = static_cast<XAP_Win32FrameImpl*>(pFrame->getFrameImpl())->getTopLevelWindow();
cf.lpLogFont = &lf;
cf.Flags = CF_SCREENFONTS |
CF_EFFECTS |
CF_ENABLEHOOK |
CF_ENABLETEMPLATE |
CF_INITTOLOGFONTSTRUCT;
cf.lpTemplateName = MAKEINTRESOURCEW(XAP_RID_DIALOG_FONT);
cf.lpfnHook = (LPCFHOOKPROC) s_hookProc;
cf.lCustData = (LPARAM) this;
cf.hInstance = pApp->getInstance();
if (!m_sFontFamily.empty())
{
family.fromUTF8 (m_sFontFamily.c_str());
lstrcpynW(lf.lfFaceName,family.c_str(),LF_FACESIZE);
}
else
cf.Flags |= CF_NOFACESEL;
if (!m_sFontSize.empty())
{
UT_ASSERT(sizeof(char) == sizeof(gchar));
lf.lfHeight = (long) -(UT_convertToPoints(m_sFontSize.c_str()))*4/3;
}
else
cf.Flags |= CF_NOSIZESEL;
if (!m_sFontWeight.empty())
{
if (g_ascii_strcasecmp(m_sFontWeight.c_str(),"bold") == 0)
lf.lfWeight = 700;
// TODO do we need any others here...
}
else
cf.Flags |= CF_NOSTYLESEL;
if (!m_sFontStyle.empty())
{
if (g_ascii_strcasecmp(m_sFontStyle.c_str(),"italic") == 0)
lf.lfItalic = TRUE;
}
else
cf.Flags |= CF_NOSTYLESEL;
if (!m_sColor.empty())
{
UT_RGBColor c;
UT_parseColor(m_sColor.c_str(),c);
cf.rgbColors = RGB(c.m_red,c.m_grn,c.m_blu);
}
if (m_bUnderline)
lf.lfUnderline = TRUE;
if (m_bStrikeout)
lf.lfStrikeOut = TRUE;
// run the actual dialog...
m_answer = (ChooseFontW(&cf) ? a_OK : a_CANCEL);
// Convert the font name returned by the Windows Font Chooser
// to UTF-8.
family.fromLocale (lf.lfFaceName);
UT_UTF8String family_utf = family.utf8_str();
const char *szFontFamily = family_utf.utf8_str();
if (m_answer == a_OK)
{
if(!m_sFontFamily.empty())
{
if((g_ascii_strcasecmp(szFontFamily, m_sFontFamily.c_str()) != 0))
{
m_bChangedFontFamily = true;
m_sFontFamily = szFontFamily;
}
}
else
{
if(szFontFamily[0])
{
m_bChangedFontFamily = true;
m_sFontFamily = szFontFamily;
}
}
bool bIsSizeValid = ((cf.Flags & CF_NOSIZESEL) == 0);
bool bWasSizeValid = !m_sFontSize.empty();
char bufSize[10];
if (bIsSizeValid)
sprintf(bufSize,"%dpt",(cf.iPointSize/10));
else
bufSize[0] = 0;
// why? let's see
if (bIsSizeValid && (g_ascii_strcasecmp(bufSize,m_sFontSize.c_str()) != 0))
{
m_bChangedFontSize = true;
m_sFontSize = bufSize;
}
else
{
/* nothing changed */
}
bool bIsBold = ((cf.nFontType & BOLD_FONTTYPE) != 0);
bool bWasBold = (g_ascii_strcasecmp(m_sFontWeight.c_str(),"bold") == 0);
bool bIsNormal = ((cf.nFontType & REGULAR_FONTTYPE) != 0);
bool bWasNormal = (m_sFontWeight.empty() || (g_ascii_strcasecmp(m_sFontWeight.c_str(),"normal") != 0));
if ((bIsBold != bWasBold) || (bIsNormal != bWasNormal))
{
m_bChangedFontWeight = true;
if( bIsBold )
m_sFontWeight = "bold";
else
m_sFontWeight = "normal";
}
bool bIsItalic = ((cf.nFontType & ITALIC_FONTTYPE) != 0);
bool bWasItalic = (g_ascii_strcasecmp(m_sFontStyle.c_str(),"italic") == 0);
if (bIsItalic != bWasItalic)
{
m_bChangedFontStyle = true;
if( bIsItalic )
m_sFontStyle = "italic";
else
m_sFontStyle = "normal";
}
char bufColor[10];
sprintf(bufColor,"%02x%02x%02x",GetRValue(cf.rgbColors),
GetGValue(cf.rgbColors),GetBValue(cf.rgbColors));
bool bWasColorValid = !m_sColor.empty();
if ( m_bChangedColor && ((bWasColorValid && (g_ascii_strcasecmp(bufColor,m_sColor.c_str()) != 0))
|| (!bWasColorValid && (g_ascii_strcasecmp(bufColor,"000000") != 0))))
{
m_sColor = bufColor;
}
m_bChangedUnderline = ((lf.lfUnderline == TRUE) != m_bUnderline);
m_bChangedStrikeOut = ((lf.lfStrikeOut == TRUE) != m_bStrikeout);
m_bChangedOverline = (m_bWin32Overline != m_bOverline);
if (m_bChangedUnderline ||
m_bChangedStrikeOut ||
m_bChangedOverline)
setFontDecoration( (lf.lfUnderline == TRUE),
m_bWin32Overline,
(lf.lfStrikeOut == TRUE), NULL, NULL);
m_bChangedHidden = (m_bWin32Hidden != m_bHidden);
m_bChangedSuperScript = (m_bWin32SuperScript != m_bSuperScript);
m_bChangedSubScript = (m_bWin32SubScript != m_bSubScript);
if(m_bChangedHidden)
setHidden(m_bWin32Hidden);
if(m_bChangedSuperScript)
setSuperScript(m_bWin32SuperScript);
if(m_bChangedSubScript)
setSubScript(m_bWin32SubScript);
}
UT_DEBUGMSG(("FontChooserEnd: Family[%s%s] Size[%s%s] Weight[%s%s] Style[%s%s] Color[%s%s] Underline[%d%s] StrikeOut[%d%s]\n",
m_sFontFamily.c_str(), ((m_bChangedFontFamily) ? "(chg)" : ""),
m_sFontSize.c_str(), ((m_bChangedFontSize) ? "(chg)" : ""),
m_sFontWeight.c_str(), ((m_bChangedFontWeight) ? "(chg)" : ""),
m_sFontStyle.c_str(), ((m_bChangedFontStyle) ? "(chg)" : ""),
m_sColor.c_str(), ((m_bChangedColor) ? "(chg)" : ""),
m_bUnderline, ((m_bChangedUnderline) ? "(chg)" : ""),
m_bStrikeout, ((m_bChangedStrikeOut) ? "(chg)" : "")));
// the caller can get the answer from getAnswer().
m_pWin32Frame = NULL;
}
BOOL AP_Win32Dialog_ListRevisions::_onInitDialog(HWND hWnd, WPARAM /*wParam*/, LPARAM /*lParam*/)
{
const XAP_StringSet * pSS = m_pApp->getStringSet();
setDialogTitle (getTitle());
// localize controls
_DSX(BTN_OK, DLG_OK);
_DSX(BTN_CANCEL, DLG_Cancel);
setDlgItemText(AP_RID_DIALOG_LIST_REVISIONS_FRAME,getLabel1());
// set the column headings
HWND h = GetDlgItem(hWnd, AP_RID_DIALOG_LIST_REVISIONS_LIST);
LVCOLUMNW col;
UT_Win32LocaleString str;
col.mask = LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH;
int col_hdr[3]={AP_STRING_ID_DLG_ListRevisions_Column1Label,
AP_STRING_ID_DLG_ListRevisions_Column2Label,
AP_STRING_ID_DLG_ListRevisions_Column3Label};
int col_wid[3]={80,160,230};
for (int i=0; i<3; i++) {
col.iSubItem = i;
col.cx = col_wid[i];
str.fromUTF8(pSS->getValue(col_hdr[i]));
col.pszText = (LPWSTR) str.c_str();
SendMessageW(h, LVM_INSERTCOLUMNW, i, (LPARAM)&col);
}
ListView_SetItemCount(h, getItemCount());
LVITEMW item;
item.state = 0;
item.stateMask = 0;
item.iImage = 0;
WCHAR buf[60];
const char *tmp;
item.pszText = buf;
for(UT_uint32 i = 0; i < getItemCount(); i++)
{
wsprintfW(buf,L"%d",getNthItemId(i));
item.pszText = buf;
item.iItem = i;
item.iSubItem = 0;
item.lParam = getNthItemId(i);
item.mask = LVIF_TEXT | LVIF_PARAM;
SendMessageW(h, LVM_INSERTITEMW, 0, (LPARAM)&item);
item.iSubItem = 1;
tmp=getNthItemTime(i);
if (tmp) {
str.fromASCII(tmp,-1);
item.pszText = (LPWSTR) str.c_str();
} else {
item.pszText = L"";
}
item.mask = LVIF_TEXT;
SendMessageW(h, LVM_SETITEMW, 0, (LPARAM)&item);
item.iSubItem = 2;
str.fromUTF8(getNthItemText(i));
item.pszText = (LPWSTR) str.c_str();
item.mask = LVIF_TEXT;
SendMessageW(h, LVM_SETITEMW, 0, (LPARAM)&item);
}
SendMessageW(h, LVM_SETEXTENDEDLISTVIEWSTYLE, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
centerDialog();
return 1; // 1 == we did not call SetFocus()
}
void XAP_Win32Slurp::stuffRegistry(const char * szSuffix,
const char * szApplicationName,
LPCWSTR szExePathname,
const char * szContentType)
{
// load the system registry if there's no info
// for us already present for the given suffix.
// we assume that the string contains the dot.
//
// TODO consider raising a dialog asking if they
// TODO want us to override any existing settings
// TODO if they currently don't point to us. like
// TODO MSFT and NSCP currently (politely) fight
// TODO for the .html suffix....
//
// we construct the following pattern in the registry:
//
// HKEY_CLASSES_ROOT\<suffix> = <foo>
// HKEY_CLASSES_ROOT\<suffix>\Content Type = <content_type>
// HKEY_CLASSES_ROOT\<foo> = <application_name> ## " Document"
// HKEY_CLASSES_ROOT\<foo>\shell\open\command = <exe_pathname>
// HKEY_CLASSES_ROOT\<foo>\shell\open\ddeexec = [Open("%1")]
// HKEY_CLASSES_ROOT\<foo>\shell\open\ddeexec\application = <application_name>
// HKEY_CLASSES_ROOT\<foo>\shell\open\ddeexec\topic = System
// HKEY_CLASSES_ROOT\<foo>\DefaultIcon = <exe_pathname,2>
#define VALUE_DDEEXEC_OPEN "[Open(\"%1\")]"
#define FORMAT_OUR_INDIRECTION "AbiSuite.%s"
#define CONTENT_TYPE_KEY "Content Type"
#define DOCUMENT_ICON_POSITION 2
#define xx(s) ((LPBYTE)(s)),(strlen(s)+1)
#define xxw(s) ((LPBYTE)(s)),((lstrlenW(s)+1)<<1)
char buf[1024];
char bufOurFoo[1024];
WCHAR bufOurFooValue[1024];
WCHAR bufDefaultIconValue[1024];
DWORD dType;
LONG eResult;
ULONG len;
bool bUpdateContentType;
bool bCreateOrOverwrite = false;
HKEY hKeyFoo = 0;
HKEY hKeySuffix = 0;
HKEY hKeyShell = 0;
HKEY hKeyCommand = 0;
HKEY hKeyOpen = 0;
HKEY hKeyDdeExec = 0;
HKEY hKeyApplication = 0;
HKEY hKeyTopic = 0;
HKEY hKeyDefaultIcon = 0;
sprintf(bufOurFoo,"AbiSuite.%s",szApplicationName);
strtok(bufOurFoo," "); // trim key at first whitespace
const XAP_StringSet *pSS = XAP_App::getApp()->getStringSet();
const gchar *pStr = "%s Document";
UT_Win32LocaleString tmpl;
char tdbuf[512];
sprintf(tdbuf,pStr,szApplicationName);
tmpl.fromUTF8(tdbuf);
wcscpy(bufOurFooValue,tmpl.c_str());
///////////////////////////////////////////////////////////////////
// See if someone has claimed this suffix.
// HKEY_CLASSES_ROOT\<suffix> = <foo>
///////////////////////////////////////////////////////////////////
switch ( _fetchKey(HKEY_CLASSES_ROOT,szSuffix,&hKeySuffix) )
{
case X_Error:
goto CleanupMess;
case X_CreatedKey: // we are free to create what we want.
bCreateOrOverwrite = true;
break;
case X_ExistingKey: // see what's already there
{
///////////////////////////////////////////////////////////////////
// HKEY_CLASSES_ROOT\<suffix> = <foo>
// was already present. Verify the value.
///////////////////////////////////////////////////////////////////
len = G_N_ELEMENTS(buf);
eResult = RegQueryValueEx(hKeySuffix,NULL,NULL,&dType,(LPBYTE)buf,&len);
if ((eResult != ERROR_SUCCESS) || (dType != REG_SZ) || (len==0))
break; // bogus data, overwrite it.
UT_DEBUGMSG(("Registry: suffix [HKEY_CLASSES_ROOT\\%s] --> [%s]\n",
szSuffix,buf));
if (g_ascii_strcasecmp(buf,bufOurFoo) != 0) // we didn't create this so ask first.
{
if (!_askForStealFromAnotherApplication())
goto CleanupMess;
bCreateOrOverwrite = true;
break;
}
}
}
if (bCreateOrOverwrite)
{
///////////////////////////////////////////////////////////////////
// Set the value <foo> in
// HKEY_CLASSES_ROOT\<suffix> = <foo>
///////////////////////////////////////////////////////////////////
UT_ASSERT(hKeySuffix);
eResult = RegSetValueEx(hKeySuffix,NULL,0,REG_SZ,xx(bufOurFoo));
UT_DEBUGMSG(("Register: HKEY_CLASSES_ROOT\\%s <-- %s [error %d]\n",
szSuffix,bufOurFoo,eResult));
if (eResult != ERROR_SUCCESS)
goto CleanupMess;
}
///////////////////////////////////////////////////////////////////
// See if "HKEY_CLASSES_ROOT\<suffix>\Content Type" is present
// as a value under the current key.
///////////////////////////////////////////////////////////////////
bUpdateContentType = true;
len = G_N_ELEMENTS(buf);
eResult = RegQueryValueEx(hKeySuffix,CONTENT_TYPE_KEY,NULL,&dType,(LPBYTE)buf,&len);
if ((eResult == ERROR_SUCCESS) && (dType == REG_SZ))
{
UT_DEBUGMSG(("Registry: Existing ContentType [%s]\n",buf));
if (g_ascii_strcasecmp(buf,szContentType) == 0)
bUpdateContentType = false;
else // we didn't create this so ask first.
bUpdateContentType = (_askForStealMimeFromAnotherApplication());
}
if (bUpdateContentType) // bogus or stale data, overwrite it.
{
///////////////////////////////////////////////////////////////////
// Set the value <content_type> in
// HKEY_CLASSES_ROOT\<suffix>\Content Type = <content_type>
///////////////////////////////////////////////////////////////////
UT_ASSERT(hKeySuffix);
eResult = RegSetValueEx(hKeySuffix,CONTENT_TYPE_KEY,0,REG_SZ,xx(szContentType));
UT_DEBUGMSG(("Register: HKEY_CLASSES_ROOT\\%s\\Content Type <-- %s [error %d]\n",
szSuffix,szContentType,eResult));
// content-type is not a critical field, so if it fails we just go on.
// if (eResult != ERROR_SUCCESS) goto CleanupMess;
}
///////////////////////////////////////////////////////////////////
// Verify that the suffix indirection is defined.
// HKEY_CLASSES_ROOT\<foo> = ...
///////////////////////////////////////////////////////////////////
switch ( _fetchKey(HKEY_CLASSES_ROOT,bufOurFoo,&hKeyFoo) )
{
case X_Error:
goto CleanupMess;
case X_ExistingKey:
UT_ASSERT(hKeyFoo);
len = G_N_ELEMENTS(buf);
eResult = RegQueryValueExW(hKeyFoo,NULL,0,&dType,(LPBYTE)buf,&len);
if ((eResult==ERROR_SUCCESS) && (dType==REG_SZ) && (lstrcmpiW((LPCWSTR)buf,bufOurFooValue)==0))
break; // already has correct value, no need to overwrite.
/* otherwise, replace the value */
/* fall thru intended */
case X_CreatedKey:
UT_ASSERT(hKeyFoo);
eResult = RegSetValueExW(hKeyFoo,NULL,0,REG_SZ,xxw(bufOurFooValue));
if (eResult != ERROR_SUCCESS)
goto CleanupMess;
break;
}
///////////////////////////////////////////////////////////////////
// Inspect the command path
// HKEY_CLASSES_ROOT\<foo>\shell\open\command = <exe_pathname>
///////////////////////////////////////////////////////////////////
WCHAR commandPathWithParam[1024];
wcscpy ( commandPathWithParam, szExePathname );
wcscat ( commandPathWithParam, L" \"%1\"" );
if (_fetchKey(hKeyFoo,"shell",&hKeyShell) == X_Error)
goto CleanupMess;
if (_fetchKey(hKeyShell,"open",&hKeyOpen) == X_Error)
goto CleanupMess;
switch ( _fetchKey(hKeyOpen,"command",&hKeyCommand) )
{
case X_Error:
goto CleanupMess;
case X_ExistingKey:
UT_ASSERT(hKeyCommand);
len = G_N_ELEMENTS((LPWSTR)buf);
eResult = RegQueryValueExW(hKeyCommand,NULL,0,&dType,(LPBYTE)buf,&len);
if ((eResult==ERROR_SUCCESS) && (dType==REG_SZ))
{
if (lstrcmpiW((LPCWSTR)buf,commandPathWithParam) == 0)
break; // already has correct value, no need to overwrite.
if(memcmp(buf, commandPathWithParam, lstrlenW(commandPathWithParam)<<1) == 0)
{
// Path name is the same but has extra at the end.
// Probably "%1"
// Fall throught to update path name.
}
else
{
if (!_askForUpdateExePathname())
goto CleanupMess;
}
}
/* otherwise, replace the value */
/* fall thru intended */
case X_CreatedKey:
UT_ASSERT(hKeyCommand);
eResult = RegSetValueExW(hKeyCommand,NULL,0,REG_SZ,xxw(commandPathWithParam));
if (eResult != ERROR_SUCCESS)
goto CleanupMess;
break;
}
///////////////////////////////////////////////////////////////////
// Inspect the ddeexec key
// HKEY_CLASSES_ROOT\<foo>\shell\open\ddeexec = [Open(%1)]
///////////////////////////////////////////////////////////////////
switch ( _fetchKey(hKeyOpen,"ddeexec",&hKeyDdeExec) )
{
case X_Error:
goto CleanupMess;
case X_ExistingKey:
UT_ASSERT(hKeyDdeExec);
len = G_N_ELEMENTS(buf);
eResult = RegQueryValueEx(hKeyDdeExec,NULL,0,&dType,(LPBYTE)buf,&len);
if ((eResult==ERROR_SUCCESS) && (dType==REG_SZ) && (g_ascii_strcasecmp(buf,VALUE_DDEEXEC_OPEN)==0))
break; // already has correct value, no need to overwrite.
/* otherwise, replace the value */
/* fall thru intended */
case X_CreatedKey:
UT_ASSERT(hKeyDdeExec);
eResult = RegSetValueEx(hKeyDdeExec,NULL,0,REG_SZ,xx(VALUE_DDEEXEC_OPEN));
if (eResult != ERROR_SUCCESS)
goto CleanupMess;
break;
}
///////////////////////////////////////////////////////////////////
// Inspect the application key
// HKEY_CLASSES_ROOT\<foo>\shell\open\ddeexec\application = <application_name>
///////////////////////////////////////////////////////////////////
switch ( _fetchKey(hKeyDdeExec,"application",&hKeyApplication) )
{
case X_Error:
goto CleanupMess;
case X_ExistingKey:
UT_ASSERT(hKeyApplication);
len = G_N_ELEMENTS(buf);
eResult = RegQueryValueEx(hKeyApplication,NULL,0,&dType,(LPBYTE)buf,&len);
if ((eResult==ERROR_SUCCESS) && (dType==REG_SZ) && (g_ascii_strcasecmp(buf,szApplicationName)==0))
break; // already has correct value, no need to overwrite.
/* otherwise, replace the value */
/* fall thru intended */
case X_CreatedKey:
UT_ASSERT(hKeyApplication);
eResult = RegSetValueEx(hKeyApplication,NULL,0,REG_SZ,xx(szApplicationName));
if (eResult != ERROR_SUCCESS)
goto CleanupMess;
break;
}
///////////////////////////////////////////////////////////////////
// Inspect the topic key
// HKEY_CLASSES_ROOT\<foo>\shell\open\ddeexec\topic = System
///////////////////////////////////////////////////////////////////
switch ( _fetchKey(hKeyDdeExec,"topic",&hKeyTopic) )
{
case X_Error:
goto CleanupMess;
case X_ExistingKey:
UT_ASSERT(hKeyTopic);
len = G_N_ELEMENTS((LPWSTR)buf);
eResult = RegQueryValueExW(hKeyTopic,NULL,0,&dType,(LPBYTE)buf,&len);
if ((eResult==ERROR_SUCCESS) && (dType==REG_SZ) && (wcsicmp((LPWSTR)buf,MY_DDE_TOPICNAME)==0))
break; // already has correct value, no need to overwrite.
/* otherwise, replace the value */
/* fall thru intended */
case X_CreatedKey:
UT_ASSERT(hKeyTopic);
eResult = RegSetValueExW(hKeyTopic,NULL,0,REG_SZ,xxw(MY_DDE_TOPICNAME));
if (eResult != ERROR_SUCCESS)
goto CleanupMess;
break;
}
///////////////////////////////////////////////////////////////////
// Set the default icon for the suffix (this is for Explorer et al.
// HKEY_CLASSES_ROOT\<foo>\DefaultIcon = <exe_pathname,2>
///////////////////////////////////////////////////////////////////
wsprintfW(bufDefaultIconValue,L"%s,%d",szExePathname,DOCUMENT_ICON_POSITION);
switch ( _fetchKey(hKeyFoo,"DefaultIcon",&hKeyDefaultIcon) )
{
case X_Error:
goto CleanupMess;
case X_ExistingKey:
UT_ASSERT(hKeyDefaultIcon);
len = G_N_ELEMENTS((LPWSTR)buf);
eResult = RegQueryValueExW(hKeyDefaultIcon,NULL,0,&dType,(LPBYTE)buf,&len);
if ((eResult==ERROR_SUCCESS) && (dType==REG_SZ) && (lstrcmpiW((LPWSTR)buf,bufDefaultIconValue)==0))
break; // already has correct value, no need to overwrite.
/* otherwise, replace the value */
/* fall thru intended */
case X_CreatedKey:
UT_ASSERT(hKeyDefaultIcon);
eResult = RegSetValueExW(hKeyDefaultIcon,NULL,0,REG_SZ,xxw(bufDefaultIconValue));
if (eResult != ERROR_SUCCESS)
goto CleanupMess;
break;
}
///////////////////////////////////////////////////////////////////
// Success.
///////////////////////////////////////////////////////////////////
UT_DEBUGMSG(("Successfully stuffed the registry for suffix [%s].\n",szSuffix));
CleanupMess:
#define KILLKEY(k) do { if (k) RegCloseKey(k); (k) = 0; } while (0)
KILLKEY(hKeyFoo);
KILLKEY(hKeySuffix);
KILLKEY(hKeyShell);
KILLKEY(hKeyCommand);
KILLKEY(hKeyOpen);
KILLKEY(hKeyDdeExec);
KILLKEY(hKeyApplication);
KILLKEY(hKeyTopic);
KILLKEY(hKeyDefaultIcon);
return;
}
