registry.c File Reference

#include <windows.h>
#include <shlobj.h>
#include <richedit.h>
#include "wordpad.h"

Include dependency graph for registry.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS
#define	WIN32_LEAN_AND_MEAN

Functions
static LRESULT	registry_get_handle (HKEY *hKey, LPDWORD action, LPCWSTR subKey)
void	registry_set_options (HWND hMainWnd)
void	registry_read_winrect (RECT *rc)
void	registry_read_maximized (DWORD *bMaximized)
static void	truncate_path (LPWSTR file, LPWSTR out, LPWSTR pos1, LPWSTR pos2)
static void	format_filelist_filename (LPWSTR file, LPWSTR out)
void	registry_read_filelist (HWND hMainWnd)
void	registry_set_filelist (LPCWSTR newFile, HWND hMainWnd)
int	reg_formatindex (WPARAM format)
void	registry_read_options (void)
static void	registry_read_formatopts (int index, LPCWSTR key, DWORD barState[], DWORD wordWrap[])
void	registry_read_formatopts_all (DWORD barState[], DWORD wordWrap[])
static void	registry_set_formatopts (int index, LPCWSTR key, DWORD barState[], DWORD wordWrap[])
void	registry_set_formatopts_all (DWORD barState[], DWORD wordWrap[])

Variables
static const WCHAR	key_recentfiles []
static const WCHAR	key_options [] = {'O','p','t','i','o','n','s',0}
static const WCHAR	key_settings [] = {'S','e','t','t','i','n','g','s',0}
static const WCHAR	key_rtf [] = {'R','T','F',0}
static const WCHAR	key_text [] = {'T','e','x','t',0}
static const WCHAR	var_file [] = {'F','i','l','e','%','d',0}
static const WCHAR	var_framerect [] = {'F','r','a','m','e','R','e','c','t',0}
static const WCHAR	var_barstate0 [] = {'B','a','r','S','t','a','t','e','0',0}
static const WCHAR	var_wrap [] = {'W','r','a','p',0}
static const WCHAR	var_maximized [] = {'M','a','x','i','m','i','z','e','d',0}

Macro Definition Documentation

WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 22 of file registry.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 21 of file registry.c.

Function Documentation

format_filelist_filename()

static void format_filelist_filename ( LPWSTR  file, LPWSTR  out  )

static

Definition at line 150 of file registry.c.

{
    LPWSTR pos_basename;
    LPWSTR truncpos1, truncpos2;
    WCHAR myDocs[MAX_PATH];
 
    SHGetFolderPathW(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, myDocs);
    pos_basename = file_basename(file);
    truncpos1 = NULL;
    truncpos2 = NULL;
 
    *(pos_basename-1) = 0;
    if(!lstrcmpiW(file, myDocs) || (lstrlenW(pos_basename) > FILELIST_ENTRY_LENGTH))
    {
        truncpos1 = pos_basename;
        *(pos_basename-1) = '\\';
    } else
    {
        LPWSTR pos;
        BOOL morespace = FALSE;
 
        *(pos_basename-1) = '\\';
 
        for(pos = file; pos < pos_basename; pos++)
        {
            if(*pos == '\\' || *pos == '/')
            {
                if(truncpos1)
                {
                    if((pos - file + lstrlenW(pos_basename)) > FILELIST_ENTRY_LENGTH)
                        break;
 
                    truncpos1 = pos;
                    morespace = TRUE;
                    break;
                }
 
                if((pos - file + lstrlenW(pos_basename)) > FILELIST_ENTRY_LENGTH)
                    break;
 
                truncpos1 = pos;
            }
        }
 
        if(morespace)
        {
            for(pos = pos_basename; pos >= truncpos1; pos--)
            {
                if(*pos == '\\' || *pos == '/')
                {
                    if((truncpos1 - file + lstrlenW(pos_basename) + pos_basename - pos) > FILELIST_ENTRY_LENGTH)
                        break;
 
                    truncpos2 = pos;
                }
            }
        }
    }
 
    if(truncpos1 == pos_basename)
        lstrcatW(out, pos_basename);
    else if(truncpos1 == truncpos2 || !truncpos2)
        lstrcatW(out, file);
    else
        truncate_path(file, out, truncpos1, truncpos2);
}

