Cannot get glLineStipple to work

Question

I am building a virtual oscilloscope with OpenGL. I am able to plot the x and y axis and also create a grid. But I cannot get the grid lines to stipple using the code below... Any suggestions ?? glLineStipple is called in the DrawMainWindow function that is passed to glutDisplayFunction....

#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
//procedures for shared memory access
#include <sys/shm.h>
#include <sys/stat.h>
#include "binary_sems.h"

///////////////////////////////////////
//debug - FIXME - Add Controls !!!
///////////////////////////////////////

////////////////////////////////////////
// So in debug turn this off to run
// the oscilloscope standalone
////////////////////////////////////////
//#define USE_COMMS

////////////////////////////////////////
// Define a constant for the value of PI
////////////////////////////////////////
#define GL_PI 3.1415f

// Rotation amounts
static GLfloat xRot = 0.0f;
static GLfloat yRot = 0.0f;

//range
GLfloat nRange = 1000.0f;


//gain control
float gain = 1.00;

//enable / disable grid
int grid_enable = 1;


//debug
int frame_id=0;

//////////////////////////////////////////
//Shared Memory Variables
//////////////////////////////////////////

/*variable for shared memory*/
int segment_id;
char *shared_memory;

/*variables for semaphore*/
int semid;

//variables
float   BorderClr[3] =  {1, 1, 1};      //Default colour for borders
float   Ch1TrClr[3] =   {1, 1, 0};      //Default colour for channel 1 traces
float   GridClr[3] =    {1, 1, 1};      //Default colour for grid
float   TextClr[3] =    {1, 0, 0};      //Default colour for text
float   PauseClr[3] =   {1, 0, 0};      //Colour for "Paused" text

//defines
#define DISP_BUFFER_LENGTH 1000

//structure defining data points
typedef struct voltage_samples{
  float volts;           //this is the raw voltage data
  float volts_scaled;    //this is the scaled voltage data for display (x)
  float time_stamp;      //this is the time stamp (y )
} DISPLAY_SAMPLES;

//declare a buffer of display samples
DISPLAY_SAMPLES sample_buffer[DISP_BUFFER_LENGTH];
int display_update = 0;

//Function Prototypes
void DrawMainWindow(void);
void IdleProcessing(void);
void SetupRC(void);
void ChangeSize(int w, int h);
void SpecialKeys(int key, int x, int y);
void WriteText(char *text, float height, float x, float y, float z);

////////////////////////////////////////////////////////
//Procedure Entry Point
////////////////////////////////////////////////////////
int main(int argc, char **argv)
{


#ifdef USE_COMMS
  //Verify that the shared memory data buffer 
  //has been specified
  if(argc != 3){
    printf("ERROR:Usage::APPLICATION <Shared Memory Segment ID> <Semaphore ID for this shared memory segment>\n");
   return(-1);
  }

  //Initialize shared memory parameters
   /*get the segment ID from the command line */
  segment_id = strtol(argv[1],NULL,0);

  /*get the semaphore ID from the comand line*/
  semid = strtol(argv[2],NULL,0);

  /*attach to the shared memory segment*/
  shared_memory = (char *)shmat(segment_id, 0, 0);
#endif


  //Initialization parameters for glut
  glutInit(&argc, argv);

  //Suggest to O/S where the window should 
  //be initialized at.
  //glutInitWindowPosition(0,0);

  //Initialize the window size
  glutInitWindowSize(640,480);

  //Argument for next opened window
  glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);

  //Create the window
  glutCreateWindow("CUDA Oscilloscope");

  //Register Special Keys and Change Size Functions
  glutReshapeFunc(ChangeSize);
  glutSpecialFunc(SpecialKeys);

  //Register callback function for redrawing window
  glutDisplayFunc(DrawMainWindow);

  //Register callback function for idle processing
  glutIdleFunc(IdleProcessing);

  //Enable depth testing ???
  glEnable(GL_DEPTH_TEST);

  //Set up drawing environment
  //SetupRC();

  //Start the infinite loop - function will never return 
  //till controlled ^c
  glutMainLoop();

  return 0;

}
/////////////////////////////////////////////////////////
//Functions
/////////////////////////////////////////////////////////
void DrawMainWindow(void)
{

  //GLfloat x, y, z;
  float x,y,z;

  //Clear buffer
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  //Save previous settings
  glPushMatrix();

  //Draw all samples 
  glColor3fv(Ch1TrClr);

  //Get scaled / processed data from buffer;
  //this was the data that was created during 
  //idle state
  glBegin(GL_POINTS);
    z = 0.00;
    for(int ii=0; ii < DISP_BUFFER_LENGTH; ii++){

      //plot point on  the coordinate
      x = -nRange + ii*2.00;
      y =  sample_buffer[ii].volts_scaled;  

      //plot the coordinate
      glVertex3f(x,y,z);

    }
  glEnd();




  if(grid_enable == 1){

    //Grid Color and Line Widths
    glColor3fv(GridClr);

    //Draw X and Y axis
    GLint factor = 10;
    GLushort pattern = 0x5555;
    glLineWidth(2);

    //Draw X-Axis
    glBegin(GL_LINES);
    glLineStipple(factor, pattern);
    glVertex3f(-nRange,  0.00, 0.00);
    glVertex3f( nRange,  0.00, 0.00);
    glEnd();

    //Draw Y-Axis
    glBegin(GL_LINES);
    glLineStipple(factor, pattern);
    glVertex3f(0.00, -nRange, 0.00);
    glVertex3f(0.00,  nRange, 0.00);
    glEnd(); 

    //Draw a 10x10 grid ( stipple lines )
    factor = 10;
    pattern = 0x5050;
    glLineWidth(1);

    // //Bottom to top - horizintal lines
    for(float ii=-nRange; ii < nRange; ii += 100)
      {
    glLineStipple(factor, pattern);
    glBegin(GL_LINES);
    glVertex3f(-nRange, ii, 0.00);
    glVertex3f( nRange, ii, 0.00);
    glEnd();
      }

    // //Left to right - vertical lines
    for(float ii=-nRange; ii < nRange+100; ii += 100)
      {
    glLineStipple(factor, pattern); 
    glBegin(GL_LINES);
    glVertex3f(ii, -nRange, 0.00);
    glVertex3f(ii,  nRange,  0.00);
    glEnd();
      }

  }


  //Write Measurement parameters to the screen
  glColor3fv(TextClr);
  WriteText("(Y)::Vertical   Scale=", 50.00, 300.00, 800.00, 0.00);
  WriteText("(X)::Horizontal Scale=", 50.00, 300.00, 700.00, 0.00);

  //FIXME - Display Time Settings
  //FIXME - Display "Paused" if capture is paused
  //FIXME - Display trigger settings
  //FIXME - Display Ch1 Settings

  //Restore previous settings
  glPopMatrix();

  //Puts rendered scene on front buffer
  //glFlush is called by glutSwapBuffers implicitely
  glutSwapBuffers();



}


