BOOL CuDlgDBEventPane01::Find (LPCTSTR lpszDbe, LPCTSTR lpszDbeOwner)
{
TCHAR tchszAll1[MAXOBJECTNAME];
TCHAR tchszAll2[MAXOBJECTNAME];
LPTSTR lpszOwner;
CString strItem;
int i, nCount = m_cListDBEvent.GetCount();
StringWithOwner ((LPUCHAR)lpszDbe, (LPUCHAR)lpszDbeOwner, (LPUCHAR)tchszAll1);
for (i=0; i<nCount; i++)
{
m_cListDBEvent.GetText (i, strItem);
lpszOwner = (LPTSTR)m_cListDBEvent.GetItemData (i);
ASSERT (lpszOwner);
StringWithOwner ((LPUCHAR)(LPCTSTR)strItem, (LPUCHAR)lpszDbeOwner, (LPUCHAR)tchszAll2);
if (lstrcmpi (tchszAll1, tchszAll2) == 0)
return TRUE;
}
return FALSE;
}
static void FillGrantedUsers (HWND hwndCtl, LPREVOKEPARAMS lprevoke, int objectToFind)
{
int hdl, ires, gtype;
BOOL bwsystem;
char buf [MAXOBJECTNAME];
char buffilter [MAXOBJECTNAME];
char bufwithparent [MAXOBJECTNAME];
LPUCHAR parentstrings [MAXPLEVEL];
LPDOMDATA lpDomData =GetCurLpDomData ();
ZEROINIT (buf);
ZEROINIT (buffilter);
hdl = GetCurMdiNodeHandle ();
bwsystem = GetSystemFlag ();
if (!lpDomData)
return;
parentstrings [0] = lprevoke->DBName; // Database name
if (lprevoke->ObjectType != OT_VIEW)
parentstrings [1] = StringWithOwner ((LPTSTR)Quote4DisplayIfNeeded(lprevoke->PreselectObject),
lprevoke->PreselectObjectOwner, bufwithparent);
else
parentstrings [1] = StringWithOwner ((LPTSTR)Quote4DisplayIfNeeded(lprevoke->PreselectObject),
lprevoke->PreselectObjectOwner, bufwithparent);
ires = DOMGetFirstObject (hdl, objectToFind, 2, parentstrings, bwsystem, NULL, buf, NULL, NULL);
while (ires == RES_SUCCESS)
{
gtype = DBA_GetObjectType (buf, lpDomData);
if (gtype == lprevoke->GranteeType)
{
CAListBox_AddString (hwndCtl, buf);
}
ires = DOMGetNextObject (buf, buffilter, NULL);
}
}
LONG CuDlgDBEventPane02::OnDbeventTraceIncoming (WPARAM wParam, LPARAM lParam)
{
LPRAISEDDBE lpStruct = (LPRAISEDDBE)lParam;
CView* pView = (CView*)GetParent();
ASSERT (pView);
CDbeventDoc* pDoc = (CDbeventDoc*)pView->GetDocument();
ASSERT (pDoc);
CSplitterWnd* pSplitter = (CSplitterWnd*)pView->GetParent();
ASSERT (pSplitter);
CDbeventFrame* pFrame = (CDbeventFrame*)pSplitter->GetParent();
ASSERT (pFrame);
if (!pFrame->GetPaneRegisteredDBEvent()->Find ((LPCTSTR)lpStruct->DBEventName, (LPCTSTR)lpStruct->DBEventOwner))
{
IncomingDBEvent (
pDoc,
"r",
(LPCTSTR)lpStruct->StrTimeStamp,
(LPCTSTR)lpStruct->DBEventName,
(LPCTSTR)lpStruct->DBEventOwner,
(LPCTSTR)lpStruct->DBEventText,
"*");
}
else
{
IncomingDBEvent (
pDoc,
"r",
(LPCTSTR)lpStruct->StrTimeStamp,
(LPCTSTR)lpStruct->DBEventName,
(LPCTSTR)lpStruct->DBEventOwner,
(LPCTSTR)lpStruct->DBEventText);
}
if (pDoc->m_bPopupOnRaise)
{
CString strMsg;
strMsg.GetBuffer (520);
TCHAR tchszAll [80];
StringWithOwner ((LPUCHAR)lpStruct->DBEventName, (LPUCHAR)lpStruct->DBEventOwner, (LPUCHAR)tchszAll);
//"%s: Database Event %s '%s' was raised on node %s."
strMsg.Format (IDS_I_DB_EVENT_RAISED,
(LPCTSTR)lpStruct->StrTimeStamp,
(LPCTSTR)tchszAll,
(LPCTSTR)lpStruct->DBEventText,
(LPCTSTR)GetVirtNodeName (pDoc->m_hNode));
BfxMessageBox (strMsg);
}
return RES_SUCCESS;
}
static void AddFile (HWND hwnd, LPTABLExFILE lpFile)
{
int hdl, ires;
BOOL bwsystem;
char buf [MAXOBJECTNAME];
char buf2 [MAXOBJECTNAME];
char szOwner [MAXOBJECTNAME];
LPUCHAR parentstrings [MAXPLEVEL];
LPAUDITDBPARAMS lpauditdb = GetDlgProp (hwnd);
HWND hwndTables = GetDlgItem (hwnd, IDC_AUDITDBF_TABLE);
LPTABLExFILE
ls = lpFile,
obj;
char szFileName[MAXOBJECTNAME];
ZEROINIT (buf);
parentstrings [0] = lpauditdb->DBName;
parentstrings [1] = NULL;
hdl = GetCurMdiNodeHandle ();
bwsystem = GetSystemFlag ();
ires = DOMGetFirstObject (
hdl,
OT_TABLE,
1,
parentstrings,
bwsystem,
NULL,
buf,
szOwner,
NULL);
while (ires == RES_SUCCESS)
{
StringWithOwner (buf, szOwner, buf2);
obj = FindStringInListTableAndFile (ls, buf2);
if (obj)
{
wsprintf (szFileName, "%s.trl", RemoveDisplayQuotesIfAny((LPTSTR)StringWithoutOwner(buf)));
x_strcpy (obj->FileName, szFileName);
}
ires = DOMGetNextObject (buf, szOwner, NULL);
}
}
static BOOL FillStructureFromControls (HWND hwnd, LPSECURITYALARMPARAMS lpsecurity)
{
char buf [MAXOBJECTNAME];
// char buffowner [MAXOBJECTNAME];
// char bufftable [MAXOBJECTNAME];
char szDBE [MAXOBJECTNAME];
char szName [MAXOBJECTNAME];
LPCHECKEDOBJECTS obj;
LPCHECKEDOBJECTS list = NULL;
int i, max_database_number, checked;
HWND hwndDB = GetDlgItem (hwnd, IDC_SALARM_ONTABLE);
HWND hwndUsers = GetDlgItem (hwnd, IDC_SALARM_BYUSER );
HWND hwndSuccess = GetDlgItem (hwnd, IDC_SALARM_SUCCESS);
HWND hwndFailure = GetDlgItem (hwnd, IDC_SALARM_FAILURE);
HWND hwndSelect = GetDlgItem (hwnd, IDC_SALARM_SELECT);
HWND hwndDelete = GetDlgItem (hwnd, IDC_SALARM_DELETE);
HWND hwndInsert = GetDlgItem (hwnd, IDC_SALARM_INSERT);
HWND hwndUpdate = GetDlgItem (hwnd, IDC_SALARM_UPDATE);
HWND hwndConnect = GetDlgItem (hwnd, IDC_SALARM_CONNECT);
HWND hwndDisconnect = GetDlgItem (hwnd, IDC_SALARM_DISCONNECT);
HWND hwndDBE = GetDlgItem (hwnd, IDC_SALARM_DBEVENT);
HWND hwndDBEText = GetDlgItem (hwnd, IDC_SALARM_DBEVENT_TEXT);
HWND hwndName = GetDlgItem (hwnd, IDC_SALARM_NAME);
x_strcpy (lpsecurity->DBName, "iidbdb");
ZEROINIT (szName);
Edit_GetText (hwndName, szName, sizeof (szName));
x_strcpy (lpsecurity->ObjectName, szName);
lpsecurity->bsuccfail [SECALARMSUCCESS] = Button_GetCheck (hwndSuccess);
lpsecurity->bsuccfail [SECALARMFAILURE] = Button_GetCheck (hwndFailure);
//
// Get selection from
// toggle buttons (Select, Delete, Insert, Update)
//
lpsecurity->baccesstype [SECALARMSEL] = Button_GetCheck (hwndSelect);
lpsecurity->baccesstype [SECALARMDEL] = Button_GetCheck (hwndDelete);
lpsecurity->baccesstype [SECALARMINS] = Button_GetCheck (hwndInsert);
lpsecurity->baccesstype [SECALARMUPD] = Button_GetCheck (hwndUpdate);
lpsecurity->baccesstype [SECALARMCONNECT] = Button_GetCheck (hwndConnect );
lpsecurity->baccesstype [SECALARMDISCONN] = Button_GetCheck (hwndDisconnect);
//
// Get the names of users that have been checked and
// insert into the list
//
if (Button_GetCheck (GetDlgItem (hwnd, IDC_SALARM_USER)))
lpsecurity->iAuthIdType = OT_USER;
else
if (Button_GetCheck (GetDlgItem (hwnd, IDC_SALARM_GROUP)))
lpsecurity->iAuthIdType = OT_GROUP;
else
if (Button_GetCheck (GetDlgItem (hwnd, IDC_SALARM_ROLE)))
lpsecurity->iAuthIdType = OT_ROLE;
else
if (Button_GetCheck (GetDlgItem (hwnd, IDC_SALARM_PUBLIC)))
lpsecurity->iAuthIdType = OT_PUBLIC;
else
lpsecurity->iAuthIdType = OT_USER;
max_database_number = CAListBox_GetCount (hwndUsers);
if (Button_GetCheck (GetDlgItem (hwnd, IDC_SALARM_PUBLIC)))
{
obj = ESL_AllocMem (sizeof (CHECKEDOBJECTS));
if (!obj)
{
FreeAttachedPointers (lpsecurity, OTLL_SECURITYALARM);
ErrorMessage ((UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
return FALSE;
}
else
{
x_strcpy (obj->dbname, lppublicsysstring());
obj->bchecked = TRUE;
list = AddCheckedObject (list, obj);
}
}
for (i = 0; i < max_database_number; i++)
{
checked = CAListBox_GetSel (hwndUsers, i);
if (checked == 1)
{
CAListBox_GetText (hwndUsers, i, buf);
obj = ESL_AllocMem (sizeof (CHECKEDOBJECTS));
if (!obj)
{
FreeAttachedPointers (lpsecurity, OTLL_SECURITYALARM);
ErrorMessage ((UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
return FALSE;
}
else
{
if (x_strcmp (buf, lppublicdispstring()) == 0)
x_strcpy (obj->dbname, lppublicsysstring());
else
x_strcpy (obj->dbname, QuoteIfNeeded(buf));
obj->bchecked = TRUE;
list = AddCheckedObject (list, obj);
}
}
}
lpsecurity->lpfirstUser = list;
//
// Get the names of Database that have been checked and
// insert into the list
//
max_database_number = CAListBox_GetCount (hwndDB);
list = NULL;
for (i=0; i<max_database_number; i++)
{
checked = CAListBox_GetSel (hwndDB, i);
if (checked)
{
CAListBox_GetText (hwndDB, i, buf);
obj = ESL_AllocMem (sizeof (CHECKEDOBJECTS));
if (!obj)
{
FreeAttachedPointers (lpsecurity, OTLL_SECURITYALARM);
ErrorMessage ((UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
return FALSE;
}
else
{
x_strcpy (obj->dbname, buf);
obj->bchecked = TRUE;
list = AddCheckedObject (list, obj);
}
}
}
lpsecurity->lpfirstTable = list;
ComboBox_GetText (hwndDBE, szDBE, sizeof (szDBE));
if ((x_strlen (szDBE) > 0 ) && (x_strcmp (szDBE, szSecurityDBEvent) != 0))
{
char szOwner [MAXOBJECTNAME];
char szAll [MAXOBJECTNAME];
int len, nSel;
nSel = ComboBox_GetCurSel (hwndDBE);
x_strcpy (szOwner, (char *) ComboBox_GetItemData (hwndDBE, nSel));
StringWithOwner (szDBE, szOwner, szAll);
x_strcpy (lpsecurity->DBEvent, szAll);
len = Edit_GetTextLength (hwndDBEText);
if (len > 0)
{
lpsecurity->lpDBEventText = ESL_AllocMem ((len*sizeof(TCHAR)) + sizeof(TCHAR));
if (lpsecurity->lpDBEventText)
{
Edit_GetText (hwndDBEText, lpsecurity->lpDBEventText, len+1); // Emb 26/06/97: +1 was missing --> lost character
if (EscapedSimpleQuote(&lpsecurity->lpDBEventText) == RES_ERR) {
FreeAttachedPointers (lpsecurity, OTLL_SECURITYALARM);
ErrorMessage ((UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
return FALSE;
}
}
else
{
FreeAttachedPointers (lpsecurity, OTLL_SECURITYALARM);
ErrorMessage ((UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
return FALSE;
}
}
lpsecurity->bDBEvent = TRUE;
}
else if (lpsecurity->lpDBEventText)
{
ESL_FreeMem (lpsecurity->lpDBEventText);
lpsecurity->lpDBEventText = NULL;
}
return TRUE;
}
LONG CuDlgDomPropTblInteg::OnUpdateData (WPARAM wParam, LPARAM lParam)
{
// cast received parameters
int nNodeHandle = (int)wParam;
LPIPMUPDATEPARAMS pUps = (LPIPMUPDATEPARAMS)lParam;
ASSERT (nNodeHandle != -1);
ASSERT (pUps);
// ignore selected actions on filters
switch (pUps->nIpmHint)
{
case 0:
case FILTER_DOM_SYSTEMOBJECTS: // eligible
//case FILTER_DOM_BASEOWNER:
//case FILTER_DOM_OTHEROWNER:
break;
case FILTER_DOM_BKREFRESH:
// eligible if UpdateType is compatible with DomGetFirst/Next object type,
// or is ot_virtnode, which means refresh for all whatever the type is
if (pUps->pSFilter->UpdateType != OT_VIRTNODE &&
pUps->pSFilter->UpdateType != OT_INTEGRITY)
return 0L;
break;
case FILTER_SETTING_CHANGE:
VDBA_OnGeneralSettingChange(&m_cListCtrl);
return 0L;
default:
return 0L; // nothing to change on the display
}
// Get info on the current item
LPTREERECORD lpRecord = (LPTREERECORD)pUps->pStruct;
ASSERT (lpRecord);
ResetDisplay();
//
// Get list of Tbl for the replication
//
m_Data.m_uaTblInteg.RemoveAll();
int iret;
UCHAR buf[MAXOBJECTNAME];
UCHAR bufOwner[MAXOBJECTNAME];
UCHAR bufComplim[MAXOBJECTNAME];
//
// CHECK EXISTENCE SINCE REGISTERED TABLE MIGHT NOT REALLY EXIST YET
//
int resultType;
UCHAR resultObjectName[MAXOBJECTNAME];
UCHAR resultOwnerName[MAXOBJECTNAME];
UCHAR resultExtraData[MAXOBJECTNAME];
char* parentStrings[3];
parentStrings[0] = (char*)lpRecord->extra; // DBName
parentStrings[1] = parentStrings[2] = NULL;
// preparation for get limited info - added static type - added all related granted types
LPUCHAR lpName = NULL;
LPUCHAR lpOwner = NULL;
int basicType = GetBasicType(lpRecord->recType);
m_Data.m_objType = basicType;
switch (basicType) {
case OT_TABLE:
case OT_SCHEMAUSER_TABLE:
lpName = (LPUCHAR)lpRecord->objName;
lpOwner = (LPUCHAR)lpRecord->ownerName;
break;
case OT_STATIC_INTEGRITY:
lpName = (LPUCHAR)lpRecord->extra2;
lpOwner = (LPUCHAR)lpRecord->tableOwner;
break;
default:
ASSERT(FALSE);
return 0L;
}
iret = DOMGetObjectLimitedInfo(nNodeHandle,
lpName, // object name,
lpOwner, // object owner
OT_TABLE, // iobjecttype
1, // level
(unsigned char **)parentStrings, // parenthood
TRUE, // bwithsystem
&resultType,
resultObjectName,
resultOwnerName,
resultExtraData
);
if (iret == RES_ENDOFDATA)
iret = RES_ERR; // Non-existent: ERROR !!!
if (iret == RES_SUCCESS) {
LPUCHAR aparentsTemp[MAXPLEVEL];
// prepare parenthood with schema where relevant
aparentsTemp[0] = lpRecord->extra; // DBName
UCHAR bufParent1[MAXOBJECTNAME];
aparentsTemp[1] = bufParent1;
x_strcpy((char *)buf, (const char *)resultObjectName);
StringWithOwner(buf, resultOwnerName, aparentsTemp[1]); // schema.name
aparentsTemp[2] = NULL;
memset (&bufComplim, '\0', sizeof(bufComplim));
memset (&bufOwner, '\0', sizeof(bufOwner));
iret = DOMGetFirstObject(nNodeHandle,
OT_INTEGRITY,
2, // level,
aparentsTemp, // Temp mandatory!
pUps->pSFilter->bWithSystem, // bwithsystem
NULL, // lpowner
buf,
bufOwner,
bufComplim);
}
if (iret != RES_SUCCESS && iret != RES_ENDOFDATA) {
// Erroneous case!
CuNameWithOwner errItem(VDBA_MfcResourceString (IDS_DATA_UNAVAILABLE));//"<Data Unavailable>"
m_Data.m_uaTblInteg.Add(errItem);
}
else {
while (iret == RES_SUCCESS) {
CuNameWithOwner item((const char*)buf, _T("")); // no owner
m_Data.m_uaTblInteg.Add(item);
iret = DOMGetNextObject(buf, bufOwner, bufComplim);
}
}
if (m_Data.m_uaTblInteg.GetCount() == 0) {
CuNameWithOwner noItem(VDBA_MfcResourceString (IDS_E_NO_INTEGRITY));//"<No Integrity>"
m_Data.m_uaTblInteg.Add(noItem);
}
// Refresh display
RefreshDisplay();
return 0L;
}
LONG CuDlgDomPropTableGrantees::OnUpdateData (WPARAM wParam, LPARAM lParam)
{
// cast received parameters
int nNodeHandle = (int)wParam;
LPIPMUPDATEPARAMS pUps = (LPIPMUPDATEPARAMS)lParam;
ASSERT (nNodeHandle != -1);
ASSERT (pUps);
// ignore selected actions on filters
switch (pUps->nIpmHint)
{
case 0:
case FILTER_DOM_SYSTEMOBJECTS: // can be $ingres
//case FILTER_DOM_BASEOWNER:
//case FILTER_DOM_OTHEROWNER:
break;
case FILTER_DOM_BKREFRESH:
// eligible if UpdateType is compatible with DomGetFirst/Next object type,
// or is ot_virtnode, which means refresh for all whatever the type is
if (pUps->pSFilter->UpdateType != OT_VIRTNODE &&
pUps->pSFilter->UpdateType != OTLL_GRANTEE)
return 0L;
break;
case FILTER_SETTING_CHANGE:
VDBA_OnGeneralSettingChange(&m_cListCtrl);
return 0L;
default:
return 0L; // nothing to change on the display
}
// Get info on the current item
LPTREERECORD lpRecord = (LPTREERECORD)pUps->pStruct;
ASSERT (lpRecord);
ResetDisplay();
//
// Get list of Grantees
//
m_Data.m_uaTableGrantees.RemoveAll();
int iret;
LPUCHAR aparentsTemp[MAXPLEVEL];
UCHAR buf[MAXOBJECTNAME];
UCHAR bufOwner[MAXOBJECTNAME];
UCHAR bufComplim[MAXOBJECTNAME];
memset (&bufComplim, '\0', sizeof(bufComplim));
memset (&bufOwner, '\0', sizeof(bufOwner));
// prepare parenthood with schema where relevant
aparentsTemp[0] = lpRecord->extra; // parent DB Name
UCHAR bufParent1[MAXOBJECTNAME];
aparentsTemp[1] = bufParent1;
switch (lpRecord->recType) {
case OT_TABLE:
case OTR_GRANTEE_SEL_TABLE:
case OTR_GRANTEE_INS_TABLE:
case OTR_GRANTEE_UPD_TABLE:
case OTR_GRANTEE_DEL_TABLE:
case OTR_GRANTEE_REF_TABLE:
case OTR_GRANTEE_CPI_TABLE:
case OTR_GRANTEE_CPF_TABLE:
case OTR_GRANTEE_ALL_TABLE:
case OTR_LOCATIONTABLE:
case OT_REPLIC_REGTABLE:
case OT_SCHEMAUSER_TABLE:
case OTR_REPLIC_CDDS_TABLE:
x_strcpy((char *)buf, (const char *)lpRecord->objName);
break;
case OT_STATIC_TABLEGRANTEES:
x_strcpy((char *)buf, (const char *)lpRecord->extra2);
break;
default:
ASSERT (FALSE);
buf[0] = '\0';
}
ASSERT (lpRecord->ownerName);
StringWithOwner(buf, lpRecord->ownerName, aparentsTemp[1]); // schema.name
aparentsTemp[2] = NULL;
// loop on grants
BOOL bError = FALSE;
for (int index = 0; index < NBTBLGRANTEES; index++) {
iret = DOMGetFirstObject(nNodeHandle,
aGrantType[index],
2, // level,
aparentsTemp, // Temp mandatory!
pUps->pSFilter->bWithSystem, // bwithsystem
NULL, // lpowner
buf,
bufOwner,
bufComplim);
if (iret != RES_SUCCESS && iret != RES_ENDOFDATA) {
bError = TRUE;
continue;
}
else {
while (iret == RES_SUCCESS) {
// received data:
// - Grantee name in buf
CuTableGrantee grantee((const char *)buf, // Grantee name (user/group/role)
FALSE, // not special item
aGrantType[index] // grant type
);
// Solve type on the fly and SetGranteeType
int granteeType;
UCHAR resBuf[MAXOBJECTNAME];
UCHAR resBuf2[MAXOBJECTNAME];
UCHAR resBuf3[MAXOBJECTNAME];
int res = DOMGetObjectLimitedInfo(nNodeHandle,
buf,
bufOwner,
OT_GRANTEE,
0, // level
NULL, // parentstrings,
TRUE,
&granteeType,
resBuf,
resBuf2,
resBuf3);
if (res != RES_SUCCESS)
grantee.SetGranteeType(OT_ERROR);
else
grantee.SetGranteeType(granteeType);
CuMultFlag *pRefGrantee = m_Data.m_uaTableGrantees.Find(&grantee);
if (pRefGrantee)
m_Data.m_uaTableGrantees.Merge(pRefGrantee, &grantee);
else
m_Data.m_uaTableGrantees.Add(grantee);
iret = DOMGetNextObject(buf, bufOwner, bufComplim);
}
}
}
// Manage error case
if (bError)
{
/* "<Data Unavailable>" */
CuTableGrantee grantee1(VDBA_MfcResourceString (IDS_DATA_UNAVAILABLE),
TRUE);
m_Data.m_uaTableGrantees.Add(grantee1);
}
// Manage no grantee
if (m_Data.m_uaTableGrantees.GetCount() == 0)
{
/* "<No Grantee>" */
CuTableGrantee grantee2(VDBA_MfcResourceString (IDS_E_NO_GRANTEE), TRUE);
m_Data.m_uaTableGrantees.Add(grantee2);
}
ASSERT (m_Data.m_uaTableGrantees.GetCount() > 0 );
// Refresh display
RefreshDisplay();
return 0L;
}
LONG CuDlgDomPropView::OnUpdateData (WPARAM wParam, LPARAM lParam)
{
// cast received parameters
int nNodeHandle = (int)wParam;
LPIPMUPDATEPARAMS pUps = (LPIPMUPDATEPARAMS)lParam;
ASSERT (nNodeHandle != -1);
ASSERT (pUps);
// ignore selected actions on filters
switch (pUps->nIpmHint)
{
case 0:
//case FILTER_DOM_SYSTEMOBJECTS:
//case FILTER_DOM_BASEOWNER:
//case FILTER_DOM_OTHEROWNER:
break;
case FILTER_DOM_BKREFRESH_DETAIL:
if (m_Data.m_refreshParams.MustRefresh(pUps->pSFilter->bOnLoad, pUps->pSFilter->refreshtime))
break; // need to update
else
return 0; // no need to update
break;
case FILTER_SETTING_CHANGE:
VDBA_OnGeneralSettingChange(&m_clistCtrl);
return 0L;
default:
return 0L; // nothing to change on the display
}
// Get info on the object
VIEWPARAMS ViewParams;
memset (&ViewParams, 0, sizeof (ViewParams));
LPTREERECORD lpRecord = (LPTREERECORD)pUps->pStruct;
ASSERT (lpRecord);
ResetDisplay();
//
// Get Detail Info
//
x_strcpy ((char *)ViewParams.objectname, RemoveDisplayQuotesIfAny((LPCTSTR)StringWithoutOwner(lpRecord->objName)));
x_strcpy ((char *)ViewParams.szSchema, (const char *)lpRecord->ownerName);
x_strcpy ((char *)ViewParams.DBName, (const char *)lpRecord->extra);
int dummySesHndl;
int iResult = GetDetailInfo ((LPUCHAR)GetVirtNodeName(nNodeHandle),
OT_VIEW,
&ViewParams,
FALSE,
&dummySesHndl);
if (iResult != RES_SUCCESS) {
ASSERT (FALSE);
// Reset m_Data
CuDomPropDataView tempData;
tempData.m_refreshParams = m_Data.m_refreshParams;
m_Data = tempData;
// Refresh display
RefreshDisplay();
return 0L;
}
// Update refresh info
m_Data.m_refreshParams.UpdateRefreshParams();
// update member variables, for display/load/save purpose
m_Data.m_csText = ViewParams.lpViewText;
// liberate detail structure
FreeAttachedPointers (&ViewParams, OT_VIEW);
//
// Get list of view components
//
m_Data.m_acsViewComponents.RemoveAll();
m_Data.m_acsSchema.RemoveAll();
m_Data.m_awCompType.RemoveAll();
int iret;
LPUCHAR aparentsTemp[MAXPLEVEL];
UCHAR buf[MAXOBJECTNAME];
UCHAR bufOwner[MAXOBJECTNAME];
UCHAR bufComplim[MAXOBJECTNAME];
memset (&bufComplim, '\0', sizeof(bufComplim));
memset (&bufOwner, '\0', sizeof(bufOwner));
// prepare parenthood with schema where relevant
aparentsTemp[0] = lpRecord->extra; // DBName
UCHAR bufParent1[MAXOBJECTNAME];
aparentsTemp[1] = bufParent1;
x_strcpy((char *)buf, (const char *)lpRecord->objName);
StringWithOwner(buf, lpRecord->ownerName, aparentsTemp[1]); // schema.name
aparentsTemp[2] = NULL;
iret = DOMGetFirstObject(nNodeHandle,
OT_VIEWTABLE,
2, // level,
aparentsTemp, // Temp mandatory!
pUps->pSFilter->bWithSystem, // bwithsystem
NULL, // owner
buf,
bufOwner,
bufComplim);
if (iret != RES_SUCCESS && iret != RES_ENDOFDATA) {
// Erroneous case!
CString csUnavail;
csUnavail.LoadString(IDS_TM_ERR_ERR);// = "< Data Unavailable >";
m_Data.m_acsViewComponents.Add(csUnavail);
m_Data.m_acsSchema.Add(_T(""));
m_Data.m_awCompType.Add(OT_VIEWTABLE); // unresolved view component
}
else {
while (iret == RES_SUCCESS) {
m_Data.m_acsViewComponents.Add((LPCTSTR)buf);
m_Data.m_acsSchema.Add((LPCTSTR)bufOwner);
// Solve type on the fly
int viewCompType;
UCHAR resBuf[MAXOBJECTNAME];
UCHAR resBuf2[MAXOBJECTNAME];
UCHAR resBuf3[MAXOBJECTNAME];
LPUCHAR aparentsSolve[MAXPLEVEL];
aparentsSolve[0] = lpRecord->extra; // DBName
aparentsSolve[1] = aparentsSolve[2] = NULL;
int res = DOMGetObjectLimitedInfo(nNodeHandle,
buf,
bufOwner,
OT_VIEWTABLE,
1, // level
aparentsSolve, // parentstrings,
TRUE,
&viewCompType,
resBuf,
resBuf2,
resBuf3);
if (res != RES_SUCCESS)
viewCompType = OT_VIEWTABLE;
m_Data.m_awCompType.Add(viewCompType); // OT_TABLE or OT_VIEW, or OT_VIEWTABLE if error
iret = DOMGetNextObject(buf, bufOwner, bufComplim);
}
}
if (m_Data.m_acsViewComponents.GetUpperBound() == -1) {
CString csNoViewComp;
csNoViewComp.LoadString(IDS_VIEW_COMPONENTS);// = "< No View Components>";
m_Data.m_acsViewComponents.Add(csNoViewComp);
m_Data.m_acsSchema.Add(_T(""));
m_Data.m_awCompType.Add(OT_VIEWTABLE); // unresolved view component
}
// Get comment
TCHAR *lpObjComment = NULL;
LPOBJECTLIST lpObjCol = NULL;
iret = VDBAGetCommentInfo ( (LPTSTR)(LPUCHAR)GetVirtNodeName(nNodeHandle),
(LPTSTR)ViewParams.DBName, (LPTSTR)ViewParams.objectname,
(LPTSTR)ViewParams.szSchema, &lpObjComment, lpObjCol);
if (iret!=RES_SUCCESS)
{
CString csMsg;
csMsg.LoadString(IDS_NOT_AVAILABLE);
m_ctrlEditComment.SetWindowText(csMsg);
m_Data.m_csComment = csMsg;
}
else if (lpObjComment)
{
m_ctrlEditComment.SetWindowText(lpObjComment);
m_Data.m_csComment = lpObjComment;
ESL_FreeMem(lpObjComment);
}
else
{
m_ctrlEditComment.SetWindowText(_T(""));
m_Data.m_csComment.Empty();
}
//
// Refresh display
//
RefreshDisplay();
return 0L;
}
static int DOMNodeRefresh (
time_t refreshtime,
int hnodestruct,
int iobjecttype,
void * pstartoflist,
int level,
LPUCHAR * parentstrings,
void * pdispwind,
BOOL bParentRefreshed,
BOOL *pbRefreshAll,
BOOL *pbRefreshMon,
BOOL bShouldTestOnly,
BOOL * pbAnimRefreshRequired,
BOOL bFromAnimation,
HWND hwndAnimation)
{
int i, ires;
void ** pptemp;
struct ServConnectData * pdata1 = virtnode[hnodestruct].pdata;
LPDOMREFRESHPARAMS pRefreshParams;
UCHAR Parents[MAXPLEVEL][MAXOBJECTNAME];
LPUCHAR Parents4Call[MAXPLEVEL];
UCHAR bufObjectWithOwner[MAXOBJECTNAME];
BOOL bwithsystem;
BOOL bLocalParentRefreshed;
bShouldTestOnly = TRUE;
for (i=0;i<level;i++) {
fstrncpy(Parents[i], parentstrings[i], MAXOBJECTNAME);
}
for (i=0;i<MAXPLEVEL;i++) {
Parents4Call[i] = Parents[i];
}
ires = RES_SUCCESS;
switch (iobjecttype) {
case OT_VIRTNODE :
{
int itype[]={OT_DATABASE,
OT_MON_SERVER,
OT_MON_LOCKLIST,
OTLL_MON_RESOURCE,
OT_MON_LOGPROCESS,
OT_MON_LOGDATABASE,
OT_MON_TRANSACTION};
if (!pdata1)
return RES_SUCCESS;
for (i=0;i<sizeof(itype)/sizeof(int);i++) {
switch (itype[i]){
case OT_DATABASE:
pRefreshParams = &(pdata1->DBRefreshParms);
pptemp = (void **) &(pdata1->lpDBData);
bwithsystem = pdata1->HasSystemDB;
break;
case OT_MON_SERVER :
pRefreshParams = &(pdata1->ServerRefreshParms);
pptemp = (void **) &(pdata1->lpServerData);
bwithsystem = pdata1->HasSystemServers;
break;
case OT_MON_LOCKLIST :
pRefreshParams = &(pdata1->LockListRefreshParms);
pptemp = (void **) &(pdata1->lpLockListData);
bwithsystem = pdata1->HasSystemLockLists;
break;
case OTLL_MON_RESOURCE :
pRefreshParams = &(pdata1->ResourceRefreshParms);
pptemp = (void **) &(pdata1->lpResourceData);
bwithsystem = pdata1->HasSystemResources;
break;
case OT_MON_LOGPROCESS :
pRefreshParams = &(pdata1->LogProcessesRefreshParms);
pptemp = (void **) &(pdata1->lpLogProcessData);
bwithsystem = pdata1->HasSystemLogProcesses;
break;
case OT_MON_LOGDATABASE :
pRefreshParams = &(pdata1->LogDBRefreshParms);
pptemp = (void **) &(pdata1->lpLogDBData);
bwithsystem = pdata1->HasSystemLogDB;
break;
case OT_MON_TRANSACTION:
pRefreshParams = &(pdata1->LogTransactRefreshParms);
pptemp = (void **) &(pdata1->lpLogTransactData);
bwithsystem = pdata1->HasSystemLogTransact;
break;
default:
return RES_ERR;
}
bLocalParentRefreshed=FALSE;
if (*pptemp) {
if (DOMIsTimeElapsed(refreshtime,pRefreshParams, bParentRefreshed)) {
if (bShouldTestOnly) {
*pbAnimRefreshRequired = TRUE;
return RES_SUCCESS;
}
}
}
DOMNodeRefresh (refreshtime, hnodestruct, itype[i], *pptemp,
level,Parents4Call, pdispwind, bLocalParentRefreshed, pbRefreshAll, pbRefreshMon,
bShouldTestOnly,pbAnimRefreshRequired,bFromAnimation, hwndAnimation);
}
}
break;
case OT_DATABASE :
{
struct DBData * pDBData = (struct DBData * )pstartoflist;
int itype[]={OT_TABLE,
OT_MON_REPLIC_SERVER};
while (pDBData) {
fstrncpy(Parents[0],pDBData->DBName,MAXOBJECTNAME);
for (i=0;i<sizeof(itype)/sizeof(int);i++) {
switch (itype[i]){
case OT_TABLE:
pRefreshParams = &(pDBData->TablesRefreshParms);
pptemp = (void **) &(pDBData -> lpTableData);
bwithsystem = pDBData->HasSystemTables;
break;
case OT_MON_REPLIC_SERVER:
pRefreshParams =&(pDBData->MonReplServerRefreshParms);
pptemp = (void **) &(pDBData -> lpMonReplServerData);
bwithsystem = pDBData->HasSystemMonReplServers;
break;
default:
return RES_ERR;
}
bLocalParentRefreshed=FALSE;
if (*pptemp) {
if (DOMIsTimeElapsed(refreshtime,pRefreshParams, bParentRefreshed)) {
if (bShouldTestOnly) {
*pbAnimRefreshRequired = TRUE;
return RES_SUCCESS;
}
}
}
DOMNodeRefresh (refreshtime, hnodestruct, itype[i], *pptemp,
1,Parents4Call, pdispwind, bLocalParentRefreshed, pbRefreshAll, pbRefreshMon,
bShouldTestOnly,pbAnimRefreshRequired,bFromAnimation, hwndAnimation);
}
pDBData=pDBData->pnext;
}
}
break;
case OT_MON_SESSION :
case OT_MON_LOCK :
case OT_MON_RES_LOCK :
case OT_MON_LOGPROCESS :
case OT_MON_LOGDATABASE :
case OT_MON_TRANSACTION :
case OT_MON_REPLIC_SERVER :
case OTLL_MON_RESOURCE :
case OT_MON_ICE_CONNECTED_USER:
case OT_MON_ICE_ACTIVE_USER :
case OT_MON_ICE_TRANSACTION :
case OT_MON_ICE_CURSOR :
case OT_MON_ICE_FILEINFO :
case OT_MON_ICE_DB_CONNECTION :
case OT_ICE_ROLE:
case OT_ICE_DBUSER:
case OT_ICE_DBCONNECTION:
case OT_ICE_SERVER_APPLICATION:
case OT_ICE_SERVER_LOCATION:
case OT_ICE_SERVER_VARIABLE:
case OT_ICE_BUNIT_SEC_ROLE:
case OT_ICE_BUNIT_SEC_USER:
case OT_ICE_BUNIT_LOCATION:
case OT_ICE_WEBUSER_ROLE:
case OT_ICE_WEBUSER_CONNECTION:
case OT_ICE_PROFILE_ROLE:
case OT_ICE_PROFILE_CONNECTION:
case OT_ICE_BUNIT_FACET_ROLE :
case OT_ICE_BUNIT_FACET_USER :
case OT_ICE_BUNIT_PAGE_ROLE :
case OT_ICE_BUNIT_PAGE_USER :
return RES_SUCCESS; // no children
break;
case OT_USER :
return RES_SUCCESS; // no children
break;
case OT_TABLE :
{
struct TableData * pTableData = (struct TableData * )pstartoflist;
BOOL bUsed;
int itype[]={OT_COLUMN};
while (pTableData) {
fstrncpy(Parents[1],
StringWithOwner(pTableData->TableName,
pTableData->TableOwner,
bufObjectWithOwner),
MAXOBJECTNAME);
for (i=0;i<sizeof(itype)/sizeof(int);i++) {
bUsed = TRUE;
switch (itype[i]){
case OT_COLUMN:
pRefreshParams=&(pTableData->ColumnsRefreshParms);
pptemp = (void **) &(pTableData->lpColumnData);
bwithsystem = pTableData->HasSystemColumns;
break;
default:
return RES_ERR;
}
bLocalParentRefreshed=FALSE;
if (*pptemp) {
if (bUsed && DOMIsTimeElapsed(refreshtime,pRefreshParams, bParentRefreshed)) {
if (bShouldTestOnly) {
*pbAnimRefreshRequired = TRUE;
return RES_SUCCESS;
}
}
}
DOMNodeRefresh (refreshtime, hnodestruct, itype[i], *pptemp,
1,Parents4Call, pdispwind, bLocalParentRefreshed, pbRefreshAll, pbRefreshMon,
bShouldTestOnly,pbAnimRefreshRequired,bFromAnimation, hwndAnimation);
}
pTableData=pTableData->pnext;
}
}
break;
case OT_MON_SERVER :
{
struct ServerData * pServerdata = (struct ServerData * )pstartoflist;
int itype[]={OT_MON_SESSION,
OT_MON_ICE_CONNECTED_USER,
OT_MON_ICE_ACTIVE_USER,
OT_MON_ICE_TRANSACTION,
OT_MON_ICE_CURSOR,
OT_MON_ICE_FILEINFO,
OT_MON_ICE_DB_CONNECTION};
while (pServerdata) {
for (i=0;i<sizeof(itype)/sizeof(int);i++) {
switch (itype[i]){
case OT_MON_SESSION:
pRefreshParams=&(pServerdata->ServerSessionsRefreshParms);
pptemp = (void **)&(pServerdata->lpServerSessionData);
bwithsystem = pServerdata->HasSystemServerSessions;
break;
case OT_MON_ICE_CONNECTED_USER:
pRefreshParams=&(pServerdata->IceConnUsersRefreshParms);
pptemp = (void **)&(pServerdata->lpIceConnUsersData);
bwithsystem = pServerdata->HasSystemIceConnUsers;
break;
case OT_MON_ICE_ACTIVE_USER:
pRefreshParams=&(pServerdata->IceActiveUsersRefreshParms);
pptemp = (void **)&(pServerdata->lpIceActiveUsersData);
bwithsystem = pServerdata->HasSystemIceActiveUsers;
break;
case OT_MON_ICE_TRANSACTION:
pRefreshParams=&(pServerdata->IceTransactionsRefreshParms);
pptemp = (void **)&(pServerdata->lpIceTransactionsData);
bwithsystem = pServerdata->HasSystemIceTransactions;
break;
case OT_MON_ICE_CURSOR:
pRefreshParams=&(pServerdata->IceCursorsRefreshParms);
pptemp = (void **)&(pServerdata->lpIceCursorsData);
bwithsystem = pServerdata->HasSystemIceCursors;
break;
case OT_MON_ICE_FILEINFO:
pRefreshParams=&(pServerdata->IceCacheRefreshParms);
pptemp = (void **)&(pServerdata->lpIceCacheInfoData);
bwithsystem = pServerdata->HasSystemIceCacheInfo;
break;
case OT_MON_ICE_DB_CONNECTION:
pRefreshParams=&(pServerdata->IceDbConnectRefreshParms);
pptemp = (void **)&(pServerdata->lpIceDbConnectData);
bwithsystem = pServerdata->HasSystemIceDbConnectInfo;
break;
default:
return RES_ERR;
}
bLocalParentRefreshed=FALSE;
if (*pptemp) {
if (DOMIsTimeElapsed(refreshtime,pRefreshParams, bParentRefreshed)) {
if (bShouldTestOnly) {
*pbAnimRefreshRequired = TRUE;
return RES_SUCCESS;
}
}
}
DOMNodeRefresh (refreshtime, hnodestruct, itype[i], *pptemp,
0,(LPUCHAR *)&(pServerdata->ServerDta), pdispwind, bLocalParentRefreshed, pbRefreshAll, pbRefreshMon,
bShouldTestOnly,pbAnimRefreshRequired,bFromAnimation, hwndAnimation);
}
pServerdata=pServerdata->pnext;
}
}
break;
case OT_MON_LOCKLIST :
{
struct LockListData * pLockListdata = (struct LockListData * )pstartoflist;
int itype[]={OT_MON_LOCK};
while (pLockListdata) {
for (i=0;i<sizeof(itype)/sizeof(int);i++) {
switch (itype[i]){
case OT_MON_LOCK:
pRefreshParams=&(pLockListdata->LocksRefreshParms);
pptemp = (void **)&(pLockListdata->lpLockData);
bwithsystem = pLockListdata->HasSystemLocks;
break;
default:
return RES_ERR;
}
bLocalParentRefreshed=FALSE;
if (*pptemp) {
if (DOMIsTimeElapsed(refreshtime,pRefreshParams, bParentRefreshed)) {
if (bShouldTestOnly) {
*pbAnimRefreshRequired = TRUE;
return RES_SUCCESS;
}
}
}
DOMNodeRefresh (refreshtime, hnodestruct, itype[i], *pptemp,
0,(LPUCHAR *)&(pLockListdata->LockListDta), pdispwind, bLocalParentRefreshed, pbRefreshAll, pbRefreshMon,
bShouldTestOnly,pbAnimRefreshRequired,bFromAnimation, hwndAnimation);
}
pLockListdata=pLockListdata->pnext;
}
}
break;
case OT_VIEW :
{
struct ViewData * pViewData = (struct ViewData * )pstartoflist;
int itype[]={OT_VIEWTABLE,
OT_VIEWCOLUMN };
while (pViewData) {
fstrncpy(Parents[1],
StringWithOwner(pViewData->ViewName,
pViewData->ViewOwner,
bufObjectWithOwner),
MAXOBJECTNAME);
for (i=0;i<sizeof(itype)/sizeof(int);i++) {
switch (itype[i]){
case OT_VIEWTABLE:
pRefreshParams=&(pViewData->ViewTablesRefreshParms);
pptemp = (void **) &(pViewData->lpViewTableData);
bwithsystem = pViewData->HasSystemViewTables;
break;
case OT_VIEWCOLUMN:
pRefreshParams=&(pViewData->ColumnsRefreshParms);
pptemp = (void **) &(pViewData->lpColumnData);
bwithsystem = pViewData->HasSystemColumns;
break;
default:
return RES_ERR;
}
bLocalParentRefreshed=FALSE;
if (*pptemp) {
if (DOMIsTimeElapsed(refreshtime,pRefreshParams, bParentRefreshed)) {
if (bShouldTestOnly) {
*pbAnimRefreshRequired = TRUE;
return RES_SUCCESS;
}
}
}
DOMNodeRefresh (refreshtime, hnodestruct, itype[i], *pptemp,
1,Parents4Call, pdispwind, bLocalParentRefreshed, pbRefreshAll, pbRefreshMon,
bShouldTestOnly,pbAnimRefreshRequired,bFromAnimation, hwndAnimation);
}
pViewData=pViewData->pnext;
}
}
break;
case OT_COLUMN :
return RES_SUCCESS;
break;
default:
{
return myerror(ERR_OBJECTNOEXISTS);
}
break;
}
return ires;
}
BOOL CxDlgObjectComment::InitializeObjectColumns()
{
TCHAR tblNameWithOwner[MAXOBJECTNAME];
int ires, nLevel = 2;
LPUCHAR aparents [MAXPLEVEL];
TCHAR tchszBuf [MAXOBJECTNAME];
TCHAR tchszOwner [MAXOBJECTNAME];
TCHAR tchszBufComplim[MAXOBJECTNAME];
LPTSTR lpszOwner = NULL;
BOOL bSystem = FALSE;
if (m_iCurObjType != OT_TABLE && m_iCurObjType != OT_VIEW)
return FALSE;
StringWithOwner((LPUCHAR)Quote4DisplayIfNeeded((LPTSTR)(LPCTSTR)m_csObjectName),
(LPUCHAR)(LPTSTR)(LPCTSTR) m_csObjectOwner, (LPUCHAR)tblNameWithOwner);
aparents[0] = (LPUCHAR)(LPCTSTR)m_csDBName;
aparents[1] = (LPUCHAR)tblNameWithOwner;
aparents[2] = NULL;
nLevel = 2;
tchszBuf[0] = 0;
tchszOwner[0] = 0;
tchszBufComplim[0] = 0;
LPOBJECTLIST lpColTemp;
LPCOMMENTCOLUMN lpCommentCol;
ires = DOMGetFirstObject( m_nNodeHandle,
(m_iCurObjType == OT_TABLE)? OT_COLUMN: OT_VIEWCOLUMN,
nLevel,
aparents,
bSystem,
NULL,
(LPUCHAR)tchszBuf,
(LPUCHAR)tchszOwner,
(LPUCHAR)tchszBufComplim);
if (ires != RES_SUCCESS && ires != RES_ENDOFDATA)
{
CString csMsg;
csMsg.LoadString(IDS_E_COMMENTS_FAILED);
MessageWithHistoryButton(m_hWnd,csMsg);
return FALSE;
}
while (ires == RES_SUCCESS)
{
lpColTemp = AddListObjectTail(&m_ListColumn, sizeof(COMMENTCOLUMN));
if (!lpColTemp)
{
// Need to free previously allocated objects.
ErrorMessage ( (UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
FreeObjectList(m_ListColumn);
m_ListColumn = NULL;
return FALSE;
}
lpCommentCol = (LPCOMMENTCOLUMN)lpColTemp->lpObject;
lstrcpy((LPTSTR)lpCommentCol->szColumnName,tchszBuf);
lpCommentCol->lpszComment = NULL;
tchszBuf[0] = 0;
tchszOwner[0] = 0;
tchszBufComplim[0] = 0;
ires = DOMGetNextObject ((LPUCHAR)tchszBuf, (LPUCHAR)tchszOwner, (LPUCHAR)tchszBufComplim);
}
return TRUE;
}
static BOOL FillStructureFromControls (HWND hwnd, LPSECURITYALARMPARAMS lpsecurity)
{
char buf [MAXOBJECTNAME];
char buffowner [MAXOBJECTNAME];
char bufftable [MAXOBJECTNAME];
LPCHECKEDOBJECTS obj;
LPCHECKEDOBJECTS list = NULL;
int i, max_database_number, checked;
HWND hwndUsers = GetDlgItem (hwnd, IDC_REFALARM_BYUSER );
HWND hwndTables = GetDlgItem (hwnd, IDC_REFALARM_ONTABLE);
HWND hwndSuccess = GetDlgItem (hwnd, IDC_REFALARM_SUCCESS);
HWND hwndFailure = GetDlgItem (hwnd, IDC_REFALARM_FAILURE);
HWND hwndSelect = GetDlgItem (hwnd, IDC_REFALARM_SELECT);
HWND hwndDelete = GetDlgItem (hwnd, IDC_REFALARM_DELETE);
HWND hwndInsert = GetDlgItem (hwnd, IDC_REFALARM_INSERT);
HWND hwndUpdate = GetDlgItem (hwnd, IDC_REFALARM_UPDATE);
lpsecurity->bsuccfail [SECALARMSUCCESS] = Button_GetCheck (hwndSuccess);
lpsecurity->bsuccfail [SECALARMFAILURE] = Button_GetCheck (hwndFailure);
//
// Get selection from
// toggle buttons (Select, Delete, Insert, Update)
//
lpsecurity->baccesstype [SECALARMSEL] = Button_GetCheck (hwndSelect);
lpsecurity->baccesstype [SECALARMDEL] = Button_GetCheck (hwndDelete);
lpsecurity->baccesstype [SECALARMINS] = Button_GetCheck (hwndInsert);
lpsecurity->baccesstype [SECALARMUPD] = Button_GetCheck (hwndUpdate);
//
// Get the names of users that have been checked and
// insert into the list
//
max_database_number = CAListBox_GetCount (hwndUsers);
for (i=0; i<max_database_number; i++)
{
checked = CAListBox_GetSel (hwndUsers, i);
if (checked)
{
CAListBox_GetText (hwndUsers, i, buf);
obj = ESL_AllocMem (sizeof (CHECKEDOBJECTS));
if (!obj)
{
FreeAttachedPointers (lpsecurity, OTLL_SECURITYALARM);
ErrorMessage ((UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
break;
}
else
{
if (x_strcmp (buf, lppublicdispstring()) == 0)
x_strcpy (obj->dbname, lppublicsysstring());
else
x_strcpy (obj->dbname, buf);
obj->bchecked = TRUE;
list = AddCheckedObject (list, obj);
}
}
}
lpsecurity->lpfirstUser = list;
//
// Get the names of Tables that have been checked and
// insert into the list
//
max_database_number = CAListBox_GetCount (hwndTables);
list = NULL;
for (i = 0; i < max_database_number; i++)
{
checked = CAListBox_GetSel (hwndTables, i);
if (checked)
{
CAListBox_GetText (hwndTables, i, buf);
x_strcpy (buffowner, (char *) CAListBox_GetItemData (hwndTables, i));
obj = ESL_AllocMem (sizeof (CHECKEDOBJECTS));
if (!obj)
{
FreeAttachedPointers (lpsecurity, OTLL_SECURITYALARM);
ErrorMessage ((UINT)IDS_E_CANNOT_ALLOCATE_MEMORY, RES_ERR);
return FALSE;
}
else
{
StringWithOwner (buf, buffowner, bufftable);
x_strcpy (obj->dbname, bufftable);
obj->bchecked = TRUE;
list = AddCheckedObject (list, obj);
}
}
}
lpsecurity->lpfirstTable = list;
return TRUE;
}
