1 000100000000000 0001
2 000100000000000 0001
3 100000110010000 00000000001
4 100000110010000 00000000001
5 100000110010000 00000000001
6 100000110010000 00000000001
7 100000110010000 00000000001
8 100000110010000 00000000001
9 100000110010000 00000000001
10 100000110010000 00000000001
11 100000001111100
12 100000001111100
13 100000001111100
14 100000111011011 110000000000000 1
15 100000111011011 110000000000000 1
16 100000111011011 110000000000000 1
17 100000111011011 110000000000000 1
18 100000111011011 110000000000000 1
19 100000111011011 110000000000000 1
20 000100000000000 0001
1
2
*****
*****
*****
*****
*****
*****
*****
***** 10
************ 11
************
************
***** *** 14
***** ***
***** ***
***** ***
***** ***
***** ***
20
3W, 12 B, 5W
1000 0000111 1100
If I wanted to suck in the above 20 lines without line numbers, spaces,
carriage returns, line feeds, or anything that is not a zero, one or EOF,
how would I do it?
Thanks in advance,
--
George
Terrorist attacks can shake the foundations of our biggest buildings, but
they cannot touch the foundation of America. These acts shatter steel, but
they cannot dent the steel of American resolve.
George W. Bush
Picture of the Day http://apod.nasa.gov/apod/ 30  1949 
On 18 Nov, 05:44, George <geo...@example .invalidwrote:
1 *00010000000000 00001
2 *00010000000000 00001
3 *10000011001000 000000000001
4 *10000011001000 000000000001
5 *10000011001000 000000000001
6 *10000011001000 000000000001
7 *10000011001000 000000000001
8 *10000011001000 000000000001
9 *10000011001000 000000000001
10 *10000011001000 000000000001
11 *10000000111110 0
12 *10000000111110 0
13 *10000000111110 0
14 *10000011101101 111000000000000 01
15 *10000011101101 111000000000000 01
16 *10000011101101 111000000000000 01
17 *10000011101101 111000000000000 01
18 *10000011101101 111000000000000 01
19 *10000011101101 111000000000000 01
20 *00010000000000 00001
1
2
* *****
* *****
* *****
* *****
* *****
* *****
* *****
* ***** 10
* ************ 11
* ************
* ************
* ***** * **** 14
* ***** * ****
* ***** * ****
* ***** * ****
* ***** * ****
* ***** * ****
20
3W, 12 B, 5W
1000 0000111 1100
If I wanted to suck in the above 20 lines without line numbers, spaces,
carriage returns, line feeds, or anything that is not a zero, one or EOF,
how would I do it?
assuming you mean the twenty lines at the beginning. Would fgets()
followed by
int line_num;
char data[32];
fscanf (line, "%d %32s", &line_num, data);
do the job?
--
Nick Keighley
On Tue, 18 Nov 2008 00:59:20 -0800 (PST), Nick Keighley wrote:
On 18 Nov, 05:44, George <geo...@example .invalidwrote:
>1 *00010000000000 00001
2 *00010000000000 00001
3 *10000011001000 000000000001
4 *10000011001000 000000000001
5 *10000011001000 000000000001
6 *10000011001000 000000000001
7 *10000011001000 000000000001
8 *10000011001000 000000000001
9 *10000011001000 000000000001
10 *10000011001000 000000000001
11 *10000000111110 0
12 *10000000111110 0
13 *10000000111110 0
14 *10000011101101 111000000000000 01
15 *10000011101101 111000000000000 01
16 *10000011101101 111000000000000 01
17 *10000011101101 111000000000000 01
18 *10000011101101 111000000000000 01
19 *10000011101101 111000000000000 01
20 *00010000000000 00001
1
2
* *****
* *****
* *****
* *****
* *****
* *****
* *****
* ***** 10
* ************ 11
* ************
* ************
* ***** * **** 14
* ***** * ****
* ***** * ****
* ***** * ****
* ***** * ****
* ***** * ****
20
3W, 12 B, 5W
1000 0000111 1100
If I wanted to suck in the above 20 lines without line numbers, spaces,
carriage returns, line feeds, or anything that is not a zero, one or EOF,
how would I do it?
assuming you mean the twenty lines at the beginning. Would fgets()
followed by
int line_num;
char data[32];
fscanf (line, "%d %32s", &line_num, data);
do the job?
Why fgets before scanf?
The better data set is:
1 000100000000000 0001
2 000100000000000 0001
3 100000110010000 00000000001
4 100000110010000 00000000001
5 100000110010000 00000000001
6 100000110010000 00000000001
7 100000110010000 00000000001
8 100000110010000 00000000001
9 100000110010000 00000000001
10 100000110010000 00000000001
11 100000001111100 000000000001
12 100000001111100 000000000001
13 100000001111100 000000000001
14 100000111011011 110000000000000 1
15 100000111011011 110000000000000 1
16 100000111011011 110000000000000 1
17 100000111011011 110000000000000 1
18 100000111011011 110000000000000 1
19 100000111011011 110000000000000 1
20 000100000000000 0001
--
George
The course of this conflict is not known, yet its outcome is certain.
Freedom and fear, justice and cruelty, have always been at war, and we know
that God is not neutral between them.
George W. Bush
Picture of the Day http://apod.nasa.gov/apod/
On Nov 18, 12:59 am, Nick Keighley <nick_keighley_ nos...@hotmail. com>
wrote:
On 18 Nov, 05:44, George <geo...@example .invalidwrote:
1 000100000000000 0001
2 000100000000000 0001
3 100000110010000 00000000001
4 100000110010000 00000000001
5 100000110010000 00000000001
6 100000110010000 00000000001
7 100000110010000 00000000001
8 100000110010000 00000000001
9 100000110010000 00000000001
10 100000110010000 00000000001
11 100000001111100
12 100000001111100
13 100000001111100
14 100000111011011 110000000000000 1
15 100000111011011 110000000000000 1
16 100000111011011 110000000000000 1
17 100000111011011 110000000000000 1
18 100000111011011 110000000000000 1
19 100000111011011 110000000000000 1
20 000100000000000 0001
1
2
*****
*****
*****
*****
*****
*****
*****
***** 10
************ 11
************
************
***** *** 14
***** ***
***** ***
***** ***
***** ***
***** ***
20
3W, 12 B, 5W
1000 0000111 1100
If I wanted to suck in the above 20 lines without line numbers, spaces,
carriage returns, line feeds, or anything that is not a zero, one or EOF,
how would I do it?
assuming you mean the twenty lines at the beginning. Would fgets()
followed by
int line_num;
char data[32];
fscanf (line, "%d %32s", &line_num, data);
do the job?
But he would would fgets() followed by fscanf(), wouldn't that just
suck in one line at a time vs all 20 lines at once? Here is what I
mean. BTW, I used sscanf() and not fscanf().
[cdalten@localho st oakland]$ pwd
/home/cdalten/oakland
[cdalten@localho st oakland]$ more bin.txt
1 000100000000000 0001
2 000100000000000 0001
3 100000110010000 00000000001
4 100000110010000 00000000001
5 100000110010000 00000000001
6 100000110010000 00000000001
7 100000110010000 00000000001
8 100000110010000 00000000001
9 100000110010000 00000000001
10 100000110010000 00000000001
11 100000001111100 000000000001
12 100000001111100 000000000001
13 100000001111100 000000000001
14 100000111011011 110000000000000 1
15 100000111011011 110000000000000 1
16 100000111011011 110000000000000 1
17 100000111011011 110000000000000 1
18 100000111011011 110000000000000 1
19 100000111011011 110000000000000 1
20 000100000000000 0001
[cdalten@localho st oakland]$ more slurp.c
#include <stdio.h>
#include <stdlib.h>
#define PATH "/home/cdalten/oakland/bin.txt"
#define NUMBER 100
#define BIN 1000
#define MAXFMTLEN 2000
int main(void)
{
FILE *fp;
char pattern[MAXFMTLEN];
char lnumber[NUMBER];
char lbin[BIN];
char line[MAXFMTLEN];
/*int line_num;
char data[32];*/
if ((fp = fopen(PATH, "r")) == NULL ) {
fprintf(stderr, "can't open file\n");
exit(1);
}
sprintf(pattern , "%%%ds %%%ds", BIN-1, NUMBER-1);
while ((fgets(line, MAXFMTLEN, fp)) != NULL ) {
sscanf(line, pattern , lnumber, lbin);
/*fscanf (fp, "%d %32s", &lnumber, lbin);*/
printf("%s\n", lbin);
}
fclose(fp);
return 0;
}
[cdalten@localho st oakland]$ gcc -Wall slurp.c -o slurp
[cdalten@localho st oakland]$ ./slurp
000100000000000 0001
000100000000000 0001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000001111100 000000000001
100000001111100 000000000001
100000001111100 000000000001
100000111011011 110000000000000 1
100000111011011 110000000000000 1
100000111011011 110000000000000 1
100000111011011 110000000000000 1
100000111011011 110000000000000 1
100000111011011 110000000000000 1
000100000000000 0001
[cdalten@localho st oakland]$
On Nov 18, 4:06 am, Chad <cdal...@gmail. comwrote:
On Nov 18, 12:59 am, Nick Keighley <nick_keighley_ nos...@hotmail. com>
wrote:
On 18 Nov, 05:44, George <geo...@example .invalidwrote:
1 000100000000000 0001
2 000100000000000 0001
3 100000110010000 00000000001
4 100000110010000 00000000001
5 100000110010000 00000000001
6 100000110010000 00000000001
7 100000110010000 00000000001
8 100000110010000 00000000001
9 100000110010000 00000000001
10 100000110010000 00000000001
11 100000001111100
12 100000001111100
13 100000001111100
14 100000111011011 110000000000000 1
15 100000111011011 110000000000000 1
16 100000111011011 110000000000000 1
17 100000111011011 110000000000000 1
18 100000111011011 110000000000000 1
19 100000111011011 110000000000000 1
20 000100000000000 0001
1
2
*****
*****
*****
*****
*****
*****
*****
***** 10
************ 11
************
************
***** *** 14
***** ***
***** ***
***** ***
***** ***
***** ***
20
3W, 12 B, 5W
1000 0000111 1100
If I wanted to suck in the above 20 lines without line numbers, spaces,
carriage returns, line feeds, or anything that is not a zero, one or EOF,
how would I do it?
assuming you mean the twenty lines at the beginning. Would fgets()
followed by
int line_num;
char data[32];
fscanf (line, "%d %32s", &line_num, data);
do the job?
But he would would fgets() followed by fscanf(), wouldn't that just
suck in one line at a time vs all 20 lines at once? Here is what I
mean. BTW, I used sscanf() and not fscanf().
[cdalten@localho st oakland]$ pwd
/home/cdalten/oakland
[cdalten@localho st oakland]$ more bin.txt
1 000100000000000 0001
2 000100000000000 0001
3 100000110010000 00000000001
4 100000110010000 00000000001
5 100000110010000 00000000001
6 100000110010000 00000000001
7 100000110010000 00000000001
8 100000110010000 00000000001
9 100000110010000 00000000001
10 100000110010000 00000000001
11 100000001111100 000000000001
12 100000001111100 000000000001
13 100000001111100 000000000001
14 100000111011011 110000000000000 1
15 100000111011011 110000000000000 1
16 100000111011011 110000000000000 1
17 100000111011011 110000000000000 1
18 100000111011011 110000000000000 1
19 100000111011011 110000000000000 1
20 000100000000000 0001
[cdalten@localho st oakland]$ more slurp.c
#include <stdio.h>
#include <stdlib.h>
#define PATH "/home/cdalten/oakland/bin.txt"
#define NUMBER 100
#define BIN 1000
#define MAXFMTLEN 2000
int main(void)
{
FILE *fp;
char pattern[MAXFMTLEN];
char lnumber[NUMBER];
char lbin[BIN];
char line[MAXFMTLEN];
/*int line_num;
char data[32];*/
if ((fp = fopen(PATH, "r")) == NULL ) {
fprintf(stderr, "can't open file\n");
exit(1);
}
sprintf(pattern , "%%%ds %%%ds", BIN-1, NUMBER-1);
while ((fgets(line, MAXFMTLEN, fp)) != NULL ) {
sscanf(line, pattern , lnumber, lbin);
/*fscanf (fp, "%d %32s", &lnumber, lbin);*/
printf("%s\n", lbin);
}
fclose(fp);
return 0;
}
[cdalten@localho st oakland]$ gcc -Wall slurp.c -o slurp
[cdalten@localho st oakland]$ ./slurp
000100000000000 0001
000100000000000 0001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000110010000 00000000001
100000001111100 000000000001
100000001111100 000000000001
100000001111100 000000000001
100000111011011 110000000000000 1
100000111011011 110000000000000 1
100000111011011 110000000000000 1
100000111011011 110000000000000 1
100000111011011 110000000000000 1
100000111011011 110000000000000 1
000100000000000 0001
[cdalten@localho st oakland]$
Yikes! I forgot that using internet slang is a no no here. BTW = by
the way.
George wrote:
On Tue, 18 Nov 2008 00:59:20 -0800 (PST), Nick Keighley wrote:
....
>assuming you mean the twenty lines at the beginning. Would fgets()
followed by
int line_num;
char data[32];
fscanf (line, "%d %32s", &line_num, data);
do the job?
Why fgets before scanf?
Because scanf() treats newline characters the same way as any other
whitespace character. This is usually not the way they should be
handled. As a result, a single incorrectly formatted line can cause all
following lines to be handled incorrectly, causing bugs that can be a
real pain to track down.
On 18 Nov, 09:11, George <geo...@example .invalidwrote:
On Tue, 18 Nov 2008 00:59:20 -0800 (PST), Nick Keighley wrote:
On 18 Nov, 05:44, George <geo...@example .invalidwrote:
1 *00010000000000 00001
2 *00010000000000 00001
3 *10000011001000 000000000001
4 *10000011001000 000000000001
5 *10000011001000 000000000001
6 *10000011001000 000000000001
7 *10000011001000 000000000001
8 *10000011001000 000000000001
9 *10000011001000 000000000001
10 *10000011001000 000000000001
11 *10000000111110 0
12 *10000000111110 0
13 *10000000111110 0
14 *10000011101101 111000000000000 01
15 *10000011101101 111000000000000 01
16 *10000011101101 111000000000000 01
17 *10000011101101 111000000000000 01
18 *10000011101101 111000000000000 01
19 *10000011101101 111000000000000 01
20 *00010000000000 00001
<snip>
If I wanted to suck in the above 20 lines without line numbers, spaces,
carriage returns, line feeds, or anything that is not a zero, one or EOF,
how would I do it?
assuming you mean the twenty lines at the beginning. Would fgets()
followed by
* *int line_num;
* *char data[32];
* *fscanf (line, "%d %32s", &line_num, data);
do the job?
Why fgets before scanf? *
because it should have read "sscanf()" rather than "fscanf()".
I prefer to separate the reading from the parsing. It makes the error
recovery easier.
The better data set is:
1 *00010000000000 00001
2 *00010000000000 00001
3 *10000011001000 000000000001
4 *10000011001000 000000000001
5 *10000011001000 000000000001
6 *10000011001000 000000000001
7 *10000011001000 000000000001
8 *10000011001000 000000000001
9 *10000011001000 000000000001
10 *10000011001000 000000000001
11 *10000000111110 0000000000001
12 *10000000111110 0000000000001
13 *10000000111110 0000000000001
14 *10000011101101 111000000000000 01
15 *10000011101101 111000000000000 01
16 *10000011101101 111000000000000 01
17 *10000011101101 111000000000000 01
18 *10000011101101 111000000000000 01
19 *10000011101101 111000000000000 01
20 *00010000000000 00001
something like
int read_binary_dat a (char data[], FILE *in)
{
char buffer [80];
int line_num;
char junk[2];
if (fgets (buffer, 80, in) == NULL)
return 0; /* i/o error or no more data */
if (strchr(buffer, '\n') == NULL)
return 0; /* line too long */
if (sscanf (buffer, "%d %32s%1s", &line_num, data, junk) != 2)
return 0; /* parse error */
return 1; /* success */
}
that is untested code
--
Nick Keighley
the experience of free will is a gift of ignorance
or a product of incomplete information
Chad <cd*****@gmail. comwrites:
[66 lines deleted]
>But he would would fgets() followed by fscanf(), wouldn't that just
suck in one line at a time vs all 20 lines at once? Here is what I
mean. BTW, I used sscanf() and not fscanf().
[85 lines deleted]
>
Yikes! I forgot that using internet slang is a no no here. BTW = by
the way.
I don't think BTW is a problem; it's common enough that I think almost
everyone understands it. Silly abbreviations like "u" for "you"
are frowned upon.
But you really didn't need to quote the *entire* previous article to
add a one-line comment.
--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
On Tue, 18 Nov 2008 12:26:05 GMT, James Kuyper wrote:
George wrote:
>On Tue, 18 Nov 2008 00:59:20 -0800 (PST), Nick Keighley wrote:
...
>>assuming you mean the twenty lines at the beginning. Would fgets()
followed by
int line_num;
char data[32];
fscanf (line, "%d %32s", &line_num, data);
do the job?
Why fgets before scanf?
Because scanf() treats newline characters the same way as any other
whitespace character. This is usually not the way they should be
handled. As a result, a single incorrectly formatted line can cause all
following lines to be handled incorrectly, causing bugs that can be a
real pain to track down.
How does fgets know to stop?
Presumably, we want to start scanf'ing with '1'. Let me refresh you memory
of the data set. I call it george.txt to reflect my pseudonym.
1 000100000000000 0001
2 000100000000000 0001
3 100000110010000 00000000001
4 100000110010000 00000000001
5 100000110010000 00000000001
6 100000110010000 00000000001
7 100000110010000 00000000001
8 100000110010000 00000000001
9 100000110010000 00000000001
10 100000110010000 00000000001
11 100000001111100
12 100000001111100
13 100000001111100
14 100000111011011 110000000000000 1
15 100000111011011 110000000000000 1
16 100000111011011 110000000000000 1
17 100000111011011 110000000000000 1
18 100000111011011 110000000000000 1
19 100000111011011 110000000000000 1
20 000100000000000 0001
It's 20 by forty. Given that I premise that the first datum is the line
number, do I still have to fgets?
--
George
Do I think faith will be an important part of being a good president? Yes,
I do.
George W. Bush
Picture of the Day http://apod.nasa.gov/apod/
George <ge****@example .invalidwrites:
On Tue, 18 Nov 2008 12:26:05 GMT, James Kuyper wrote:
>George wrote:
>>On Tue, 18 Nov 2008 00:59:20 -0800 (PST), Nick Keighley wrote:
...
>>>assuming you mean the twenty lines at the beginning. Would fgets()
followed by
int line_num;
char data[32];
fscanf (line, "%d %32s", &line_num, data);
do the job?
Why fgets before scanf?
Because scanf() treats newline characters the same way as any other
whitespace character. This is usually not the way they should be
handled. As a result, a single incorrectly formatted line can cause all
following lines to be handled incorrectly, causing bugs that can be a
real pain to track down.
How does fgets know to stop?
Either the buffer runs out (you tell fgets the size) or the data runs
out.
Presumably, we want to start scanf'ing with '1'. Let me refresh you memory
of the data set. I call it george.txt to reflect my pseudonym.
1 000100000000000 0001
2 000100000000000 0001
3 100000110010000 00000000001
4 100000110010000 00000000001
5 100000110010000 00000000001
6 100000110010000 00000000001
7 100000110010000 00000000001
8 100000110010000 00000000001
9 100000110010000 00000000001
10 100000110010000 00000000001
11 100000001111100
12 100000001111100
13 100000001111100
14 100000111011011 110000000000000 1
15 100000111011011 110000000000000 1
16 100000111011011 110000000000000 1
17 100000111011011 110000000000000 1
18 100000111011011 110000000000000 1
19 100000111011011 110000000000000 1
20 000100000000000 0001
It's 20 by forty. Given that I premise that the first datum is the line
number, do I still have to fgets?
I would read this using:
int line_no;
char string[41];
while (scanf("%d %40[01]", &line_no, string) == 2)
/* process the data */;
but this is "fragile" -- any upset in the data will throw it off.
Wiser heads than mine advocate reading a line and sscanf'ing it.
As a general bit of advice, it looks like you need to get a C
textbook. I don't think you can lean C by posting questions here.
--
Ben. This thread has been closed and replies have been disabled. Please start a new discussion. Similar topics | |
by: Paul |
last post by:
Hi,
(First apologies if this is not the most relevant place to post this
but I wasn't sure of where was and I am writing my app in VB.)
I'm attempting to parse a binary file for which I have the format. The
format states that the general packet format is as follows
Message header
Hex Length of whole binary packet
|
by: yaipa |
last post by:
What would be the common sense way of finding a binary pattern in a
..bin file, say some 200 bytes, and replacing it with an updated pattern
of the same length at the same offset?
Also, the pattern can occur on any byte boundary in the file, so
chunking through the code at 16 bytes a frame maybe a problem. The
file itself isn't so large, maybe 32 kbytes is all and the need for
speed is not so great, but the need for accuracy in the...
|
by: Steven T. Hatton |
last post by:
§27.4.2.1.4 Type ios_base::openmode
Says this about the std::ios::binary openmode flag:
*binary*: perform input and output in binary mode (as opposed to text mode)
And that is basically _all_ it says about it. What the heck does the binary
flag mean?
--
If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in...
|
by: Lisa Pearlson |
last post by:
Hi,
My php application (on Apache/Linux) needs to do the following:
The PHP script receives a request from a client (binary), asking for certain
records of data.
My PHP script loops through all records and sends each of them ONE BY ONE.
After each record that my server script sends, it waits for the client to
confirm proper reception with an ACK (binary digit).
When there are no more records, my server script sends the client a binary
|
by: wwj |
last post by:
void main()
{
char* p="Hello";
printf("%s",p);
*p='w';
printf("%s",p);
}
| | |
by: knapak |
last post by:
Hello
I'm a self instructed amateur attempting to read a huge file from disk... so
bear with me please... I just learned that reading a file in binary is
faster than text. So I wrote the following code that compiles OK. It runs and
shows the requested output. However, after execution, it pops one of those
windows to send error reports online to the porgram creator. I have managed
to find where the error is but can't see what's wrong....
|
by: |
last post by:
Hi all, is there a better way to stream binary data stored in a table in sql
2005 to a browser in .net 2.0? Or is the code same as in .net 1.1? We
noticed that in certain heavy load scenarios, every now and then the client
would timeout and have to re-initiate the request...
TIA!
|
by: stockblaster |
last post by:
Hello all..
Is it possible to convert a DataTable (i create the DataTable from a
CSV file) into binary data and save it into an sql 2005 table (into
binary field).
After that I want to have the ability to add a row to the beginning of
the to the binary data..
|
by: willakawill |
last post by:
I have a very large binary file saved from a vb array with 2 dimensions;
Dim arMatrix() As Byte
Dim fNum As Integer
ReDim arMatrix(7166, 17769)
'code here to store data from a database into this
'array
'get a free file number
fNum = FreeFile()
|
by: marktang |
last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However, people are often confused as to whether an ONU can Work As a Router. In this blog post, we’ll explore What is ONU, What Is Router, ONU & Router’s main usage, and What is the difference between ONU and Router. Let’s take a closer look !
Part I. Meaning of...
|
by: Oralloy |
last post by:
Hello folks,
I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>".
The problem is that using the GNU compilers, it seems that the internal comparison operator "<=>" tries to promote arguments from unsigned to signed.
This is as boiled down as I can make it.
Here is my compilation command:
g++-12 -std=c++20 -Wnarrowing bit_field.cpp
Here is the code in...
| | |
by: jinu1996 |
last post by:
In today's digital age, having a compelling online presence is paramount for businesses aiming to thrive in a competitive landscape. At the heart of this digital strategy lies an intricately woven tapestry of website design and digital marketing. It's not merely about having a website; it's about crafting an immersive digital experience that captivates audiences and drives business growth.
The Art of Business Website Design
Your website is...
|
by: Hystou |
last post by:
Overview:
Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows Update option using the Control Panel or Settings app; it automatically checks for updates and installs any it finds, whether you like it or not. For most users, this new feature is actually very convenient. If you want to control the update process,...
|
by: tracyyun |
last post by:
Dear forum friends,
With the development of smart home technology, a variety of wireless communication protocols have appeared on the market, such as Zigbee, Z-Wave, Wi-Fi, Bluetooth, etc. Each protocol has its own unique characteristics and advantages, but as a user who is planning to build a smart home system, I am a bit confused by the choice of these technologies. I'm particularly interested in Zigbee because I've heard it does some...
|
by: isladogs |
last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM).
In this session, we are pleased to welcome a new presenter, Adolph Dupré who will be discussing some powerful techniques for using class modules.
He will explain when you may want to use classes instead of User Defined Types (UDT). For example, to manage the data in unbound forms.
Adolph will...
|
by: conductexam |
last post by:
I have .net C# application in which I am extracting data from word file and save it in database particularly. To store word all data as it is I am converting the whole word file firstly in HTML and then checking html paragraph one by one.
At the time of converting from word file to html my equations which are in the word document file was convert into image.
Globals.ThisAddIn.Application.ActiveDocument.Select();...
|
by: TSSRALBI |
last post by:
Hello
I'm a network technician in training and I need your help.
I am currently learning how to create and manage the different types of VPNs and I have a question about LAN-to-LAN VPNs.
The last exercise I practiced was to create a LAN-to-LAN VPN between two Pfsense firewalls, by using IPSEC protocols.
I succeeded, with both firewalls in the same network. But I'm wondering if it's possible to do the same thing, with 2 Pfsense firewalls...
| | |
by: bsmnconsultancy |
last post by:
In today's digital era, a well-designed website is crucial for businesses looking to succeed. Whether you're a small business owner or a large corporation in Toronto, having a strong online presence can significantly impact your brand's success. BSMN Consultancy, a leader in Website Development in Toronto offers valuable insights into creating effective websites that not only look great but also perform exceptionally well. In this comprehensive...
| |
