registry.c 10.2 KB
Newer Older
1 2 3 4 5
/*
 * an application for displaying Win32 console
 *      registry and init functions
 *
 * Copyright 2001 Eric Pouech
6 7 8 9 10 11 12 13 14 15 16 17 18
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 21
 */

22 23 24
#include <stdarg.h>

#include "windef.h"
25 26 27 28
#include "winbase.h"
#include "winreg.h"
#include "winecon_private.h"

29 30 31 32
#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(wineconsole);

33 34 35
static const WCHAR wszConsole[]           = {'C','o','n','s','o','l','e',0};
static const WCHAR wszCursorSize[]        = {'C','u','r','s','o','r','S','i','z','e',0};
static const WCHAR wszCursorVisible[]     = {'C','u','r','s','o','r','V','i','s','i','b','l','e',0};
36
static const WCHAR wszEditionMode[]       = {'E','d','i','t','i','o','n','M','o','d','e',0};
37
static const WCHAR wszExitOnDie[]         = {'E','x','i','t','O','n','D','i','e',0};
38 39 40 41
static const WCHAR wszFaceName[]          = {'F','a','c','e','N','a','m','e',0};
static const WCHAR wszFontSize[]          = {'F','o','n','t','S','i','z','e',0};
static const WCHAR wszFontWeight[]        = {'F','o','n','t','W','e','i','g','h','t',0};
static const WCHAR wszHistoryBufferSize[] = {'H','i','s','t','o','r','y','B','u','f','f','e','r','S','i','z','e',0};
42
static const WCHAR wszHistoryNoDup[]      = {'H','i','s','t','o','r','y','N','o','D','u','p',0};
43
static const WCHAR wszMenuMask[]          = {'M','e','n','u','M','a','s','k',0};
44
static const WCHAR wszQuickEdit[]         = {'Q','u','i','c','k','E','d','i','t',0};
45 46 47 48
static const WCHAR wszScreenBufferSize[]  = {'S','c','r','e','e','n','B','u','f','f','e','r','S','i','z','e',0};
static const WCHAR wszScreenColors[]      = {'S','c','r','e','e','n','C','o','l','o','r','s',0};
static const WCHAR wszWindowSize[]        = {'W','i','n','d','o','w','S','i','z','e',0};

49 50
void WINECON_DumpConfig(const char* pfx, const struct config_data* cfg)
{
51
    WINE_TRACE("%s cell=(%u,%u) cursor=(%d,%d) attr=%02x font=%s/%u hist=%u/%d flags=%c%c msk=%08x sb=(%u,%u) win=(%u,%u)x(%u,%u) edit=%u registry=%s\n",
52 53 54 55
               pfx, cfg->cell_width, cfg->cell_height, cfg->cursor_size, cfg->cursor_visible, cfg->def_attr,
               wine_dbgstr_w(cfg->face_name), cfg->font_weight, cfg->history_size, cfg->history_nodup ? 1 : 2,
               cfg->quick_edit ? 'Q' : 'q', cfg->exit_on_die ? 'X' : 'x',
               cfg->menu_mask, cfg->sb_width, cfg->sb_height, cfg->win_pos.X, cfg->win_pos.Y, cfg->win_width, cfg->win_height,
56
               cfg->edition_mode,
57 58 59
               wine_dbgstr_w(cfg->registry));
}

60
/******************************************************************
61
 *		WINECON_CreateKeyName
62
 *
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
 * Get a proper key name from an appname (mainly convert '\\' to '_')
 */
static LPWSTR   WINECON_CreateKeyName(LPCWSTR kn)
{
    LPWSTR      ret = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(kn) + 1) * sizeof(WCHAR));
    LPWSTR      ptr = ret;

    if (!ptr) WINECON_Fatal("OOM");

    do
    {
        *ptr++ = *kn == '\\' ? '_' : *kn;
    } while (*kn++ != 0);
    return ret;
}

/******************************************************************
 *		WINECON_RegLoadHelper
81
 *
82
 * Read the basic configuration from any console key or subkey
83
 */
