You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
549 lines
16 KiB
549 lines
16 KiB
/* File: cloopset.c (created 02/19/94, JKH)
|
|
*
|
|
* Copyright 1994 by Hilgraeve Inc. -- Monroe, MI
|
|
* All rights reserved
|
|
*
|
|
* $Revision: 3 $
|
|
* $Date: 3/20/02 12:43p $
|
|
*/
|
|
|
|
#include <windows.h>
|
|
#pragma hdrstop
|
|
|
|
#include "stdtyp.h"
|
|
#include <tdll\assert.h>
|
|
#include "session.h"
|
|
#include "timers.h"
|
|
#include "sf.h"
|
|
#include "htchar.h"
|
|
#include "cloop.h"
|
|
#include "cloop.hh"
|
|
|
|
/* --- Session file access functions --- */
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
* FUNCTION:
|
|
* CLoopInitHdl
|
|
*
|
|
* DESCRIPTION:
|
|
* Set all cloop user settings to valid, default values.
|
|
*
|
|
* ARGUMENTS:
|
|
*
|
|
*
|
|
* RETURNS:
|
|
*
|
|
*/
|
|
int CLoopInitHdl(const HCLOOP hCLoop)
|
|
{
|
|
ST_CLOOP *pstCLoop = (ST_CLOOP *)hCLoop;
|
|
|
|
pstCLoop->stWorkSettings.fSendCRLF = FALSE;
|
|
pstCLoop->stWorkSettings.fExpandBlankLines = FALSE;
|
|
pstCLoop->stWorkSettings.fLocalEcho = FALSE;
|
|
pstCLoop->stWorkSettings.fLineWait = FALSE;
|
|
pstCLoop->stWorkSettings.chWaitChar = TEXT('\r');
|
|
pstCLoop->stWorkSettings.fExpandTabsOut = FALSE;
|
|
pstCLoop->stWorkSettings.nTabSizeOut = 8;
|
|
pstCLoop->stWorkSettings.nLineDelay = 0;
|
|
pstCLoop->stWorkSettings.nCharDelay = 0;
|
|
|
|
pstCLoop->stWorkSettings.fAddLF = FALSE;
|
|
pstCLoop->stWorkSettings.fASCII7 = FALSE;
|
|
pstCLoop->stWorkSettings.fEchoplex = FALSE;
|
|
pstCLoop->stWorkSettings.fShowHex = FALSE;
|
|
pstCLoop->stWorkSettings.nTabSizeIn = 8;
|
|
|
|
// Original settings and working settings must match initially
|
|
// If they no longer match at save time, then changes occurred.
|
|
pstCLoop->stOrigSettings = pstCLoop->stWorkSettings;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
* FUNCTION:
|
|
* CLoopLoadHdl
|
|
*
|
|
* DESCRIPTION:
|
|
* Loads CLoop user settings from the session file
|
|
*
|
|
* ARGUMENTS:
|
|
*
|
|
*
|
|
* RETURNS:
|
|
*
|
|
*/
|
|
int CLoopLoadHdl(const HCLOOP hCLoop)
|
|
{
|
|
unsigned long ul;
|
|
ST_CLOOP *pstCLoop = (ST_CLOOP *)hCLoop;
|
|
ST_CLOOP_SETTINGS *pstSettings;
|
|
const SF_HANDLE sfhdl = sessQuerySysFileHdl(pstCLoop->hSession);
|
|
|
|
// Start off with default settings
|
|
CLoopInitHdl(hCLoop);
|
|
|
|
pstSettings = &pstCLoop->stOrigSettings;
|
|
|
|
ul = sizeof(pstSettings->fSendCRLF);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_SENDCRLF, &ul, &pstSettings->fSendCRLF);
|
|
|
|
ul = sizeof(pstSettings->fExpandBlankLines);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_EXPAND, &ul, &pstSettings->fExpandBlankLines);
|
|
|
|
ul = sizeof(pstSettings->fLocalEcho);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_LOCALECHO, &ul, &pstSettings->fLocalEcho);
|
|
|
|
ul = sizeof(pstSettings->fLineWait);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_LINEWAIT, &ul, &pstSettings->fLineWait);
|
|
|
|
ul = sizeof(pstSettings->chWaitChar);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_WAITCHAR, &ul, &pstSettings->chWaitChar);
|
|
|
|
ul = sizeof(pstSettings->fExpandTabsOut);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_EXTABSOUT, &ul, &pstSettings->fExpandTabsOut);
|
|
|
|
ul = sizeof(pstSettings->nTabSizeOut);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_TABSIZEOUT, &ul, &pstSettings->nTabSizeOut);
|
|
|
|
ul = sizeof(pstSettings->nLineDelay);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_LINEDELAY, &ul, &pstSettings->nLineDelay);
|
|
|
|
ul = sizeof(pstSettings->nCharDelay);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_CHARDELAY, &ul, &pstSettings->nCharDelay);
|
|
|
|
ul = sizeof(pstSettings->fAddLF);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_ADDLF, &ul, &pstSettings->fAddLF);
|
|
|
|
ul = sizeof(pstSettings->fASCII7);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_ASCII7, &ul, &pstSettings->fASCII7);
|
|
|
|
ul = sizeof(pstSettings->fEchoplex);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_ECHOPLEX, &ul, &pstSettings->fEchoplex);
|
|
|
|
ul = sizeof(pstSettings->fShowHex);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_SHOWHEX, &ul, &pstSettings->fShowHex);
|
|
|
|
ul = sizeof(pstSettings->nTabSizeIn);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_TABSIZEIN, &ul, &pstSettings->nTabSizeIn);
|
|
|
|
ul = sizeof(pstCLoop->fDoMBCS);
|
|
sfGetSessionItem(sfhdl, SF_CLOOP_DBCS, &ul, &pstCLoop->fDoMBCS);
|
|
|
|
pstCLoop->stWorkSettings = pstCLoop->stOrigSettings;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
* FUNCTION:
|
|
* CLoopSaveHdl
|
|
*
|
|
* DESCRIPTION:
|
|
* Saves CLoop user settings in the session file if any changes have
|
|
* been made.
|
|
*
|
|
* ARGUMENTS:
|
|
* hCLoop -- The CLoop handle created by CLoopCreateHandle
|
|
*
|
|
* RETURNS:
|
|
* nothing
|
|
*/
|
|
int CLoopSaveHdl(const HCLOOP hCLoop)
|
|
{
|
|
ST_CLOOP *pstCLoop = (ST_CLOOP *)hCLoop;
|
|
ST_CLOOP_SETTINGS *pstSettings;
|
|
SF_HANDLE hSF;
|
|
#define PutItem(v,i) sfPutSessionItem(hSF, i, sizeof(v), &(v))
|
|
|
|
EnterCriticalSection(&pstCLoop->csect);
|
|
|
|
hSF = sessQuerySysFileHdl(pstCLoop->hSession);
|
|
|
|
// If any settings have changed, write all settings out to session file
|
|
// Outgoing line endings
|
|
#if 1
|
|
// Decided on 3/23 to modify design so handles will write out all
|
|
// settings and session file routiines will decide what has changed
|
|
if (TRUE)
|
|
#else
|
|
if (memcmp(&pstCLoop->stWorkSettings, &pstCLoop->stOrigSettings,
|
|
sizeof(pstCLoop->stWorkSettings)) != 0)
|
|
#endif
|
|
{
|
|
pstSettings = &pstCLoop->stWorkSettings;
|
|
|
|
PutItem(pstSettings->fSendCRLF, SF_CLOOP_SENDCRLF);
|
|
PutItem(pstSettings->fExpandBlankLines, SF_CLOOP_EXPAND);
|
|
PutItem(pstSettings->fLocalEcho, SF_CLOOP_LOCALECHO);
|
|
PutItem(pstSettings->fLineWait, SF_CLOOP_LINEWAIT);
|
|
PutItem(pstSettings->chWaitChar, SF_CLOOP_WAITCHAR);
|
|
PutItem(pstSettings->fExpandTabsOut, SF_CLOOP_EXTABSOUT);
|
|
PutItem(pstSettings->nTabSizeOut, SF_CLOOP_TABSIZEOUT);
|
|
PutItem(pstSettings->nLineDelay, SF_CLOOP_LINEDELAY);
|
|
PutItem(pstSettings->nCharDelay, SF_CLOOP_CHARDELAY);
|
|
PutItem(pstSettings->fAddLF, SF_CLOOP_ADDLF);
|
|
PutItem(pstSettings->fASCII7, SF_CLOOP_ASCII7);
|
|
PutItem(pstSettings->fEchoplex, SF_CLOOP_ECHOPLEX);
|
|
PutItem(pstSettings->fShowHex, SF_CLOOP_SHOWHEX);
|
|
PutItem(pstSettings->nTabSizeIn, SF_CLOOP_TABSIZEIN);
|
|
PutItem(pstCLoop->fDoMBCS, SF_CLOOP_DBCS);
|
|
|
|
pstCLoop->stOrigSettings = pstCLoop->stWorkSettings;
|
|
}
|
|
|
|
LeaveCriticalSection(&pstCLoop->csect);
|
|
return SF_OK;
|
|
}
|
|
|
|
/* --- Access functions for user settings --- */
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
* FUNCTION: CLoopGetXXXXX (several functions)
|
|
*
|
|
* DESCRIPTION:
|
|
* Retrieves the named user setting.
|
|
*
|
|
* ARGUMENTS:
|
|
* hCLoop -- Value returned from CLoopCreateHandle
|
|
*
|
|
* RETURNS:
|
|
* The requested user setting.
|
|
*/
|
|
|
|
/*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|
|
* FUNCTION: CLoopSetXXXXX (several functions)
|
|
*
|
|
* DESCRIPTION:
|
|
* Sets the named user setting
|
|
*
|
|
* ARGUMENTS:
|
|
* hCLoop -- Value returned from CLoopCreateHandle
|
|
* <varname> -- The value to be set
|
|
*
|
|
* RETURNS:
|
|
* nothing
|
|
*/
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetSendCRLF(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fSendCRLF;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetSendCRLF(const HCLOOP hCLoop, const int fSendCRLF)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fSendCRLF = fSendCRLF;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetExpandBlankLines(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fExpandBlankLines;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetExpandBlankLines(const HCLOOP hCLoop, const int fExpandBlankLines)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fExpandBlankLines = fExpandBlankLines;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetLocalEcho(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fLocalEcho;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetLocalEcho(const HCLOOP hCLoop, const int fLocalEcho)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fLocalEcho = fLocalEcho;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetLineWait(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fLineWait;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetLineWait(const HCLOOP hCLoop, const int fLineWait)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fLineWait = fLineWait;
|
|
|
|
// Clear line wait flag in case option is turned off while waiting
|
|
CLoopSndControl(hCLoop, CLOOP_RESUME, CLOOP_SB_LINEWAIT);
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
TCHAR CLoopGetWaitChar(const HCLOOP hCLoop)
|
|
{
|
|
TCHAR chVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
chVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.chWaitChar;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return chVal;
|
|
}
|
|
|
|
void CLoopSetWaitChar(const HCLOOP hCLoop, TCHAR chWaitChar)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.chWaitChar = chWaitChar;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetExpandTabsOut(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fExpandTabsOut;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetExpandTabsOut(const HCLOOP hCLoop, const int fExpandTabsOut)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fExpandTabsOut = fExpandTabsOut;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetTabSizeOut(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.nTabSizeOut;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetTabSizeOut(const HCLOOP hCLoop, const int nTabSizeOut)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.nTabSizeOut = nTabSizeOut;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetLineDelay(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.nLineDelay;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetLineDelay(const HCLOOP hCLoop, const int nLineDelay)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.nLineDelay = nLineDelay;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetCharDelay(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.nCharDelay;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetCharDelay(const HCLOOP hCLoop, const int nCharDelay)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.nCharDelay = nCharDelay;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetAddLF(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fAddLF;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetAddLF(const HCLOOP hCLoop, const int fAddLF)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fAddLF = fAddLF;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetASCII7(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fASCII7;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetASCII7(const HCLOOP hCLoop, const int fASCII7)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fASCII7 = fASCII7;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetEchoplex(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fEchoplex;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetEchoplex(const HCLOOP hCLoop, const int fEchoplex)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fEchoplex = fEchoplex;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
#if 0
|
|
int CLoopGetWrapLines(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fWrapLines;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetWrapLines(const HCLOOP hCLoop, const int fWrapLines)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fWrapLines = fWrapLines;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
#endif
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetShowHex(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.fShowHex;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetShowHex(const HCLOOP hCLoop, const int fShowHex)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.fShowHex = fShowHex;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|
|
|
|
int CLoopGetTabSizeIn(const HCLOOP hCLoop)
|
|
{
|
|
int iVal;
|
|
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
iVal = ((ST_CLOOP *)hCLoop)->stWorkSettings.nTabSizeIn;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
return iVal;
|
|
}
|
|
|
|
void CLoopSetTabSizeIn(const HCLOOP hCLoop, const int nTabSizeIn)
|
|
{
|
|
assert(hCLoop);
|
|
EnterCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
((ST_CLOOP *)hCLoop)->stWorkSettings.nTabSizeIn = nTabSizeIn;
|
|
LeaveCriticalSection(&((ST_CLOOP *)hCLoop)->csect);
|
|
}
|
|
|
|
/* ------------------------------------------------------------*/
|