Can you show the code where you actually draw that line? Is it this:

void plotDot(GLint x, GLint y, int c)
{
     glBegin(GL_POINTS);
     glVertex2i(x, y);
     glEnd();
}

You are not providing any texture coordinates so that's why it only shows red. Do you have to draw it as dots? you'd be much better off drawing it as 2 triangles unless you need it as points for some reason. Ideally you would call glBegin, draw all the points, then do glEnd rather than doing begin/point/end however many times each.

I don't recommend sticking with this approach but you would need to do somehting along the lines of:

void plotDot(GLint x, GLint y, int c)
{
     glBegin(GL_POINTS); // You should have this outside of your loop
     glVertex2i(x, y);
     // notice it is 2f, not 2i. 2i only lets you have 0, 1, 2 etc so you will never see anything
     // other than the start and end pixels of your texture.
     glTexcoord2f(u, v); // u should be a value from 0 to 1, 0 when c==0 and 1 when c==ss-1 (done outside the call)
     glEnd(); // This should also be outside the loop
}

Curses, I wrote a long post, accidentally pasted over it and clicked submit and lost it :(. Will try again.

When you want to sample (take a color from) a texture you have to provide u,v coordinates to opengl to tell it where on that texture to take a color from. Typically people call the horizontal axis u and the vertical axis v. For the u axis, the left of the texture is 0, the right of the texture is 1 so if you wanted that cyan part of your gradient in the central area you would likely provide a value of 0.5 for u. V is then the vertical axis and in opengl the bottom of the texture is v=0 and the top is v=1. All areas inside are then within the range 0-1. If you provide values outside of that range then it will have a different effect depending on the texture wrap you have setup (search opengl texture wrapping for more info).

With the gradient texture you have, it is effectively 1D, no matter what v value you give it the color won't change so you can happily use a v value of 0 (the second parameter in glTexcoord2i). We are interested only in the horizontal value u. To get the left we give a value of 0, to get the right we give a value of 1 and to sample the texture in between we give a value between 0 and 1. The problem with glTexcoord2i is that it accepts only integers (0, 1, 2, 3 etc and negatives) so we can never actually give it a value in between so we can never show the whole of your gradient only the left and right pixels. To solve this we can switch to glTexcoord2f instead which takes floats so we can provide values such as 0.5 and thus get that cyan in the central area.

The other issue is you are passing in c%16 which will give integer values too which you don't want. From what I understand of your code that line should be a rainbow being repeated every 16 pixels. Hopefully this should help you out:

// It is horribly inefficient to call begin/end for every single primitive so do this 
// outside of the loop
glBegin(GL_POINTS);
for(int c = 0; c < ss; x+=ds, c++)
{
   // You want a value that goes 0-1 every 16c. To get it going every 16c:
   // c = c%16; Then to convert that to 0-1
   // u = c/(16-1); It's -1 since the largest value you can have is 15 which will then give 1
   glTexcoord2f((c%16)/15.0f, 0);
   glVertex2i((int)x, 700);
}
glEnd();

what about v? in gradient1.png file, there are a lot of redundant colors (all row are in the same colors), but in the future, I will create a new gradient png file, it will be quite different.

If you want the vertical aspect then you should stop using points and instead create a quad which will be much more efficient and easier to work with. You would simply define 4 points (the corners) and let opengl do the rest. If you wanted the texture to be repeated, say 10 times, then instead of putting the texture coord to u=1 on the right you'd just set it to 10 (and setup your texture wrapping to repeat). It will save you a lot of trouble. You can make textures procedurally which is sort of the same as drawing a whole bunch of points but a lot more efficient. Ask yourself if you really need to be using points, they are probably a bad choice for what you are trying to do.

I have to use points to draw a fractals.

Are you planning to render your fractal as a dense area of points? If so you will be much better off making a texture out of them instead. In effect a texture is just that, an area of points (pixels). It'll be much more efficient to draw each frame too.