84
static void WINECON_RegLoadHelper(HKEY hConKey, struct config_data* cfg)
85 86 87 88 89 90
{
    DWORD 	type;
    DWORD 	count;
    DWORD       val;

    count = sizeof(val);
91
    if (!RegQueryValueEx(hConKey, wszCursorSize, 0, &type, (LPBYTE)&val, &count))
92
        cfg->cursor_size = val;
93 94

    count = sizeof(val);
95
    if (!RegQueryValueEx(hConKey, wszCursorVisible, 0, &type, (LPBYTE)&val, &count))
96
        cfg->cursor_visible = val;
97

98
    count = sizeof(val);
99
    if (!RegQueryValueEx(hConKey, wszEditionMode, 0, &type, (LPBYTE)&val, &count))
100 101
        cfg->edition_mode = val;

102
    count = sizeof(val);
103
    if (!RegQueryValueEx(hConKey, wszExitOnDie, 0, &type, (LPBYTE)&val, &count))
104
        cfg->exit_on_die = val;
105

106
    count = sizeof(cfg->face_name);
107
    RegQueryValueEx(hConKey, wszFaceName, 0, &type, (LPBYTE)&cfg->face_name, &count);
108 109

    count = sizeof(val);
110
    if (!RegQueryValueEx(hConKey, wszFontSize, 0, &type, (LPBYTE)&val, &count))
111 112 113 114
    {
        cfg->cell_height = HIWORD(val);
        cfg->cell_width  = LOWORD(val);
    }
115 116

    count = sizeof(val);
117
    if (!RegQueryValueEx(hConKey, wszFontWeight, 0, &type, (LPBYTE)&val, &count))
118
        cfg->font_weight = val;
119 120

    count = sizeof(val);
121
    if (!RegQueryValueEx(hConKey, wszHistoryBufferSize, 0, &type, (LPBYTE)&val, &count))
122
        cfg->history_size = val;
123 124

    count = sizeof(val);
125
    if (!RegQueryValueEx(hConKey, wszHistoryNoDup, 0, &type, (LPBYTE)&val, &count))
126
        cfg->history_nodup = val;
127

128
    count = sizeof(val);
129
    if (!RegQueryValueEx(hConKey, wszMenuMask, 0, &type, (LPBYTE)&val, &count))
130
        cfg->menu_mask = val;
131

132
    count = sizeof(val);
133
    if (!RegQueryValueEx(hConKey, wszQuickEdit, 0, &type, (LPBYTE)&val, &count))
134
        cfg->quick_edit = val;
135 136

    count = sizeof(val);
137
    if (!RegQueryValueEx(hConKey, wszScreenBufferSize, 0, &type, (LPBYTE)&val, &count))
138 139 140 141
    {
        cfg->sb_height = HIWORD(val);
        cfg->sb_width  = LOWORD(val);
    }
142 143

    count = sizeof(val);
144
    if (!RegQueryValueEx(hConKey, wszScreenColors, 0, &type, (LPBYTE)&val, &count))
145
        cfg->def_attr = val;
146

147
    count = sizeof(val);
148
    if (!RegQueryValueEx(hConKey, wszWindowSize, 0, &type, (LPBYTE)&val, &count))
149 150 151 152
    {
        cfg->win_height = HIWORD(val);
        cfg->win_width  = LOWORD(val);
    }
153

154
    /* win_pos isn't read from registry */
155 156 157
}

/******************************************************************
158
 *		WINECON_RegLoad
159 160 161
 *
 *
 */