Referenced by registry_read_filelist().

reg_formatindex()

int reg_formatindex

(

WPARAM

format

)

Definition at line 330 of file registry.c.

{
    return (format & SF_TEXT) ? 1 : 0;
}

Referenced by dialog_viewproperties(), is_bar_visible(), OnCommand(), registry_read_formatopts(), registry_read_formatopts_all(), registry_set_formatopts_all(), set_fileformat(), store_bar_state(), and WinMain().

registry_get_handle()

static LRESULT registry_get_handle ( HKEY *  hKey, LPDWORD  action, LPCWSTR  subKey  )

static

Definition at line 42 of file registry.c.

{
    LONG ret;
    static const WCHAR wszProgramKey[] = {'S','o','f','t','w','a','r','e','\\',
        'M','i','c','r','o','s','o','f','t','\\',
        'W','i','n','d','o','w','s','\\',
        'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
        'A','p','p','l','e','t','s','\\',
        'W','o','r','d','p','a','d',0};
        LPWSTR key = (LPWSTR)wszProgramKey;
 
        if(subKey)
        {
            WCHAR backslash[] = {'\\',0};
            key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                            (lstrlenW(wszProgramKey)+lstrlenW(subKey)+lstrlenW(backslash)+1)
                                    *sizeof(WCHAR));
 
            if(!key)
                return 1;
 
            lstrcpyW(key, wszProgramKey);
            lstrcatW(key, backslash);
            lstrcatW(key, subKey);
        }
 
        if(action)
        {
            ret = RegCreateKeyExW(HKEY_CURRENT_USER, key, 0, NULL, REG_OPTION_NON_VOLATILE,
                                  KEY_READ | KEY_WRITE, NULL, hKey, action);
        } else
        {
            ret = RegOpenKeyExW(HKEY_CURRENT_USER, key, 0, KEY_READ | KEY_WRITE, hKey);
        }
 
        if(subKey)
            HeapFree(GetProcessHeap(), 0, key);
 
        return ret;
}

Referenced by registry_read_filelist(), registry_read_formatopts(), registry_read_maximized(), registry_read_options(), registry_read_winrect(), registry_set_filelist(), registry_set_formatopts(), and registry_set_options().

registry_read_filelist()

void registry_read_filelist

(

HWND

hMainWnd

)

Definition at line 217 of file registry.c.

{
    HKEY hFileKey;
 
    if(registry_get_handle(&hFileKey, 0, key_recentfiles) == ERROR_SUCCESS)
    {
        WCHAR itemText[MAX_PATH+3], buffer[MAX_PATH];
        /* The menu item name is not the same as the file name, so we need to store
        the file name here */
        static WCHAR file1[MAX_PATH], file2[MAX_PATH], file3[MAX_PATH], file4[MAX_PATH];
        WCHAR numFormat[] = {'&','%','d',' ',0};
        LPWSTR pFile[] = {file1, file2, file3, file4};
        DWORD pathSize = MAX_PATH*sizeof(WCHAR);
        int i;
        WCHAR key[6];
        MENUITEMINFOW mi;
        HMENU hMenu = GetMenu(hMainWnd);
 
        mi.cbSize = sizeof(MENUITEMINFOW);
        mi.fMask = MIIM_ID | MIIM_DATA | MIIM_STRING | MIIM_FTYPE;
        mi.fType = MFT_STRING;
        mi.dwTypeData = itemText;
        mi.wID = ID_FILE_RECENT1;
 
        RemoveMenu(hMenu, ID_FILE_RECENT_SEPARATOR, MF_BYCOMMAND);
        for(i = 0; i < FILELIST_ENTRIES; i++)
        {
            wsprintfW(key, var_file, i+1);
            RemoveMenu(hMenu, ID_FILE_RECENT1+i, MF_BYCOMMAND);
            if(RegQueryValueExW(hFileKey, (LPWSTR)key, 0, NULL, (LPBYTE)pFile[i], &pathSize)
               != ERROR_SUCCESS)
                break;
 
            mi.dwItemData = (ULONG_PTR)pFile[i];
            wsprintfW(itemText, numFormat, i+1);
 
            lstrcpyW(buffer, pFile[i]);
 
            format_filelist_filename(buffer, itemText);
 
            InsertMenuItemW(hMenu, ID_FILE_EXIT, FALSE, &mi);
            mi.wID++;
            pathSize = MAX_PATH*sizeof(WCHAR);
        }
        mi.fType = MFT_SEPARATOR;
        mi.fMask = MIIM_FTYPE | MIIM_ID;
        InsertMenuItemW(hMenu, ID_FILE_EXIT, FALSE, &mi);
 
        RegCloseKey(hFileKey);
    }
}

