registry.c 10.6 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 wszInsertMode[]        = {'I','n','s','e','r','t','M','o','d','e',0};
44
static const WCHAR wszMenuMask[]          = {'M','e','n','u','M','a','s','k',0};
45
static const WCHAR wszQuickEdit[]         = {'Q','u','i','c','k','E','d','i','t',0};
46 47 48 49
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};

50 51
void WINECON_DumpConfig(const char* pfx, const struct config_data* cfg)
{
52
    WINE_TRACE("%s cell=(%u,%u) cursor=(%d,%d) attr=%02x font=%s/%u hist=%u/%d flags=%c%c%c msk=%08x sb=(%u,%u) win=(%u,%u)x(%u,%u) edit=%u registry=%s\n",
53 54
               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,
55
               cfg->insert_mode ? 'I' : 'i', cfg->quick_edit ? 'Q' : 'q', cfg->exit_on_die ? 'X' : 'x',
56
               cfg->menu_mask, cfg->sb_width, cfg->sb_height, cfg->win_pos.X, cfg->win_pos.Y, cfg->win_width, cfg->win_height,
57
               cfg->edition_mode,
58 59 60
               wine_dbgstr_w(cfg->registry));
}

61
/******************************************************************
62
 *		WINECON_CreateKeyName
63
 *
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
 * 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
82
 *
83
 * Read the basic configuration from any console key or subkey
84
 */
85
static void WINECON_RegLoadHelper(HKEY hConKey, struct config_data* cfg)
86 87 88 89 90 91
{
    DWORD 	type;
    DWORD 	count;
    DWORD       val;

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

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

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

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

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

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

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

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

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

129 130 131 132
    count = sizeof(val);
    if (!RegQueryValueExW(hConKey, wszInsertMode, 0, &type, (LPBYTE)&val, &count))
        cfg->insert_mode = val;

133
    count = sizeof(val);
134
    if (!RegQueryValueExW(hConKey, wszMenuMask, 0, &type, (LPBYTE)&val, &count))
135
        cfg->menu_mask = val;
136

137
    count = sizeof(val);
138
    if (!RegQueryValueExW(hConKey, wszQuickEdit, 0, &type, (LPBYTE)&val, &count))
139
        cfg->quick_edit = val;
140 141

    count = sizeof(val);
142
    if (!RegQueryValueExW(hConKey, wszScreenBufferSize, 0, &type, (LPBYTE)&val, &count))
143 144 145 146
    {
        cfg->sb_height = HIWORD(val);
        cfg->sb_width  = LOWORD(val);
    }
147 148

    count = sizeof(val);
149
    if (!RegQueryValueExW(hConKey, wszScreenColors, 0, &type, (LPBYTE)&val, &count))
150
        cfg->def_attr = val;
151

152
    count = sizeof(val);
153
    if (!RegQueryValueExW(hConKey, wszWindowSize, 0, &type, (LPBYTE)&val, &count))
154 155 156 157
    {
        cfg->win_height = HIWORD(val);
        cfg->win_width  = LOWORD(val);
    }
158

159
    /* win_pos isn't read from registry */
160 161 162
}

/******************************************************************
163
 *		WINECON_RegLoad
164 165 166
 *
 *
 */
167
void WINECON_RegLoad(const WCHAR* appname, struct config_data* cfg)
168 169 170
{
    HKEY        hConKey;

171 172 173 174 175 176
    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;
177
    memset(cfg->face_name, 0, sizeof(cfg->face_name));
178 179 180
    cfg->cell_height = 12;
    cfg->cell_width  = 8;
    cfg->font_weight = 0;
181
    cfg->history_size = 50;
182
    cfg->history_nodup = 0;
183
    cfg->insert_mode = 1;
184 185 186 187 188 189 190
    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;
191 192
    cfg->win_pos.X = 0;
    cfg->win_pos.Y = 0;
193
    cfg->edition_mode = 0;
194 195 196
    cfg->registry = NULL;

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

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

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

    WINECON_DumpConfig("save", cfg);
227

228
    val = cfg->cursor_size;
229
    RegSetValueExW(hConKey, wszCursorSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
230 231

    val = cfg->cursor_visible;
232
    RegSetValueExW(hConKey, wszCursorVisible, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
233

234
    val = cfg->edition_mode;
235
    RegSetValueExW(hConKey, wszEditionMode, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
236

237
    val = cfg->exit_on_die;
238
    RegSetValueExW(hConKey, wszExitOnDie, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
239

240
    RegSetValueExW(hConKey, wszFaceName, 0, REG_SZ, (LPBYTE)&cfg->face_name, sizeof(cfg->face_name));
241 242

    val = MAKELONG(cfg->cell_width, cfg->cell_height);
243
    RegSetValueExW(hConKey, wszFontSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
244 245

    val = cfg->font_weight;
246
    RegSetValueExW(hConKey, wszFontWeight, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
247 248

    val = cfg->history_size;
249
    RegSetValueExW(hConKey, wszHistoryBufferSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
250

251
    val = cfg->history_nodup;
252
    RegSetValueExW(hConKey, wszHistoryNoDup, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
253

254 255 256
    val = cfg->insert_mode;
    RegSetValueExW(hConKey, wszInsertMode, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));

257
    val = cfg->menu_mask;
258
    RegSetValueExW(hConKey, wszMenuMask, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
259

260
    val = cfg->quick_edit;
261
    RegSetValueExW(hConKey, wszQuickEdit, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
262

263
    val = MAKELONG(cfg->sb_width, cfg->sb_height);
264
    RegSetValueExW(hConKey, wszScreenBufferSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
265 266

    val = cfg->def_attr;
267
    RegSetValueExW(hConKey, wszScreenColors, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
268 269

    val = MAKELONG(cfg->win_width, cfg->win_height);
270
    RegSetValueExW(hConKey, wszWindowSize, 0, REG_DWORD, (LPBYTE)&val, sizeof(val));
271
}
272

273 274 275 276 277 278 279 280 281 282
/******************************************************************
 *		WINECON_RegSave
 *
 *
 */
void WINECON_RegSave(const struct config_data* cfg)
{
    HKEY        hConKey;

    WINE_TRACE("saving registry settings.\n");
283
    if (RegCreateKeyW(HKEY_CURRENT_USER, wszConsole, &hConKey))
284 285 286 287 288 289 290 291 292
    {
        WINE_ERR("Can't open registry for saving\n");
    }
    else
    {
        if (cfg->registry)
        {
            HKEY    hAppKey;

293
            if (RegCreateKeyW(hConKey, cfg->registry, &hAppKey))
294 295 296 297 298 299 300 301 302 303 304 305 306
            {
                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);
    }
307
}