Добавлена возможность использования мультипараметров

This commit is contained in:
Alexander Zhirov 2022-07-08 19:45:45 +03:00
parent 3b6a0a433a
commit 5a6aef9424
10 changed files with 583 additions and 353 deletions

View File

@ -8,51 +8,51 @@
#include <stdlib.h> #include <stdlib.h>
#include "arguments.h" #include "arguments.h"
#include "node_settings.h" #include "node_settings.h"
#include "concat.h"
void settingsLoad() void settingsLoad()
{ {
settingsAddKey(PARAMETER_XFREERDP, "xfreerdp", false, true); addParameterKey(PARAMETER_XFREERDP, "xfreerdp", true, true);
settingsAddKey(PARAMETER_SERVER, "/v:", true, true); addParameterKey(PARAMETER_SERVER, "/v:", true, true);
settingsAddKey(PARAMETER_USERNAME, "/u:", true, true); addParameterKey(PARAMETER_USERNAME, "/u:", true, true);
settingsAddKey(PARAMETER_PASSWORD, "/p:", true, true); addParameterKey(PARAMETER_PASSWORD, "/p:", true, true);
settingsAddKey(PARAMETER_MULTIMONITOR, "/multimon", false, true); addParameterKey(PARAMETER_MULTIMONITOR, "/multimon", true, true);
settingsAddKey(PARAMETER_FULLSCREEN, "/f", false, true); addParameterKey(PARAMETER_FULLSCREEN, "/f", true, true);
settingsAddKey(PARAMETER_AUTHENTICATION, "-authentication", false, true); addParameterKey(PARAMETER_AUTHENTICATION, "-authentication", true, true);
settingsAddKey(PARAMETER_SECURITY, "/sec:", false, true); addParameterKey(PARAMETER_SECURITY, "/sec:", true, true);
addParameterValue(PARAMETER_SECURITY, VALUE_SECURITY_TLS, "tls", true);
// settingsAddKey(PARAMETER_SECURITY_TLS, "-authentication", false, true); addParameterValue(PARAMETER_SECURITY, VALUE_SECURITY_RDP, "rdp", false);
// settingsAddKey(PARAMETER_SECURITY_RDP, "-authentication", false, true); addParameterValue(PARAMETER_SECURITY, VALUE_SECURITY_NLA, "nla", false);
// settingsAddKey(PARAMETER_SECURITY_NLA, "-authentication", false, true); addParameterValue(PARAMETER_SECURITY, VALUE_SECURITY_EXT, "ext", false);
// settingsAddKey(PARAMETER_SECURITY_EXT, "-authentication", false, true);
} }
Arguments *buildArguments() void settingsFree()
{ {
Arguments *args = (Arguments *)malloc(sizeof(Arguments)); freeSettings();
args->argc = settings.countEnable; }
args->argv = (char **)malloc(sizeof(char *) * settings.countEnable);
Node *head = settings.next;
for (size_t i = 0; i < settings.countEnable; head = head->next) void buildArguments(Arguments *args)
{
args->argc = 0;
args->argv = (char **)malloc(sizeof(char *) * settings.countParameterSet);
for (NodeParameter *head = settings.parameter; head; head = head->next)
{ {
if (head->enable) if (head->set)
{ {
if (head->data->isValue) if (head->value)
{ args->argv[(args->argc)++] = concat(head->key, getSetNodeValue(head)->current);
args->argv[i++] = head->data->fullArgument;
}
else else
{ args->argv[(args->argc)++] = concat(head->key, NULL);
args->argv[i++] = head->data->key;
} }
} }
}
return args;
} }
void freeArguments(Arguments *args) void freeArguments(Arguments *args)
{ {
for (int i = 0; i < args->argc; ++i)
{
free(args->argv[i]);
}
free(args->argv); free(args->argv);
free(args);
} }

View File

@ -14,8 +14,10 @@ typedef struct
char **argv; char **argv;
} Arguments; } Arguments;
void buildArguments(Arguments *args);
void freeArguments(Arguments *args);
void settingsLoad(); void settingsLoad();
Arguments *buildArguments(); void settingsFree();
void freeArguments();
#endif /* ARGUMENTS_H_ */ #endif /* ARGUMENTS_H_ */

View File