Referenced by OnCreate(), preview_exit(), and registry_set_filelist().

registry_read_formatopts()

static void registry_read_formatopts ( int  index, LPCWSTR  key, DWORD  barState[], DWORD  wordWrap[]  )

static

Definition at line 355 of file registry.c.

{
    HKEY hKey;
    DWORD action = 0;
    BOOL fetched = FALSE;
    barState[index] = 0;
    wordWrap[index] = 0;
 
    if(registry_get_handle(&hKey, &action, key) != ERROR_SUCCESS)
        return;
 
    if(action == REG_OPENED_EXISTING_KEY)
    {
        DWORD size = sizeof(DWORD);
 
        if(RegQueryValueExW(hKey, var_barstate0, 0, NULL, (LPBYTE)&barState[index],
           &size) == ERROR_SUCCESS)
            fetched = TRUE;
    }
 
    if(!fetched)
        barState[index] = (1 << BANDID_TOOLBAR) | (1 << BANDID_FORMATBAR) | (1 << BANDID_RULER) | (1 << BANDID_STATUSBAR);
 
    fetched = FALSE;
    if(action == REG_OPENED_EXISTING_KEY)
    {
        DWORD size = sizeof(DWORD);
        if(RegQueryValueExW(hKey, var_wrap, 0, NULL, (LPBYTE)&wordWrap[index],
           &size) == ERROR_SUCCESS)
            fetched = TRUE;
    }
 
    if (!fetched)
    {
        if(index == reg_formatindex(SF_RTF))
            wordWrap[index] = ID_WORDWRAP_WINDOW;
        else if(index == reg_formatindex(SF_TEXT))
            wordWrap[index] = ID_WORDWRAP_NONE;
    }
 
    RegCloseKey(hKey);
}

Referenced by registry_read_formatopts_all().

registry_read_formatopts_all()

void registry_read_formatopts_all	(	DWORD	barState[],
		DWORD	wordWrap[]
	)

Definition at line 398 of file registry.c.

{
    registry_read_formatopts(reg_formatindex(SF_RTF), key_rtf, barState, wordWrap);
    registry_read_formatopts(reg_formatindex(SF_TEXT), key_text, barState, wordWrap);
}

Referenced by OnCreate().

registry_read_maximized()

void registry_read_maximized

(

DWORD *

bMaximized

)

Definition at line 124 of file registry.c.

{
    HKEY hKey = 0;
    DWORD size = sizeof(DWORD);
 
    if(registry_get_handle(&hKey, 0, key_options) != ERROR_SUCCESS ||
       RegQueryValueExW(hKey, var_maximized, 0, NULL, (LPBYTE)bMaximized, &size) !=
       ERROR_SUCCESS || size != sizeof(DWORD))
    {
        *bMaximized = FALSE;
    }
 
    RegCloseKey(hKey);
}

Referenced by WinMain().

registry_read_options()

void registry_read_options

(

void

)

Definition at line 335 of file registry.c.

{
    HKEY hKey;
 
    if(registry_get_handle(&hKey, 0, key_options) != ERROR_SUCCESS)
        registry_read_pagemargins(NULL);
    else
    {
        registry_read_pagemargins(hKey);
        RegCloseKey(hKey);
    }
 
    if(registry_get_handle(&hKey, 0, key_settings) != ERROR_SUCCESS) {
        registry_read_previewpages(NULL);
    } else {
        registry_read_previewpages(hKey);
        RegCloseKey(hKey);
    }
}

