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

arguments.c

@@ -8,51 +8,51 @@
 #include <stdlib.h>
 #include "arguments.h"
 #include "node_settings.h"
+#include "concat.h"
 
 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
-            {
+                args->argv[(args->argc)++] = concat(head->key, NULL);
-                args->argv[i++] = head->data->key;
         }
     }
-    }
-
-    return args;
 }
 
 void freeArguments(Arguments *args)
 {
+    for (int i = 0; i < args->argc; ++i)
+    {
+        free(args->argv[i]);
+    }
     free(args->argv);
-    free(args);
 }

arguments.h

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

concat.c

@@ -16,7 +16,7 @@ char* concat(char *s1, char *s2)
     size_t len1 = s1 ? strlen(s1) : 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)
     {
@@ -26,11 +26,11 @@ char* concat(char *s1, char *s2)
 
     if (s1)
     {
-        memcpy(result, s1, len1);
+        strcpy(result, s1);
     }
     if (s2)
     {
-        memcpy(result + len1, s2, len2 + 1);
+        strcpy(result + len1, s2);
     }
 
     return result;

gui.c

@@ -22,18 +22,18 @@ static int guiExit(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");
-
+    freeArguments(&args);
-    freeArguments(args);
 
     return IUP_DEFAULT;
 }

main.c

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

node_settings.c

@@ -7,40 +7,91 @@
 
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 
 #include "node_settings.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->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;
 }
 
-/*
+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)
         {
@@ -49,9 +100,14 @@ Node *settingsGetNode(SettingsParameters parameter)
         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;
         }
@@ -60,206 +116,318 @@ Node *settingsGetNode(SettingsParameters parameter)
     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;
     }
 
-    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;
     }
     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;
     }
-    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
     {
-        ++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)
         {
             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
-            {
+            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 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;
 }

node_settings.h

@@ -10,58 +10,52 @@
 
 #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 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_ */

parameter.h

@@ -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_ */

settings.c

@@ -14,9 +14,15 @@
 #include "arguments.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)
 {
-    settingsResetChange();
+    resetChangeSettings();
     IupSetAttribute(IupGetDialog(self), "SIMULATEMODAL", "OFF");
     IupHide(IupGetDialog(self));
     return IUP_DEFAULT;
@@ -24,7 +30,7 @@ static int settingsClose(Ihandle *self)
 
 static int settingsSave(Ihandle *self)
 {
-    settingsSaveSettings();
+    saveChangeSettings();
     IupSetAttribute(IupGetDialog(self), "SIMULATEMODAL", "OFF");
     IupHide(IupGetDialog(self));
     return IUP_DEFAULT;
@@ -32,112 +38,131 @@ static int settingsSave(Ihandle *self)
 
 static int settingsTglMultimonitor(Ihandle *self)
 {
-    settingsToggleChange(PARAMETER_MULTIMONITOR);
+    changeParameter(PARAMETER_MULTIMONITOR);
     return IUP_DEFAULT;
 }
 
 static int settingsTglFullscreen(Ihandle *self)
 {
-    settingsToggleChange(PARAMETER_FULLSCREEN);
+    changeParameter(PARAMETER_FULLSCREEN);
     return IUP_DEFAULT;
 }
 
 static int settingsTglAuthentication(Ihandle *self)
 {
-    settingsToggleChange(PARAMETER_AUTHENTICATION);
+    changeParameter(PARAMETER_AUTHENTICATION);
     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;
 
-    tglMultimonitor = IupToggle("Мультиэкран", NULL);
+    tglMultimonitor = IupToggle("Несколько мониторов", NULL);
     tglFullscreen = 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",
                     (Icallback) settingsTglMultimonitor, NULL),
             IupSetCallbacks(IupSetAttributes(tglFullscreen, "NAME=SETTINGS_TGL_FULLSCREEN"), "ACTION",
                     (Icallback) settingsTglFullscreen, NULL),
             IupSetCallbacks(IupSetAttributes(tglAuthentication, "NAME=SETTINGS_TGL_AUTHENTICATION"), "ACTION",
                                                 (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;
 
@@ -147,6 +172,7 @@ static Ihandle* getHorBoxButtons()
 
     btnClose = IupButton("Закрыть", NULL);
     IupSetAttribute(btnClose, "NAME", "SETTIGS_BTN_CLOSE");
+    IupSetAttribute(btnClose, "TIP", "Отменить изменения");
 
     IupSetHandle("btnClosePointer", btnClose);
 
@@ -161,7 +187,7 @@ int settingsMainWindow(Ihandle *self)
     Ihandle *dlg;
     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);
     IupSetAttribute(dlg, "TITLE", "Настройки");

value.h

@@ -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_ */