//FIXME - Several functions are required for GUI

void IdleProcessing(void)
{
  /*clear read buffer so new write data can be added*/
  initSemAvailable(semid, 1);

  /*try bump down semaphore to indicate completion of memory read*/
  reserveSem(semid,0);

  //Here we acquire and process the content of the 
  //data buffer
  double *p = (double *)shared_memory;
  for(int ii=0; ii < DISP_BUFFER_LENGTH; ii++){


#ifdef USE_COMMS
    sample_buffer[ii].volts_scaled = gain*p[ii];
#else
    sample_buffer[ii].volts_scaled = gain*cos((2.0f*GL_PI)*ii*4/DISP_BUFFER_LENGTH + rand()%2) + rand()%10;
#endif
  }


#ifdef DEBUG
  for(int ii=0; ii < DISP_BUFFER_LENGTH; ii++){
    if(ii%10==0){
      printf("\n");
    }

    printf("%f ",sample_buffer[ii].volts_scaled);

  }
  printf("\n");
#endif

  printf("Frame Cntr = %d\r",frame_id);
  frame_id++;

  //FIXME - data processing during idle time
  DrawMainWindow();

}


// This function does any needed initialization on the rendering
// context. 
void SetupRC()
{
  // Black background
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f );

  // Set drawing color to green
  glColor3f(1.0f, 1.0f, 1.0f);

  //enable line stippling
  glEnable(GL_LINE_STIPPLE);
}


void SpecialKeys(int key, int x, int y)
{



  if(key == GLUT_KEY_UP){
    //xRot-= 5.0f;
    if(gain < 10000.00)
      gain = gain + 100.0;
  }

  if(key == GLUT_KEY_DOWN){
    //xRot += 5.0f;
    if(gain > 0.00)
      gain = gain - 100.0;
  }


  if(key == GLUT_KEY_LEFT)
    //yRot -= 5.0f;
    grid_enable = 1;

  if(key == GLUT_KEY_RIGHT)
    //yRot += 5.0f;
    grid_enable = 0;

  if(key > 356.0f)
    xRot = 0.0f;

  if(key < -1.0f)
    xRot = 355.0f;

  if(key > 356.0f)
    yRot = 0.0f;

  if(key < -1.0f)
    yRot = 355.0f;

  // Refresh the Window
  glutPostRedisplay();
}


void ChangeSize(int w, int h)
{

  // Prevent a divide by zero
  if(h == 0)
    h = 1;

  // Set Viewport to window dimensions
  glViewport(0, 0, w, h);

  // Reset projection matrix stack
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  // Establish clipping volume (left, right, bottom, top, near, far)
  if (w <= h) 
    glOrtho (-nRange, nRange, -nRange*h/w, nRange*h/w, -nRange, nRange);
  else 
    glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -nRange, nRange);

  // Reset Model view matrix stack
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();


}


 void WriteText(char *text, float height, float x, float y, float z)
 {

   const float charHeight = 119.05;

   glPushMatrix();
   glTranslatef(x,y,z);

   glScalef(height/charHeight/1.5, height/charHeight, height/charHeight);

   while(*text){
     glutStrokeCharacter(GLUT_STROKE_MONO_ROMAN, (int)*text);
     *text++;
   }

   glPopMatrix();
 }