Referenced by OnCreate().

registry_read_winrect()

void registry_read_winrect

(

RECT *

rc

)

Definition at line 111 of file registry.c.

{
    HKEY hKey = 0;
    DWORD size = sizeof(RECT);
 
    if(registry_get_handle(&hKey, 0, key_options) != ERROR_SUCCESS ||
       RegQueryValueExW(hKey, var_framerect, 0, NULL, (LPBYTE)rc, &size) !=
       ERROR_SUCCESS || size != sizeof(RECT))
        SetRect(rc, 0, 0, 600, 300);
 
    RegCloseKey(hKey);
}

Referenced by WinMain().

registry_set_filelist()

void registry_set_filelist	(	LPCWSTR	newFile,
		HWND	hMainWnd
	)

Definition at line 269 of file registry.c.

{
    HKEY hKey;
    DWORD action;
 
    if(registry_get_handle(&hKey, &action, key_recentfiles) == ERROR_SUCCESS)
    {
        LPCWSTR pFiles[FILELIST_ENTRIES];
        int i;
        HMENU hMenu = GetMenu(hMainWnd);
        MENUITEMINFOW mi;
        WCHAR buffer[6];
 
        mi.cbSize = sizeof(MENUITEMINFOW);
        mi.fMask = MIIM_DATA;
 
        for(i = 0; i < FILELIST_ENTRIES; i++)
            pFiles[i] = NULL;
 
        for(i = 0; GetMenuItemInfoW(hMenu, ID_FILE_RECENT1+i, FALSE, &mi); i++)
            pFiles[i] = (LPWSTR)mi.dwItemData;
 
        if(lstrcmpiW(newFile, pFiles[0]))
        {
            for(i = 0; i < FILELIST_ENTRIES && pFiles[i]; i++)
            {
                if(!lstrcmpiW(pFiles[i], newFile))
                {
                    int j;
                    for(j = 0; j < i; j++)
                    {
                        pFiles[i-j] = pFiles[i-j-1];
                    }
                    pFiles[0] = NULL;
                    break;
                }
            }
 
            if(!pFiles[0])
            {
                pFiles[0] = newFile;
            } else
            {
                for(i = 0; i < FILELIST_ENTRIES-1; i++)
                    pFiles[FILELIST_ENTRIES-1-i] = pFiles[FILELIST_ENTRIES-2-i];
 
                pFiles[0] = newFile;
            }
 
            for(i = 0; i < FILELIST_ENTRIES && pFiles[i]; i++)
            {
                wsprintfW(buffer, var_file, i+1);
                RegSetValueExW(hKey, (LPWSTR)&buffer, 0, REG_SZ, (const BYTE*)pFiles[i],
                               (lstrlenW(pFiles[i])+1)*sizeof(WCHAR));
            }
        }
        RegCloseKey(hKey);
    }
    registry_read_filelist(hMainWnd);
}

Referenced by DoOpenFile().

registry_set_formatopts()

static void registry_set_formatopts ( int  index, LPCWSTR  key, DWORD  barState[], DWORD  wordWrap[]  )

static

Definition at line 404 of file registry.c.

{
    HKEY hKey;
    DWORD action = 0;
 
    if(registry_get_handle(&hKey, &action, key) == ERROR_SUCCESS)
    {
        RegSetValueExW(hKey, var_barstate0, 0, REG_DWORD, (LPBYTE)&barState[index],
                       sizeof(DWORD));
        RegSetValueExW(hKey, var_wrap, 0, REG_DWORD, (LPBYTE)&wordWrap[index],
                       sizeof(DWORD));
        RegCloseKey(hKey);
    }
}

Referenced by registry_set_formatopts_all().

registry_set_formatopts_all()

void registry_set_formatopts_all	(	DWORD	barState[],
		DWORD	wordWrap[]
	)

Definition at line 419 of file registry.c.