162
void WINECON_RegLoad(const WCHAR* appname, struct config_data* cfg)
163 164 165
{
    HKEY        hConKey;

166 167 168 169 170 171
    WINE_TRACE("loading %s registry settings.\n", appname ? wine_dbgstr_w(appname) : "default");

    /* first set default values */
    cfg->cursor_size = 25;
    cfg->cursor_visible = 1;
    cfg->exit_on_die = 1;
172
    memset(cfg->face_name, 0, sizeof(cfg->face_name));
173 174 175
    cfg->cell_height = 12;
    cfg->cell_width  = 8;
    cfg->font_weight = 0;
176
    cfg->history_size = 50;
177 178 179 180 181 182 183 184
    cfg->history_nodup = 0;
    cfg->menu_mask = 0;
    cfg->quick_edit = 0;
    cfg->sb_height = 25;
    cfg->sb_width  = 80;
    cfg->def_attr = 0x000F;
    cfg->win_height = 25;
    cfg->win_width  = 80;
185 186
    cfg->win_pos.X = 0;
    cfg->win_pos.Y = 0;
187
    cfg->edition_mode = 0;
188 189 190 191
    cfg->registry = NULL;

    /* then read global settings */
    if (!RegOpenKey(HKEY_CURRENT_USER, wszConsole, &hConKey))
192
    {
193 194 195 196 197 198 199 200 201 202 203 204 205 206
        WINECON_RegLoadHelper(hConKey, cfg);
        /* if requested, load part related to console title */
        if (appname)
        {
            HKEY        hAppKey;

            cfg->registry = WINECON_CreateKeyName(appname);
            if (!RegOpenKey(hConKey, cfg->registry, &hAppKey))
            {
                WINECON_RegLoadHelper(hAppKey, cfg);
                RegCloseKey(hAppKey);
            }
        }
        RegCloseKey(hConKey);
207
    }
208 209 210 211 212 213 214 215 216 217 218 219 220
    WINECON_DumpConfig("load", cfg);
}

/******************************************************************
 *		WINECON_RegSaveHelper
 *
 *
 */
static void WINECON_RegSaveHelper(HKEY hConKey, const struct config_data* cfg)
{
    DWORD       val;

    WINECON_DumpConfig("save", cfg);
221

222
    val = cfg->cursor_size;
223
    RegSetValueEx(hConKey, wszCursorSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
224 225

    val = cfg->cursor_visible;
226
    RegSetValueEx(hConKey, wszCursorVisible, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
227

228
    val = cfg->edition_mode;
229
    RegSetValueEx(hConKey, wszEditionMode, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
230

231
    val = cfg->exit_on_die;
232
    RegSetValueEx(hConKey, wszExitOnDie, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
233

234
    RegSetValueEx(hConKey, wszFaceName, 0, REG_SZ, (LPBYTE)&cfg->face_name, sizeof(cfg->face_name));
235 236

    val = MAKELONG(cfg->cell_width, cfg->cell_height);
237
    RegSetValueEx(hConKey, wszFontSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
238 239

    val = cfg->font_weight;
240
    RegSetValueEx(hConKey, wszFontWeight, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
241 242

    val = cfg->history_size;
243
    RegSetValueEx(hConKey, wszHistoryBufferSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
244

245
    val = cfg->history_nodup;
246
    RegSetValueEx(hConKey, wszHistoryNoDup, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
247

248
    val = cfg->menu_mask;
249
    RegSetValueEx(hConKey, wszMenuMask, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
250

251
    val = cfg->quick_edit;
252
    RegSetValueEx(hConKey, wszQuickEdit, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
253

254
    val = MAKELONG(cfg->sb_width, cfg->sb_height);
255
    RegSetValueEx(hConKey, wszScreenBufferSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
256 257

    val = cfg->def_attr;
258
    RegSetValueEx(hConKey, wszScreenColors, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
259 260

    val = MAKELONG(cfg->win_width, cfg->win_height);
261
    RegSetValueEx(hConKey, wszWindowSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
262
}
263

264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
/******************************************************************
 *		WINECON_RegSave
 *
 *
 */
void WINECON_RegSave(const struct config_data* cfg)
{
    HKEY        hConKey;

    WINE_TRACE("saving registry settings.\n");
    if (RegCreateKey(HKEY_CURRENT_USER, wszConsole, &hConKey))
    {
        WINE_ERR("Can't open registry for saving\n");
    }
    else
    {
        if (cfg->registry)
        {
            HKEY    hAppKey;

            if (RegCreateKey(hConKey, cfg->registry, &hAppKey))
            {
                WINE_ERR("Can't open registry for saving\n");
            }
            else
            {
                /* FIXME: maybe only save the values different from the default value ? */
                WINECON_RegSaveHelper(hAppKey, cfg);
                RegCloseKey(hAppKey);
            }
        }
        else WINECON_RegSaveHelper(hConKey, cfg);
        RegCloseKey(hConKey);
    }
298
}