alexander
/
GUI-FreeRDP
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
arguments.c
View File

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

6
arguments.h
View File

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

6
concat.c
View File

@ -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;

16
gui.c
View File

@ -22,18 +22,18 @@ static int guiExit(Ihandle *self)
static int guiConnect(Ihandle *self)
{
settingsSetValue(PARAMETER_SERVER, IupGetAttribute(IupGetDialogChild(self, "SERVER"), "LINEVALUE"));
settingsSetValue(PARAMETER_USERNAME, IupGetAttribute(IupGetDialogChild(self, "USER"), "LINEVALUE"));
settingsSetValue(PARAMETER_PASSWORD, IupGetAttribute(IupGetDialogChild(self, "PASSWORD"), "LINEVALUE"));
setParameterValue(PARAMETER_SERVER, VALUE_SERVER, IupGetAttribute(IupGetDialogChild(self, "SERVER"), "LINEVALUE"));
setParameterValue(PARAMETER_USERNAME, VALUE_USERNAME, IupGetAttribute(IupGetDialogChild(self, "USER"), "LINEVALUE"));
setParameterValue(PARAMETER_PASSWORD, VALUE_PASSWORD, IupGetAttribute(IupGetDialogChild(self, "PASSWORD"), "LINEVALUE"));
Arguments *args = buildArguments();
for (int i = 0; i < args->argc; ++i)
Arguments args;
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;
}

3
main.c
View File

@ -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();

490
node_settings.c
View File

@ -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));
node->parameter = PARAMETER_NULL;
NodeValue *node = (NodeValue*) malloc(sizeof(NodeValue));
node->name = name;
node->set = set;
node->change = false;
node->next = NULL;
node->data = (SettingsData*)malloc(sizeof(SettingsData));
node->data->key = NULL;
node->data->value = NULL;
node->data->fullArgument = NULL;
node->current = (char*) malloc(sizeof(char) * strlen(current));
strcpy(node->current, current);
return node;
}
/*
* Если передан параметр PARAMETER_NULL, то возвращается последний действующий узел.
* Если возврат NULL, то ни одного узла не существует.
* Если передан параметр отличный от PARAMETER_NULL, то ищется существующий узел с этим параметром.
* Если возврат NULL, то узла с таким параметром не найдено.
*/
Node *settingsGetNode(SettingsParameters parameter)
static void freeNodeValue(NodeValue *node)
{
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();
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)
if (!settings.parameter)
{
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 (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)
if (!nodeParameter->value)
{
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)
{
Node *currentNode = settingsGetNode(parameter);
if (!currentNode)
NodeValue *nodeValue = getNodeValue(nodeParameter, vName);
if (nodeValue)
{
return;
}
if (currentNode->enable)
{
--settings.countEnable;
free(nodeValue->current);
nodeValue->current = (char*) malloc(sizeof(char) * length);
strcpy(nodeValue->current, current);
}
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);
if (!currentNode)
{
return;
}
currentNode->change = !currentNode->change;
NodeParameter *node = getNodeParameter(name);
node->change = !node->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)
{
if (head->change)
{
head->change = false;
pHead->countValueSet = 0;
if (head->enable)
{
--settings.countEnable;
}
if (pHead->singleValue)
saveChangeSingleValueSettings(pHead);
else
{
++settings.countEnable;
saveChangeValueSettings(pHead);
}
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);
if (!currentNode)
NodeParameter *node = getNodeParameter(name);
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 (data->fullArgument)
if (vNode->name == vName)
{
free(data->fullArgument);
return vNode->set;
}
free(data);
}
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;
}
return false;
}

84
node_settings.h
View File

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

168
settings.c
View File

@ -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(tglFullscreen, "VALUE", settingsGetEnable(PARAMETER_FULLSCREEN));
IupSetInt(tglAuthentication, "VALUE", settingsGetEnable(PARAMETER_AUTHENTICATION));
IupSetInt(tglMultimonitor, "VALUE", getSetParameter(PARAMETER_MULTIMONITOR));
IupSetInt(tglFullscreen, "VALUE", getSetParameter(PARAMETER_FULLSCREEN));
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)
//{
// 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()
static Ihandle* settingsBoxSecurity()
{
Ihandle *frmSettings;
Ihandle *tglSecurity;
Ihandle *tglTLS, *tglRDP, *tglNLA, *tglEXT;
Ihandle *grdSecurity;
frmSettings = IupSetAttributes(IupFrame(IupSetAttributes(getFrmCheckbox(), "MARGIN=3x2, GAP=2, ALIGNMENT=ALEFT")), "TITLE=\"Настройки\"");
return IupHbox(frmSettings, NULL);
tglSecurity = IupToggle("Использовать", 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", "Настройки");

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