{
    registry_set_formatopts(reg_formatindex(SF_RTF), key_rtf, barState, wordWrap);
    registry_set_formatopts(reg_formatindex(SF_TEXT), key_text, barState, wordWrap);
}

Referenced by WndProc().

registry_set_options()

void registry_set_options

(

HWND

hMainWnd

)

Definition at line 83 of file registry.c.

{
    HKEY hKey = 0;
    DWORD action;
 
    if(registry_get_handle(&hKey, &action, key_options) == ERROR_SUCCESS)
    {
        WINDOWPLACEMENT wp;
        DWORD isMaximized;
 
        wp.length = sizeof(WINDOWPLACEMENT);
        GetWindowPlacement(hMainWnd, &wp);
        isMaximized = (wp.showCmd == SW_SHOWMAXIMIZED);
 
        RegSetValueExW(hKey, var_framerect, 0, REG_BINARY, (LPBYTE)&wp.rcNormalPosition, sizeof(RECT));
        RegSetValueExW(hKey, var_maximized, 0, REG_DWORD, (LPBYTE)&isMaximized, sizeof(DWORD));
 
        registry_set_pagemargins(hKey);
        RegCloseKey(hKey);
    }
 
    if(registry_get_handle(&hKey, &action, key_settings) == ERROR_SUCCESS)
    {
        registry_set_previewpages(hKey);
        RegCloseKey(hKey);
    }
}

Referenced by WndProc().

truncate_path()

static void truncate_path ( LPWSTR  file, LPWSTR  out, LPWSTR  pos1, LPWSTR  pos2  )

static

Definition at line 139 of file registry.c.

{
    static const WCHAR dots[] = {'.','.','.',0};
 
    *++pos1 = 0;
 
    lstrcatW(out, file);
    lstrcatW(out, dots);
    lstrcatW(out, pos2);
}

Referenced by format_filelist_filename().

Variable Documentation

key_options

const WCHAR key_options[] = {'O','p','t','i','o','n','s',0}

static

Definition at line 31 of file registry.c.

Referenced by registry_read_maximized(), registry_read_options(), registry_read_winrect(), and registry_set_options().

key_recentfiles

const WCHAR key_recentfiles[]

static

Initial value:

= {'R','e','c','e','n','t',' ','f','i','l','e',
                                        ' ','l','i','s','t',0}

Definition at line 29 of file registry.c.

Referenced by registry_read_filelist(), and registry_set_filelist().

key_rtf

const WCHAR key_rtf[] = {'R','T','F',0}

static

Definition at line 33 of file registry.c.

Referenced by registry_read_formatopts_all(), and registry_set_formatopts_all().

key_settings

const WCHAR key_settings[] = {'S','e','t','t','i','n','g','s',0}

static

Definition at line 32 of file registry.c.

Referenced by registry_read_options(), and registry_set_options().

key_text

const WCHAR key_text[] = {'T','e','x','t',0}

static

Definition at line 34 of file registry.c.

Referenced by registry_read_formatopts_all(), and registry_set_formatopts_all().

var_barstate0

const WCHAR var_barstate0[] = {'B','a','r','S','t','a','t','e','0',0}

static

Definition at line 38 of file registry.c.

Referenced by registry_read_formatopts(), and registry_set_formatopts().

var_file

const WCHAR var_file[] = {'F','i','l','e','%','d',0}

static

Definition at line 36 of file registry.c.

Referenced by registry_read_filelist(), and registry_set_filelist().

var_framerect

const WCHAR var_framerect[] = {'F','r','a','m','e','R','e','c','t',0}

static

Definition at line 37 of file registry.c.

Referenced by registry_read_winrect(), and registry_set_options().

var_maximized

const WCHAR var_maximized[] = {'M','a','x','i','m','i','z','e','d',0}

static

Definition at line 40 of file registry.c.

Referenced by registry_read_maximized(), and registry_set_options().

var_wrap

const WCHAR var_wrap[] = {'W','r','a','p',0}

static

Definition at line 39 of file registry.c.

Referenced by registry_read_formatopts(), and registry_set_formatopts().