@ -16,7 +16,7 @@ char* concat(char *s1, char *s2)
size_t len1 = s1 ? strlen(s1) : 0; size_t len1 = s1 ? strlen(s1) : 0;
size_t len2 = s2 ? strlen(s2) : 0; size_t len2 = s2 ? strlen(s2) : 0;
char *result = malloc(len1 + len2 + 1); char *result = (char *)malloc(sizeof(char) * (len1 + len2 + 1));
if (!result) if (!result)
{ {
@ -26,11 +26,11 @@ char* concat(char *s1, char *s2)
if (s1) if (s1)
{ {
memcpy(result, s1, len1); strcpy(result, s1);
} }
if (s2) if (s2)
{ {
memcpy(result + len1, s2, len2 + 1); strcpy(result + len1, s2);
} }
return result; return result;

16
gui.c
View File

@ -22,18 +22,18 @@ static int guiExit(Ihandle *self)
static int guiConnect(Ihandle *self) static int guiConnect(Ihandle *self)
{ {
settingsSetValue(PARAMETER_SERVER, IupGetAttribute(IupGetDialogChild(self, "SERVER"), "LINEVALUE")); setParameterValue(PARAMETER_SERVER, VALUE_SERVER, IupGetAttribute(IupGetDialogChild(self, "SERVER"), "LINEVALUE"));
settingsSetValue(PARAMETER_USERNAME, IupGetAttribute(IupGetDialogChild(self, "USER"), "LINEVALUE")); setParameterValue(PARAMETER_USERNAME, VALUE_USERNAME, IupGetAttribute(IupGetDialogChild(self, "USER"), "LINEVALUE"));
settingsSetValue(PARAMETER_PASSWORD, IupGetAttribute(IupGetDialogChild(self, "PASSWORD"), "LINEVALUE")); setParameterValue(PARAMETER_PASSWORD, VALUE_PASSWORD, IupGetAttribute(IupGetDialogChild(self, "PASSWORD"), "LINEVALUE"));
Arguments *args = buildArguments(); Arguments args;
for (int i = 0; i < args->argc; ++i) buildArguments(&args);
for (int i = 0; i < args.argc; ++i)
{ {
printf("%s\n", args->argv[i]); printf("%s\n", args.argv[i]);
} }
printf("\n"); printf("\n");
freeArguments(&args);
freeArguments(args);
return IUP_DEFAULT; return IUP_DEFAULT;
} }

3
main.c
View File

@ -1,8 +1,9 @@
#include <stdlib.h> #include <stdlib.h>
#include "gui.h" #include "gui.h"
#include "node_settings.h"
#include "arguments.h" #include "arguments.h"
#include <stdio.h>
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
settingsLoad(); settingsLoad();

View File

@ -7,40 +7,91 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <stdio.h>
#include "node_settings.h" #include "node_settings.h"
#include "concat.h" #include "concat.h"
HeadNode settings = {0, 0, NULL}; NodeHead settings =
{ NULL, 0 };
static Node* settingsCreateNode() static NodeValue* newNodeValue(Value name, char *current, bool set)
{ {
Node *node = (Node*) malloc(sizeof(Node)); NodeValue *node = (NodeValue*) malloc(sizeof(NodeValue));
node->parameter = PARAMETER_NULL; node->name = name;
node->set = set;
node->change = false;
node->next = NULL; node->next = NULL;
node->data = (SettingsData*)malloc(sizeof(SettingsData));
node->data->key = NULL; node->current = (char*) malloc(sizeof(char) * strlen(current));
node->data->value = NULL; strcpy(node->current, current);
node->data->fullArgument = NULL;
return node; return node;
} }
/* static void freeNodeValue(NodeValue *node)
* Если передан параметр PARAMETER_NULL, то возвращается последний действующий узел.
* Если возврат NULL, то ни одного узла не существует.
* Если передан параметр отличный от PARAMETER_NULL, то ищется существующий узел с этим параметром.
* Если возврат NULL, то узла с таким параметром не найдено.
*/
Node *settingsGetNode(SettingsParameters parameter)
{ {
if (!settings.countAll) if (node)
{ {
return NULL; free(node->current);
free(node);
} }
}
Node *head = settings.next; static void freeAllNodeValue(NodeValue *node)
{
NodeValue *next = NULL;
for (NodeValue *head = node; head; head = next)
{
next = head->next;
freeNodeValue(head);
}
}
if (parameter == PARAMETER_NULL) static NodeParameter* newNodeParameter(Parameter name, char *key, bool set, bool singleValue)
{
NodeParameter *node = (NodeParameter*) malloc(sizeof(NodeParameter));
node->name = name;
node->set = set;
node->change = false;
node->value = NULL;
node->countValue = 0;
node->singleValue = singleValue;
node->next = NULL;
node->key = (char*) malloc(sizeof(char) * strlen(key));
strcpy(node->key, key);
return node;
}
static void freeNodeParameter(NodeParameter *node)
{
if (node)
{
freeAllNodeValue(node->value);
free(node->key);
free(node);
}
}
static void freeAllNodeParameter(NodeParameter *node)
{
NodeParameter *next = NULL;
for (NodeParameter *head = node; head; head = next)
{
next = head->next;
freeNodeParameter(head);
}
}
///////////////////////////////
static NodeParameter* getLastNodeParameter()
{
NodeParameter *head = settings.parameter;
if (head)
{ {
while (head->next) while (head->next)
{ {
@ -49,9 +100,14 @@ Node *settingsGetNode(SettingsParameters parameter)
return head; return head;
} }
for (; head; head = head->next) return NULL;
}
static NodeParameter* getNodeParameter(Parameter name)
{
for (NodeParameter *head = settings.parameter; head; head = head->next)
{ {
if (head->parameter == parameter) if (head->name == name)
{ {
return head; return head;
} }
@ -60,206 +116,318 @@ Node *settingsGetNode(SettingsParameters parameter)
return NULL; return NULL;
} }
void settingsAddKey(SettingsParameters parameter, char *key, bool isValue, bool enable) void addParameterKey(Parameter name, char *key, bool set, bool singleValue)
{ {
Node *newNode = settingsCreateNode(); if (!settings.parameter)
newNode->parameter = parameter;
newNode->enable = enable;
newNode->change = false;
SettingsData *data = newNode->data;
data->isValue = isValue;
size_t len = strlen(key);
data->key = (char *) malloc(sizeof(char) * (len + 1));
memcpy(data->key, key, len);
Node *lastNode = settingsGetNode(PARAMETER_NULL);
if (lastNode)
{ {
lastNode->next = newNode; settings.parameter = newNodeParameter(name, key, set, singleValue);
++settings.countParameter;
if (set)
{
++settings.countParameterSet;
} }
else
{
settings.next = newNode;
}
if (enable)
{
++settings.countEnable;
}
++settings.countAll;
}
void settingsSetValue(SettingsParameters parameter, char *value)
{
Node *currentNode = settingsGetNode(parameter);
if (!currentNode || !currentNode->data->isValue)
{
return; return;
} }
if (!strlen(value)) NodeParameter *node = getNodeParameter(name);
if (node)
{ {
settingsSetEnable(parameter, false); fprintf(stderr, "%s \"%s\" %s", "Параметр", key, "уже существует!\n");
}
else
{
node = getLastNodeParameter();
node->next = newNodeParameter(name, key, set, singleValue);
++settings.countParameter;
if (set)
{
++settings.countParameterSet;
}
}
}
static NodeValue* getLastNodeValue(NodeParameter *node)
{
NodeValue *head = node->value;
if (head)
{
while (head->next)
{
head = head->next;
}
return head;
}
return NULL;
}
static NodeValue* getNodeValue(NodeParameter *node, Value name)
{
for (NodeValue *head = node->value; head; head = head->next)
{
if (head->name == name)
{
return head;
}
}
return NULL;
}
void addParameterValue(Parameter pName, Value vName, char *current, bool set)
{
NodeParameter *nodeParameter = getNodeParameter(pName);
if (!nodeParameter)
{
fprintf(stderr, "%s \"%s\" %s", "Параметр для значения", current, "не существует!\n");
return;
}
if (!nodeParameter->value)
{
nodeParameter->value = newNodeValue(vName, current, set);
++nodeParameter->countValue;
if (set)
{
++nodeParameter->countValueSet;
}
return;
}
NodeValue *nodeValue = getNodeValue(nodeParameter, vName);
if (nodeValue)
{
fprintf(stderr, "%s \"%s\" %s", "Значение", current, "уже существует!\n");
}
else
{
nodeValue = getLastNodeValue(nodeParameter);
nodeValue->next = newNodeValue(vName, current, set);
++nodeParameter->countValue;
if (set)
{
++nodeParameter->countValueSet;
}
}
}
void freeSettings()
{
if (settings.parameter)
{
freeAllNodeParameter(settings.parameter);
}
}
/////////////////////////////////////////////////////////////
NodeValue* getSetNodeValue(NodeParameter *node)
{
for (NodeValue *head = node->value; head; head = head->next)
{
if (head->set)
{
return head;
}
}
return NULL;
}
////////////////////////////////////////////////////////////////
void setParameterValue(Parameter pName, Value vName, char *current)
{
NodeParameter *nodeParameter = getNodeParameter(pName);
if (!nodeParameter)
{
fprintf(stderr, "%s \"%s\" %s", "Параметр для значения", current, "не существует!\n");
return;
}
size_t length = strlen(current);
if (!length)
{
if (nodeParameter->set)
{
nodeParameter->set = false;
--settings.countParameterSet;
}
return; return;
} }
else else
{ {
settingsSetEnable(parameter, true); if (!nodeParameter->set)
{
nodeParameter->set = true;
++settings.countParameterSet;
}
} }
SettingsData *data = currentNode->data; if (!nodeParameter->value)
if (data->value)
{
free(data->value);
}
if (data->fullArgument)
{
free(data->fullArgument);
}
size_t len = strlen(value);
data->value = (char *) malloc(sizeof(char) * (len + 1));
memcpy(data->value, value, len);
data->fullArgument = concat(data->key, value);
}
void settingsSetEnable(SettingsParameters parameter, bool enable)
{
Node *currentNode = settingsGetNode(parameter);
if (!currentNode)
{ {
nodeParameter->value = newNodeValue(vName, current, true);
++nodeParameter->countValue;
++nodeParameter->countValueSet;
return; return;
} }
if (currentNode->enable && !enable)
{
--settings.countEnable;
}
else if (!currentNode->enable && enable)
{
++settings.countEnable;
}
currentNode->enable = enable;
}
void settingsToggleEnable(SettingsParameters parameter) NodeValue *nodeValue = getNodeValue(nodeParameter, vName);
{
Node *currentNode = settingsGetNode(parameter); if (nodeValue)
if (!currentNode)
{ {
return; free(nodeValue->current);
} nodeValue->current = (char*) malloc(sizeof(char) * length);
if (currentNode->enable) strcpy(nodeValue->current, current);
{
--settings.countEnable;
} }
else else
{ {
++settings.countEnable; nodeValue = getLastNodeValue(nodeParameter);
nodeValue->next = newNodeValue(vName, current, true);
++nodeParameter->countValue;
++nodeParameter->countValueSet;
} }
currentNode->enable = !currentNode->enable;
changeValue(pName, vName);
} }
void settingsToggleChange(SettingsParameters parameter) ////////////////////////////////////////////////////////////////
void changeParameter(Parameter name)
{ {
Node *currentNode = settingsGetNode(parameter); NodeParameter *node = getNodeParameter(name);
if (!currentNode) node->change = !node->change;
{
return;
}
currentNode->change = !currentNode->change;
} }
void settingsResetChange() void changeValue(Parameter pName, Value vName)
{ {
if (!settings.countAll) NodeParameter *pNode = getNodeParameter(pName);
for (NodeValue *head = pNode->value; head; head = head->next)
{ {
return; if (pNode->singleValue)
{
head->change = head->name == vName && !head->set;
}
else
{
// ДОРАБОТАТЬ НА ИСПОЛЬЗОВАНИЕ МНОГИХ ПАРАМЕТРОВ
head->change = head->name == vName;
}
}
}
static void saveChangeSingleValueSettings(NodeParameter *node)
{
NodeValue *nChange = NULL;
NodeValue *nSet = NULL;
for (NodeValue *head = node->value; head; head = head->next)
{
if (head->change)
{
nChange = head;
}
if (head->set)
{
nSet = head;
}
} }
for (Node *head = settings.next; head; head = head->next) if (nChange)
{
nChange->change = false;
nChange->set = true;
nSet->set = false;
++node->countValueSet;
}
}
static void saveChangeValueSettings(NodeParameter *node)
{
for (NodeValue *head = node->value; head; head = head->next)
{ {
if (head->change) if (head->change)
{ {
head->change = false; head->change = false;
head->set = !head->set;
}
if (head->set)
{
++node->countValueSet;
} }
} }
} }
void settingsSaveSettings() void saveChangeSettings()
{ {
if (!settings.countAll) settings.countParameterSet = 0;
for (NodeParameter *pHead = settings.parameter; pHead; pHead = pHead->next)
{ {
return; if (pHead->change)
{
pHead->change = false;
pHead->set = !pHead->set;
}
if (pHead->set)
{
++settings.countParameterSet;
} }
for (Node *head = settings.next; head; head = head->next) pHead->countValueSet = 0;
{
if (head->change)
{
head->change = false;
if (head->enable) if (pHead->singleValue)
{ saveChangeSingleValueSettings(pHead);
--settings.countEnable;
}
else else
{ saveChangeValueSettings(pHead);
++settings.countEnable;
} }
head->enable = !head->enable; }
void resetChangeSettings()
{
for (NodeParameter *pHead = settings.parameter; pHead; pHead = pHead->next)
{
pHead->change = false;
for (NodeValue *vHead = pHead->value; vHead; vHead = vHead->next)
{
vHead->change = false;
} }
} }
} }
bool settingsGetEnable(SettingsParameters parameter) bool getSetParameter(Parameter name)
{ {
Node *currentNode = settingsGetNode(parameter); NodeParameter *node = getNodeParameter(name);
if (!currentNode) if (!node)
{ {
return false; return false;
} }
return currentNode->enable; return node->set;
} }
static void settingsFreeData(SettingsData *data) bool getSetValue(Parameter pName, Value vName)
{ {
if (data->key) NodeParameter *pNode = getNodeParameter(pName);
if (!pNode)
{ {
free(data->key); return false;
} }
if (data->value)
for (NodeValue *vNode = pNode->value; vNode; vNode = vNode->next)
{ {
free(data->value); if (vNode->name == vName)
}
if (data->fullArgument)
{ {
free(data->fullArgument); return vNode->set;
} }
free(data); }
}
return false;
void settingsFree()
{
if (!settings.countAll)
{
return;
}
Node *head = settings.next;
Node *current = NULL;
while (head->next)
{
current = head->next;
settingsFreeData(head->data);
free(head);
head = current;
}
settingsFreeData(head->data);
free(head);
settings.next = NULL;
} }

View File

@ -10,58 +10,52 @@
#include <stdbool.h> #include <stdbool.h>
typedef enum #include "parameter.h"
{ #include "value.h"
PARAMETER_NULL,
PARAMETER_XFREERDP,
PARAMETER_USERNAME,
PARAMETER_SERVER,
PARAMETER_PASSWORD,
PARAMETER_MULTIMONITOR,
PARAMETER_FULLSCREEN,
PARAMETER_AUTHENTICATION,
PARAMETER_SECURITY
} SettingsParameters;
typedef struct typedef struct NodeValue
{ {
char *key; Value name;
char *value; bool set;
char *fullArgument;
bool isValue;
} SettingsData;
typedef struct Node
{
SettingsParameters parameter;
bool change; bool change;
bool enable; char *current;
SettingsData *data; struct NodeValue *next;
struct Node *next; } NodeValue;
} Node;
typedef struct typedef struct NodeParameter
{ {
size_t countAll; Parameter name;
size_t countEnable; bool set;
struct Node *next; bool change;
} HeadNode; char *key;
NodeValue *value;
bool singleValue;
size_t countValue;
size_t countValueSet;
struct NodeParameter *next;
} NodeParameter;
extern HeadNode settings; typedef struct NodeHead
{
NodeParameter *parameter;
size_t countParameter;
size_t countParameterSet;
} NodeHead;
/* extern NodeHead settings;
* Работа с Node
*/
Node *settingsGetNode(SettingsParameters parameter); void addParameterKey(Parameter name, char *key, bool set, bool singleValue);
void settingsAddKey(SettingsParameters parameter, char *key, bool isValue, bool enable); void addParameterValue(Parameter pName, Value vName, char *current, bool set);
void settingsSetValue(SettingsParameters parameter, char *value); void freeSettings();
void settingsSetEnable(SettingsParameters parameter, bool enable);
void settingsToggleEnable(SettingsParameters parameter); NodeValue *getSetNodeValue(NodeParameter *node);
void settingsToggleChange(SettingsParameters parameter); bool getSetParameter(Parameter name);
bool settingsGetEnable(SettingsParameters parameter); bool getSetValue(Parameter pName, Value vName);
void settingsFree(); void changeParameter(Parameter name);
void settingsSaveSettings(); void changeValue(Parameter pName, Value vName);
void settingsResetChange(); void saveChangeSettings();
void resetChangeSettings();
void setParameterValue(Parameter pName, Value vName, char *current);
#endif /* SETTINGS_H_ */ #endif /* SETTINGS_H_ */

23
parameter.h Normal file
View File

@ -0,0 +1,23 @@
/*
* parameters.h
*
* Created on: 7 июл. 2022 г.
* Author: alexander
*/
#ifndef PARAMETERS_H_
#define PARAMETERS_H_
typedef enum
{
PARAMETER_XFREERDP,
PARAMETER_SERVER,
PARAMETER_USERNAME,
PARAMETER_PASSWORD,
PARAMETER_MULTIMONITOR,
PARAMETER_FULLSCREEN,
PARAMETER_AUTHENTICATION,
PARAMETER_SECURITY
} Parameter;
#endif /* PARAMETERS_H_ */

View File

@ -14,9 +14,15 @@
#include "arguments.h" #include "arguments.h"
#include "node_settings.h" #include "node_settings.h"
void toggleActive(Ihandle *self, char *name)
{
IupSetInt(IupGetDialogChild(self, name), "ACTIVE", !IupGetInt(IupGetDialogChild(self, name), "ACTIVE"));
}
static int settingsClose(Ihandle *self) static int settingsClose(Ihandle *self)
{ {
settingsResetChange(); resetChangeSettings();
IupSetAttribute(IupGetDialog(self), "SIMULATEMODAL", "OFF"); IupSetAttribute(IupGetDialog(self), "SIMULATEMODAL", "OFF");
IupHide(IupGetDialog(self)); IupHide(IupGetDialog(self));
return IUP_DEFAULT; return IUP_DEFAULT;
@ -24,7 +30,7 @@ static int settingsClose(Ihandle *self)
static int settingsSave(Ihandle *self) static int settingsSave(Ihandle *self)
{ {
settingsSaveSettings(); saveChangeSettings();
IupSetAttribute(IupGetDialog(self), "SIMULATEMODAL", "OFF"); IupSetAttribute(IupGetDialog(self), "SIMULATEMODAL", "OFF");
IupHide(IupGetDialog(self)); IupHide(IupGetDialog(self));
return IUP_DEFAULT; return IUP_DEFAULT;
@ -32,112 +38,131 @@ static int settingsSave(Ihandle *self)
static int settingsTglMultimonitor(Ihandle *self) static int settingsTglMultimonitor(Ihandle *self)
{ {
settingsToggleChange(PARAMETER_MULTIMONITOR); changeParameter(PARAMETER_MULTIMONITOR);
return IUP_DEFAULT; return IUP_DEFAULT;
} }
static int settingsTglFullscreen(Ihandle *self) static int settingsTglFullscreen(Ihandle *self)
{ {
settingsToggleChange(PARAMETER_FULLSCREEN); changeParameter(PARAMETER_FULLSCREEN);
return IUP_DEFAULT; return IUP_DEFAULT;
} }
static int settingsTglAuthentication(Ihandle *self) static int settingsTglAuthentication(Ihandle *self)
{ {
settingsToggleChange(PARAMETER_AUTHENTICATION); changeParameter(PARAMETER_AUTHENTICATION);
return IUP_DEFAULT; return IUP_DEFAULT;
} }
static int settingsUseSecurity(Ihandle *self)
{
changeParameter(PARAMETER_SECURITY);
toggleActive(self, "SECURITY_TLS");
toggleActive(self, "SECURITY_RDP");
toggleActive(self, "SECURITY_NLA");
toggleActive(self, "SECURITY_EXT");
return IUP_DEFAULT;
}
static void settingsChooseSecurity(Ihandle *self, int state)
{
if (state == 1)
{
int tool_index = IupGetInt(self, "TOOLINDEX");
switch (tool_index)
{
case 0:
{
changeValue(PARAMETER_SECURITY, VALUE_SECURITY_TLS);
break;
}
case 1:
{
changeValue(PARAMETER_SECURITY, VALUE_SECURITY_RDP);
break;
}
case 2:
{
changeValue(PARAMETER_SECURITY, VALUE_SECURITY_NLA);
break;
}
case 3:
{
changeValue(PARAMETER_SECURITY, VALUE_SECURITY_EXT);
break;
}
}
}
}
/* /*
* Блок настроек * Блок настроек
*/ */
static Ihandle* getFrmCheckbox() static Ihandle* settingsBoxCheckbox()
{ {
Ihandle *tglMultimonitor, *tglFullscreen, *tglAuthentication; Ihandle *tglMultimonitor, *tglFullscreen, *tglAuthentication;
tglMultimonitor = IupToggle("Мультиэкран", NULL); tglMultimonitor = IupToggle("Несколько мониторов", NULL);
tglFullscreen = IupToggle("На весь экран", NULL); tglFullscreen = IupToggle("На весь экран", NULL);
tglAuthentication = IupToggle("Аутентификация", NULL); tglAuthentication = IupToggle("Аутентификация", NULL);
IupSetInt(tglMultimonitor, "VALUE", settingsGetEnable(PARAMETER_MULTIMONITOR)); IupSetInt(tglMultimonitor, "VALUE", getSetParameter(PARAMETER_MULTIMONITOR));
IupSetInt(tglFullscreen, "VALUE", settingsGetEnable(PARAMETER_FULLSCREEN)); IupSetInt(tglFullscreen, "VALUE", getSetParameter(PARAMETER_FULLSCREEN));
IupSetInt(tglAuthentication, "VALUE", settingsGetEnable(PARAMETER_AUTHENTICATION)); IupSetInt(tglAuthentication, "VALUE", getSetParameter(PARAMETER_AUTHENTICATION));
return IupVbox( return IupHbox(IupSetAttributes(IupFrame(IupVbox(
IupSetCallbacks(IupSetAttributes(tglMultimonitor, "NAME=SETTINGS_TGL_MULTIMONITOR"), "ACTION", IupSetCallbacks(IupSetAttributes(tglMultimonitor, "NAME=SETTINGS_TGL_MULTIMONITOR"), "ACTION",
(Icallback) settingsTglMultimonitor, NULL), (Icallback) settingsTglMultimonitor, NULL),
IupSetCallbacks(IupSetAttributes(tglFullscreen, "NAME=SETTINGS_TGL_FULLSCREEN"), "ACTION", IupSetCallbacks(IupSetAttributes(tglFullscreen, "NAME=SETTINGS_TGL_FULLSCREEN"), "ACTION",
(Icallback) settingsTglFullscreen, NULL), (Icallback) settingsTglFullscreen, NULL),
IupSetCallbacks(IupSetAttributes(tglAuthentication, "NAME=SETTINGS_TGL_AUTHENTICATION"), "ACTION", IupSetCallbacks(IupSetAttributes(tglAuthentication, "NAME=SETTINGS_TGL_AUTHENTICATION"), "ACTION",
(Icallback) settingsTglAuthentication, NULL), (Icallback) settingsTglAuthentication, NULL),
NULL); NULL)), "TITLE=\"Общие\""), NULL);
} }
//void tool_action_cb(Ihandle *self, int state) static Ihandle* settingsBoxSecurity()
//{
// if (state == 1)
// {
// int tool_index = IupGetInt(self, "TOOLINDEX");
// switch (tool_index)
// {
// case 0:
// {
// settingsSetValue(PARAMETER_SECURITY, "tls");
// break;
// }
// case 1:
// {
// settingsSetValue(PARAMETER_SECURITY, "rdp");
// break;
// }
// case 2:
// {
// settingsSetValue(PARAMETER_SECURITY, "nla");
// break;
// }
// case 3:
// {
// settingsSetValue(PARAMETER_SECURITY, "ext");
// break;
// }
// }
// }
//}
//
//static Ihandle* getFrmSecurity()
//{
// Ihandle *frmSettings;
// Ihandle *grdSecurity;
//
// grdSecurity = IupGridBox(
// IupSetCallbacks(IupSetAttributes(IupToggle(NULL, NULL), "TITLE=TLS, TOOLINDEX=0, VALUE=ON"), "ACTION", (Icallback)tool_action_cb, NULL),
// IupSetCallbacks(IupSetAttributes(IupToggle(NULL, NULL), "TITLE=RDP, TOOLINDEX=1"), "ACTION", (Icallback)tool_action_cb, NULL),
// IupSetCallbacks(IupSetAttributes(IupToggle(NULL, NULL), "TITLE=NLA, TOOLINDEX=2"), "ACTION", (Icallback)tool_action_cb, NULL),
// IupSetCallbacks(IupSetAttributes(IupToggle(NULL, NULL), "TITLE=EXT, TOOLINDEX=3"), "ACTION", (Icallback)tool_action_cb, NULL),
// NULL);
//
//// tglTLS = IupToggle("TLS", NULL);
//// tglRDP = IupToggle("RDP", NULL);
//// tglNLA = IupToggle("NLA", NULL);
//// tglEXT = IupToggle("EXT", NULL);
//
// frmSettings = IupSetAttributes(IupFrame(IupSetAttributes(getFrmCheckbox(), "MARGIN=3x2, GAP=2, ALIGNMENT=ALEFT")), "TITLE=\"Настройки\"");
//
// return frmSettings;
//}
static Ihandle* getHorBoxSettings()
{ {
Ihandle *frmSettings; Ihandle *tglSecurity;
Ihandle *tglTLS, *tglRDP, *tglNLA, *tglEXT;
Ihandle *grdSecurity;
frmSettings = IupSetAttributes(IupFrame(IupSetAttributes(getFrmCheckbox(), "MARGIN=3x2, GAP=2, ALIGNMENT=ALEFT")), "TITLE=\"Настройки\""); tglSecurity = IupToggle("Использовать", NULL);
return IupHbox(frmSettings, NULL); IupSetInt(tglSecurity, "VALUE", getSetParameter(PARAMETER_SECURITY));
IupSetCallback(tglSecurity, "ACTION", (Icallback)settingsUseSecurity);
tglTLS = IupToggle("TLS", NULL);
IupSetInt(tglTLS, "VALUE", getSetValue(PARAMETER_SECURITY, VALUE_SECURITY_TLS));
IupSetInt(tglTLS, "ACTIVE", getSetParameter(PARAMETER_SECURITY));
tglRDP = IupToggle("RDP", NULL);
IupSetInt(tglRDP, "VALUE", getSetValue(PARAMETER_SECURITY, VALUE_SECURITY_RDP));
IupSetInt(tglRDP, "ACTIVE", getSetParameter(PARAMETER_SECURITY));
tglNLA = IupToggle("NLA", NULL);
IupSetInt(tglNLA, "VALUE", getSetValue(PARAMETER_SECURITY, VALUE_SECURITY_NLA));
IupSetInt(tglNLA, "ACTIVE", getSetParameter(PARAMETER_SECURITY));
tglEXT = IupToggle("EXT", NULL);
IupSetInt(tglEXT, "VALUE", getSetValue(PARAMETER_SECURITY, VALUE_SECURITY_EXT));
IupSetInt(tglEXT, "ACTIVE", getSetParameter(PARAMETER_SECURITY));
grdSecurity = IupRadio(IupGridBox(
IupSetCallbacks(IupSetAttributes(tglTLS, "NAME=SECURITY_TLS, TOOLINDEX=0"), "ACTION", (Icallback)settingsChooseSecurity, NULL),
IupSetCallbacks(IupSetAttributes(tglRDP, "NAME=SECURITY_RDP, TOOLINDEX=1"), "ACTION", (Icallback)settingsChooseSecurity, NULL),
IupSetCallbacks(IupSetAttributes(tglNLA, "NAME=SECURITY_NLA, TOOLINDEX=2"), "ACTION", (Icallback)settingsChooseSecurity, NULL),
IupSetCallbacks(IupSetAttributes(tglEXT, "NAME=SECURITY_EXT, TOOLINDEX=3"), "ACTION", (Icallback)settingsChooseSecurity, NULL),
NULL));
return IupHbox(IupSetAttributes(IupFrame(IupVbox(tglSecurity, grdSecurity, NULL)), "TITLE=\"Протокол безопасности\", MARGIN=15x10"), NULL);
}
static Ihandle* settingsHorizontalBox()
{
return IupSetAttributes(IupHbox(settingsBoxCheckbox(), settingsBoxSecurity(), NULL), "MARGIN=5x5");
} }
/* /*
* Блок кнопок * Блок кнопок
*/ */
static Ihandle* getHorBoxButtons() static Ihandle* settingsHorizontalBoxButtons()
{ {
Ihandle *btnSave, *btnClose; Ihandle *btnSave, *btnClose;
@ -147,6 +172,7 @@ static Ihandle* getHorBoxButtons()
btnClose = IupButton("Закрыть", NULL); btnClose = IupButton("Закрыть", NULL);
IupSetAttribute(btnClose, "NAME", "SETTIGS_BTN_CLOSE"); IupSetAttribute(btnClose, "NAME", "SETTIGS_BTN_CLOSE");
IupSetAttribute(btnClose, "TIP", "Отменить изменения");
IupSetHandle("btnClosePointer", btnClose); IupSetHandle("btnClosePointer", btnClose);
@ -161,7 +187,7 @@ int settingsMainWindow(Ihandle *self)
Ihandle *dlg; Ihandle *dlg;
Ihandle *vBoxMain; Ihandle *vBoxMain;
vBoxMain = IupSetAttributes(IupVbox(getHorBoxSettings(), getHorBoxButtons(), NULL), "NMARGIN=2x2, ALIGNMENT=ACENTER"); vBoxMain = IupSetAttributes(IupVbox(settingsHorizontalBox(), settingsHorizontalBoxButtons(), NULL), "NMARGIN=2x2, ALIGNMENT=ACENTER");
dlg = IupDialog(vBoxMain); dlg = IupDialog(vBoxMain);
IupSetAttribute(dlg, "TITLE", "Настройки"); IupSetAttribute(dlg, "TITLE", "Настройки");

16
value.h Normal file
View File

@ -0,0 +1,16 @@
/*
* value.h
*
* Created on: 8 июл. 2022 г.
* Author: alexander
*/
#ifndef VALUE_H_
#define VALUE_H_
typedef enum
{
VALUE_SERVER, VALUE_USERNAME, VALUE_PASSWORD, VALUE_SECURITY_TLS, VALUE_SECURITY_RDP, VALUE_SECURITY_NLA, VALUE_SECURITY_EXT,
} Value;
#endif /* VALUE_H_ */