C#

In reference to the widely used CalculateRamp code:

C#

public static void CalculateRamp(double level, double gamma, double brightness, double contrast)
{
    ramp.Red = new ushort[256];
    ramp.Green = new ushort[256];
    ramp.Blue = new ushort[256];

    gamma /= 10;
    brightness = 1 + (((brightness - 50) / 100) * 65535);
    contrast = 1 + ((contrast - 50) / 100);
    level = 1 + ((level - 50) / 100);

    for (int i = 0; i < 256; i++)
    {
        double value = i * 256;
        value = (Math.Pow(value / 65535, 1 / gamma) * 65535) + 0.5;
        value = ((((value / 65535) - 0.5) * contrast) + 0.5) * 65535;
        value = value += brightness;
        value *= level;
        ramp.Red[i] = ramp.Green[i] = ramp.Blue[i] = 
        (ushort)Math.Min((double)65535, Math.Max((double)0, value));
    }
    SetDeviceGammaRamp(GetDC(IntPtr.Zero), ref ramp);
}

How would you calculate the input values (arguments) for this method directly from the existing Gamma Ramp? In other words, what would be the reverse method?

If I am going to provide these utilities to the user, I need to present them with their current settings prior to their making the adjustments.

I have tried for three days to come up with a solution, and must admit that this is beyond my capabilities.

Update Sept 8, 2016 - My best solution...

While I worked long and hard looking for a mathematical solution, I finally went back and played around with the iteration method.

A blunt force iteration that calculates each and every possible setting and then checks for a match will run for more than 20 minutes; which is unacceptable.

I found that I could take a single sample point in the middle of the array and quickly iterate through all possible settings to find a match for that one sample; and then perform all 256 of the calculations for the array to see if we had a complete match. This operation generally runs in less than a second.

But I realized that there was yet another problem. If the Gamma Ramp was not programmed using the CalculateRamp algorithm (such as factory setting) then it is unlikely that we will find an exact match for our settings; and our solution will fail.

So I devised a backup plan that uses four sample points from across the gamma ramp array; and then set up a "span" of acceptable values that would provide a close approximation for our settings. The criteria for "span" would broaden after each failure, and re-enter the search. This scenario will produce an approximation of the Gamma Ramp Settings usually within about three seconds. This is acceptable since my main program can perform this operation during the program startup sequence.

Here is my C++ solution...

C++

//---------------------------------------------------------------------------
int __fastcall TForm1::Round( double flt ){
   int num = (int) flt;
   if( flt >= 0 ){
      if( flt - num >= .5 ){ num++;}
   }else{
      if( flt - num <= -.5 ){ num--;}
   }
   return( num );
}
//----------------------------------------------------------------------------
void __fastcall TForm1::GetGammaRampSettings(void){
   // level should be between 2 and 100
   // gamma should be between 2 and 50
   // brigntess should be between 0 and 100
   // contrast should be between 0 and 100

   double i,j,k,m;
   double gamma,bright,cntrst,level;
   double v1,v2,v3,v4;
   double c1,c2,c3,c4;
   double a1,a2,a3,a4,b1,b2,b3,b4; //for best estimate criteria
   int x1,x2,x3,x4,x5;
   int d,n;
   WORD span = 8;
   bool tog = false;

   TDateTime strt, end;

   WORD GammaArray[3][256]; //Gamma Ramp Array buffer
   WORD CompArray[256];     //Array buffer for comparison

   HDC GammaDC = GetDC( NULL );  //fetch the gamma ramp array
   GetDeviceGammaRamp( GammaDC, GammaArray );
   ReleaseDC( NULL, GammaDC );

   strt=Now();

   //Find two endpoints for the GammaArray
   for( x1 = 0; x1 < 256; x1++ ){
      if( GammaArray[0][x1] > 0 ){ break;}
   }

   for( x2 = 0; x2 < 256; x2++ ){
      if( GammaArray[0][x2] == 65535 ){ break;}
   }
   if( x2 == 256 ){ x2 = 255; }

   x5 = x1 + Round( (double)( x2 - x1 ) / 2.0 );

   Memo1->Lines->Add( "x1 = " + IntToStr( x1 )); //start
   Memo1->Lines->Add( "x2 = " + IntToStr( x2 )); //end
   Memo1->Lines->Add( "x5 = " + IntToStr( x5 )); //mid

   //neutral settings are as follows...
   //Bright = 50
   //Contrast = 50
   //Level = 50
   //Gamma = 10

   //The following code will look for an exact match to the settings
   //but it may fail if the gamma ramp was not programmed using the
   //original CalculateRamp code. ie: A factory setting, or other

   for(n=0;n<=40;){//gamma
      if( n < 9 ){         //gamma begins with a neutral setting of 10 and
         if( tog ){        //then increments high and low depending on tog
            i = ( 10 - n );
            tog = false; n++;
            if( i == 10 ){ continue;}
         }else{
            i = ( 10 + n );
            tog = true;
         }
      }else{
         i = ( 10 + n++ );
      }
      gamma = i / 10;
      v1 = ( pow( (double)(x5 * 256) / 65535, 1 / gamma) * 65535) + 0.5;
      for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
         level = 1 + ((j - 50) / 100);
         for( k = 0; k < 101; k++ ){//bright
            bright = 1 + (((k - 50) / 100) * 65535);
            for( m = 0; m < 101; m++ ){//contrast
               cntrst = 1 + ((m - 50) / 100);
               //Test only the mid-line value at first
               //To see if a complete comparison is warranted
               c1 = (((( v1 / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
               c1 = c1 += bright;
               c1 *= level;
               if( c1 > 65535){ c1 = 65535; }
               if( c1 < 0 ){ c1 = 0; }
		         if( (WORD) c1 == GammaArray[0][x5] ){
                  for( d = 0; d < 256; d++ ){
                     c1 = ( pow( (double)(d * 256) / 65535, 1 / gamma) * 65535) + 0.5;
                     c1 = ((( (c1 / 65535) - 0.5) * cntrst) + 0.5) * 65535;
                     c1 = c1 += bright;
                     c1 *= level;
                     if( c1 > 65535 ){ c1 = 65535;}
                     if( c1 < 0 ){ c1 = 0;}
                     CompArray[d] = (WORD) c1;
                  }
                  if(memcmp( &CompArray[0], &GammaArray[0][0], 2*256) == 0){
                     goto ENDIT;
                  }
               }
            }
         }
      }
   }

   //Since an exact match could not be found for the current
   //gamma ramp settings, we will broaden our criteria and
   //search for the best match for our gamma ramp settings.

   //Here our search is based on the start and end values,
   //plus two additional values that are 1/4 of the overall distance
   //above the start point; and 1/4 the distance below the end point.

   Memo1->Lines->Add("Values NOT Discovered!!!");
   Memo1->Lines->Add("Widening the Search....");

   x3 = x1 + Round( (double)( x2 - x1 ) / 4.0 );
   x4 = x1 + Round(( (double)( x2 - x1 ) / 4.0 )*3);

   Memo1->Lines->Add( "x1 = " + IntToStr( x1 )); //start
   Memo1->Lines->Add( "x2 = " + IntToStr( x2 )); //end
   Memo1->Lines->Add( "x3 = " + IntToStr( x3 )); // 1/4
   Memo1->Lines->Add( "x4 = " + IntToStr( x4 )); // 3/4

   BROADEN:

   a1 = GammaArray[0][x1]+span; //these are our high and low
   b1 = GammaArray[0][x1]-span; //values that the ramp values must
                                //fall within to be accepted
   a2 = GammaArray[0][x2]+span;
   b2 = GammaArray[0][x2]-span; //span begins at 8 and increments upwards
                                //with each loop, ever widening the
   a3 = GammaArray[0][x3]+span; //the search criteria
   b3 = GammaArray[0][x3]-span;

   a4 = GammaArray[0][x4]+span;
   b4 = GammaArray[0][x4]-span;

   tog=false;
   for(n=0;n<=40;){//gamma
      if( n < 9 ){         //gamma begins with a neutral setting of 10 and
         if( tog ){        //then increments high and low depending on tog
            i = ( 10 - n );
            tog = false; n++;
            if( i == 10 ){ continue;} //prevents two instances of i == 10
         }else{
            i = ( 10 + n );
            tog = true;
         }
      }else{
         i = ( 10 + n++ );
      }
      gamma = i / 10;
      v1 = ( pow( (double)(x1 * 256) / 65535, 1 / gamma) * 65535) + 0.5;
      v2 = ( pow( (double)(x2 * 256) / 65535, 1 / gamma) * 65535) + 0.5;
      v3 = ( pow( (double)(x3 * 256) / 65535, 1 / gamma) * 65535) + 0.5;
      v4 = ( pow( (double)(x4 * 256) / 65535, 1 / gamma) * 65535) + 0.5;
      for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
         level = 1 + ((j - 50) / 100);
         for( k = 0; k < 101; k++ ){//bright
            bright = 1 + (((k - 50) / 100) * 65535);
            for( m = 0; m < 101; m++ ){//contrast
               cntrst = 1 + ((m - 50) / 100);
               //Test the four sample values to see if the
               //results falls within our acceptance criteria.
               c1 = (((( v1 / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
               c1 = c1 += bright;
               c1 *= level;
               c2 = (((( v2 / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
               c2 = c2 += bright;
               c2 *= level;
               c3 = (((( v3 / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
               c3 = c3 += bright;
               c3 *= level;
               c4 = (((( v4 / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
               c4 = c4 += bright;
               c4 *= level;
		         if( c1 <= a1 && c1 >= b1 &&  c2 <= a2 && c2 >= b2 &&
                   c3 <= a3 && c3 >= b3 &&  c4 <= a4 && c4 >= b4 ){
                   Memo1->Lines->Add("Best Estimate +/- " + IntToStr( span ));
                   goto ENDIT;
               }
            }
         }
      }
   }

   if( span < 256){
      span *= 2;
      goto BROADEN;
   }else if( span <= 4096 ){ //set the maximum allowance for "span"
      span += 128;           //which is the basis for the allowable
      goto BROADEN;          //search criteria
   }

   //if we get to this point then we have utterly failed.
   Memo1->Lines->Add("Values STILL NOT Discovered.");
   Memo1->Lines->Add("GetGammaRampSettings Failed.");
   return;

   ENDIT:
   end=Now();
   Memo1->Lines->Add("Execution duration was "+
         FormatDateTime("nn:ss:zzz",end-strt));

   //Report on findings...
   Memo1->Lines->Add("Bright = " + IntToStr( (int) k ));
   Memo1->Lines->Add("Cntrst = " + IntToStr( (int) m ));
   Memo1->Lines->Add("Level = " + IntToStr( (int) j ));
   Memo1->Lines->Add("Gamma = " + IntToStr( (int) i ));

}
//---------------------------------------------------------------------------

modified 8-Sep-16 14:53pm.

Keith Davis wrote:
the widely used CalculateRamp code

Widely used by whom, and for what purpose? It also look like this is C# code not C++.

Yes this is C# code but I have found it on the Internet in C++ as well. The math is essentially the same either way.

This algorithm is used to adjust (or program) your graphic's card's gamma ramp with inputs for Brightness, Contrast, Level, and Gamma. It works well.

For test purposes I created a graph that plots the resulting gamma ramp. This helps me to visualize the changes made to the gamma ramp array; but I can't figure out how to work the problem from the existing gamma ramp array back to what would be the input arguments for Brightness, Contrast, Level, and Gamma.

It is simply beyond me.

Here is my C++ implementation of the algorythm:

C++

C#

void __fastcall TForm1::SetRamp(double level, double gamma, double bright, double cntrst){
// level should be between 2 and 100
// gamma should be between 2 and 50
// brigntess should be between 0 and 100
// contrast should be between 0 and 100
   HDC GammaDC=GetDC(NULL);
   WORD GammaArray[3][256];

   gamma /= 10;
   bright = 1 + (((bright - 50) / 100) * 65535);
   cntrst = 1 + ((cntrst - 50) / 100);
   level = 1 + ((level - 50) / 100);

   for(DWORD i=0;i<256;i++){
      double value = i * 256;
      value = (pow(value / 65535, 1 / gamma) * 65535) + 0.5;
      value = ((((value / 65535) - 0.5) * cntrst) + 0.5) * 65535;
      value = value += bright;
      value *= level;
      if(value>65535){value=65535;}
      if(value<0){value=0;}
		GammaArray[0][i]=GammaArray[1][i]=GammaArray[2][i]=(WORD)value;
   }
   
   if(!SetDeviceGammaRamp(GammaDC,GammaArray)){
      Memo1->Lines->Add("SetDeviceGammaRamp Failed");
      GraphIt(&GammaArray[0][0], false);
   }else{
      GraphIt(&GammaArray[0][0], true);
   }
   ReleaseDC(NULL,GammaDC);
}

All the gamma ramp or inv ramp does is stretch or compress the greyscale representation of the color range map.

So two simplest shapes you play with is exponential and 1-exponential graphs. A simple google of the two functions
will give you the formula and code for them. The above is an exponential hence the power function. Really you only
need the exponential form because 1-exp will give you the reverse code.

So if the above code works as you want 1 - (the exponential result) is the inverse it really is that simple as the
code result must be in the range between 0-1 you should be able to see why it inverts the graph. If you can't see
the logic google exp function and 1-exp function for the explaination.

In vino veritas

Hi Leon,

I understand what is going on with the Gamma Ramp. My question is really a math problem, and thus far the solution is beyond my skill level.

The algorithm previously posted works very well, and gives good control of the gamma ramp. What I don't understand concerning this algorithm is why my question has not been asked before. It seems that the first thing you would want to do is interpret the current settings from the gamma ramp array; and present the current settings to the user so that he can then begin to make adjustments by using the algorithm that I previously posted.

I'm trying to work the problem backwards from the GetDeviceGammaRamp function call to whatever input values would be required to create the current gamma ramp array: What will be the Brightness setting, what will be the Contrast setting, what will be the Level setting, and what will be the Gamma setting "going in".

The way that the input algorithm works is made ever more complex because "value" undergoes four or five operations before arriving at a final input value for each of the 256 members of the array. How to reverse this series of operations has me stumped.

Given any two of the three parts for any of these operations; it is possible to come up with the third part:

For example: any unknown part of 6=2*3 can be determine so long as any two parts are known ie: 3=6/2.

x=pow(y,z): y can be determined using y=pow(x,(1.0/z)); and z can be determined using log(x)/log(y).

The initial "value" is determined by it's place in the array, so this is known to us. Also know to us is the final value of "value" because we can extract it from the current gamma ramp array. So how would you work the problem backwards through each operation from the value of the gamma array [element] to determine each of the values for Brightness, Contrast, Level, and Gamma?

My graph visually demonstrates what is going on with the gamma ramp array. When Gamma is set to input value of 10, the curve is neutralized, and the graph presents a strait line.

When Brightness is lower than 50 the line moves in parallel from the 45 degree angle towards the lower right, and greater that 50 moves the line towards the upper left in parallel.

When Contrast is lower than 50, the graph line pivots clockwise about it's midpoint, and an input greater than 50 will pivot the line counterclockwise about its midpoint.

When Level is adjusted below 50 then the end of the graph line swings downwards while the starting point (0,0) remains stationary; and when Level is adjusted upwards the end of the graph line swings upwards while the starting point remains stationary.

When Gamma is adjusted to either side of 10; the graph line becomes a positive or negative curve.

All very interesting, but it doesn't provide me with any solutions to my problem.

At any rate, thanks for your interest and your input!

Best regards,
In Corona simul veritas Smile | :)

I started working a much more detailed description of how to play with the curve but realized that isn't what you were confused about.

Gamma-correcting an image is essentially raising its color intensities to 1/gamma, so that when the monitor in turn raises the value to gamma, these cancel out.

You said ... I'm trying to work the problem backwards from the GetDeviceGammaRamp function call to whatever input values would be required to create the current gamma ramp array. You need to explain why you want to reverse it .. you aren't a hardware device. Your code is designed for something like a game where it simply loads a slight adjustment to the colors at start up where it will set the gamma ramp table on the DC. You sound more like you are trying to do something like an ICC profile.

Your code is a basic exponential function it wouldn't really match a real monitor gamma output distortion which would need something like a spline. That would all be done in a processing phase not down on the output out to a device context. So I think you need to explain more what you are trying to do.

Perhaps read the Microsoft overview of gamma control on windows and expand it from there.
Using gamma correction (Windows)[^]

The current gamma correction occurs on 1 line of code in your example above

value = (Math.Pow(value / 65535, 1 / gamma) * 65535) + 0.5;

The initial gamma is divided by 10 so if you enter 10 you get Math.Pow(value / 65535, 1) that is it's linear
and the value is basically value/65535*65535 .. AKA the same value.

Value is defined as

double value = i * 256;

So all that whole function does is return a value in 256 step increments.
With gamma set to 10 you are going to get 0,255,511, ... 65535

The reverse table can be built using the line

value = (Math.Pow(value / 65535, gamma) * 65535) + 0.5;

Straight mathematics anything raised to a power is inverted by raising to 1/power so replace 1/gamma with gamma, I made bold and underlined so the substitution is more obvious.

Still confused what you are trying to do, but hopefully something there helps.

In vino veritas

modified 5-Sep-16 6:26am.

Hi Leon,

I took a good look at the code and the web site that you suggested, and I find it interesting. That said, I don't think it applies to my application. If I'm not mistaken, your suggested code would be something that you might use for adjusting the gamma of a photo.

The algorithm that I have put forward is actually easy to control with either four slider controls, or four updown/edit controls that will affect the graphics card for your display monitor. One control for each of the following Brightness, Contrast, Level, and Brightness.

Allow me to explain the goals that I need to achieve here in my application:

I am working on a Navigation Display where there are strict specifications for color and brightness calibration in three viewing modes: Daytime, Twilight, and Night. In this application I also make calls to GetSysColors and SetSysColors to change the over all appearance of the Windows display for Day, Twilight, and Night. The specifications also call for three specific cursors that each have to meet strict size and color requirements for each display mode. There are numerous color checks involved, as well as a grey scale display check that must appear ever time the user switches to the night time display settings (and on demand).

These specifications are laid out in the the International Hydrographic Organizations (IHO) Presentation Library for ECDIS which uses the S-57 Electronic Navigation Chart (ENC) display.

For the twilight and night time display modes it is critical that mariner's night vision be preserved, and that optimum view-ability be achieved under bright sunlight conditions.

The grey scale check that is required consist of a black box with a slightly lighter shaded box inside for which the user must be able to calibrate his display so that the lighter shaded box can be easily differentiated from the black box background. The algorithm above serves these calibration purposes.

I have used this algorithm for a number of years to adjust my own display for less eye strain when I'm spending hours at a time writing code - sometimes in a night time environment (on the ship's bridge). Because of the my inability to derive the Brightness Contrast, Level, and Gamma settings directly from the Gamma Ramp array, I have not employed this method in any of my software releases.

Thus far the best I have been able to do is iterate through all possible settings until the output matches the Graphics Card's Gamma Ramp array received through the GetDeviceGammaRamp call. This works but it takes about 49,000,000 iterations and runs for 15-20 minutes. I have applied some variations to this which has shortened the run time; but it still takes about 5 minutes to run it. I need to be able to derive these settings in about a one second. I haven't given up yet though Smile | :)

I hope this helps to better explain my goals.

Again, thank you for your interest and your suggestions; it is much appreciated!

Best regards.

But what you are doing seems to be re-inventing the wheel at least on Windows 7, 8 and 10 or I am completely missing something.

If you go to color management in control panel on Windows and tick the box on the display that says use color management (it defaults off) it will use the ICC profile for the monitor. That profile will exist so long as it has detected the monitor type and isn't using the generic. You will see the ICC profile in the box labelled Profiles associated to this device.

For most Joe Average they would only go looking for this setting if they are running dual monitors and want the two displays to have the exact some color output to the eye. It's really annoying when you have two monitors side by side on a dual monitor system with different shades. The whole point of the ICC is so that the computer color space looks exactly the same when displayed on different monitors.

So can I first ask is the color management turned on in your situation? If it is on then why don't you directly read the ICC profile which seems to be the exact thing you are trying to map from the the deviceramptable?

At least then you are down to each user will see every monitor the same, and now you need to adjust simply for each users eye which would carry from monitor to monitor if they are all running ICC or is there something I am missing?

In vino veritas

modified 5-Sep-16 12:31pm.

Hi Leon,

I actually haven't examined the Windows Color Management; and perhaps I should look into this.

However, I would still have to meet the specifications laid down by the IHO.

These specifications are fairly strict. When the ECDIS is set up it has to be inspected and tested with an instrument that reads the color values directly from the display screen; and they must meet specifications or else adjustments must be made to the [X,Y,L] color tables (and/or the hardware). I have had to build these testing scenarios and conversion functions into the software. Additional routines for the mariner to do self testing at sea are also a requirement (color comparison charts and the grey scale test that I mentioned previously).

To say the least, meeting these specifications has been fairly demanding. There are several thousand pages in total; and the display requirements come up again and again through out.

Getting these Brightness, Contrast, Level, and Gamma settings from the gamma ramp array has just been a minor setback in the grand scheme of things, but sooner or later I'll figure it out. I may be close to being able to extract the current gamma setting - working on it...

Cheers Smile | :)

You went and made me look it up just out of curiosity Smile | :)

The definitive details is given in the specification
https://www.iho.int/iho_pubs/standard/S-52/S-52_e6.0_EN.pdf[^]

-Software to generate the required colours for use during the calibration. This will 
be a program that allows the user to adjust the colour DAC values from 0 to 255 
in each of Red, Green and Blue.
- Software to calculate the transformation between RGB and CIE x, y, L values. 
(This software is part of the Presentation Library.)

Your physical testing is for compliance to the standard CIE absolute color space.

Any windows OS from 7 up with color management turned on, with a compliant monitor should meet that specification and you just need to do the user controls they ask for in the specification. If it doesn't either the monitor manufacturer or Microsoft has some answering to do.

In vino veritas

Thanks for that insight. I sort of suspected that most modern monitors and operating systems would be compliant. It is going to be the end user's responsibility to have their system certified, and then do the regular checks that are required.

There is the software for conversion of the xyl values, and there is also software for the performing the color test on a CRT monitor. At the time I purchased my current version of the Presentation Library (2008) they had not yet developed tests for a LCD display. The latest version of the Presentation Library is in transit to me now, and I'm curious to see what changes have been made to the specifications since my 2008 version; and whether they will now have some sort of testing procedure for the LCD monitor. In 2008 it was still under consideration.

The way I see it, I just have to meet the specs; but even that going to be daunting. I don't expect to have this ECDIS system ready for another two years. I have had a navigation program out since 2003 - but it is not ECDIS. There are no electronic navigation charts in my existing system; but it does have background maps (world wide coverage). My latest (as yet unreleased) version is also NMEA 2000 compatible and features extensive networking capabilities. The system also has it's own "line tracking" autopilot built into it; which is great for oceanographic survey work - I hate driving lines day in and day out - it's mind numbing.

I have only recently decided that it was time to take my nav program to the next level; and make it ECDIS compliant.

Again, thanks for checking that out Smile | :)

Cheers!

Hi Leon,

I have finally found a solution for my problem; and have edited my original post to reflect this. It's not a mathematical solution, but it works well enough.

I just thought I'd give you a heads up since you took an interest Smile | :)

Thanks again for your input!
Keith

Quote:
After unsuccessfully trying to solve for a mathematical solution for a week I had to try some other way to derive the Gamma Ramp Settings directly from the GetDeviceGammaRamp call.

One early attempt involved a simple iteration of all possible settings. This gave correct results, but it took more than 20 minutes to complete the operation. My application needs to be able to do this in under a second.

I finally found a better, more efficient way to perform the iterations, and it meets my requirements. It may be an imperfect solution; but a win is a win.

I shaved a little more time off of this operation by testing for a positive or a negative curve in the Gamma setting (or no curve at all = neutral setting 10). This saves a few iterations going in. To do this I created two additional functions: PtToPtRngBrg and GetPtFromPt.

If you like, you can skip these; and simply iterate through all possible Gamma settings (2 to 50). This would greatly simplify the code.

Here is my C++ solution...

C#

//---------------------------------------------------------------------------
#define DEG_RAD 0.017453292519943295769236907684886
//---------------------------------------------------------------------------
struct RngBrg{  //Struct for return values in the
   double rng;  //call to PtToPtRngBrg
   double brg;
};
//---------------------------------------------------------------------------
void __fastcall TForm1::GetGammaRampSettings(void){
   // level should be between 2 and 100
   // gamma should be between 2 and 50
   // brigntess should be between 0 and 100
   // contrast should be between 0 and 100

   double i,j,k,m,m4;
   double s1,s2,s3,s4;
   double gamma,bright,cntrst,level;
   double value;
   int d;
   int x1,x2,x3,x4;
   bool isFound=false;
   RngBrg rb; //Range and Bearing struct for distance and vector

   WORD GammaArray[3][256]; //Gamma Ramp Array buffer
   WORD CompArray[256];     //Array buffer for comparison
   double DArray[256];      //buffer used to hold gamma values

   HDC GammaDC = GetDC( NULL );  //fetch the gamma ramp array
   GetDeviceGammaRamp( GammaDC, GammaArray );
   ReleaseDC( NULL, GammaDC );

   //Calculate the Angle:

   //Find two endpoints for the GammaArray
   for( x1 = 0; x1 < 256; x1++ ){
      if( GammaArray[0][x1] > 0){break;}
   }

   for( x2 = 0; x2 < 256; x2++ ){
      if( GammaArray[0][x2] == 65535){isFound=true; break;}
   }
   if( !isFound ){ x2--; }

   //normalize the gama ramp numbers
   //so that a distance and vector can be calculated
   s1 = ( (double) GammaArray[0][x1] + 1 ) / 256.0;
   s2 = ( (double) GammaArray[0][x2] + 1 ) / 256.0;

   //find the mid point array element from the line described above...
   x3 = x1 + ( ( x2 - x1 ) / 2 );
   s3 = ( (double) GammaArray[0][x3] + 1 ) / 256.0;

   Memo1->Lines->Add( "x1 = " + IntToStr(x1) + "  s1 = " + AnsiString(s1));
   Memo1->Lines->Add( "x2 = " + IntToStr(x2) + "  s2 = " + AnsiString(s2));
   Memo1->Lines->Add( "x3 = " + IntToStr(x3) + "  s3 = " + AnsiString(s3));

   //caculate the strait line between
   //the two endpoints discovered above
   PtToPtRngBrg( &rb, x1, s1, x2, s2 );

   //neutral settings are as follows...
   //Bright = 50
   //Contrast = 50
   //Level = 50
   //Gamma = 10
   //rng = 359.210244842766 and  brg = 45 with all neutral settings
   Memo1->Lines->Add( "rng = " + AnsiString( rb.rng ) +
                      "  brg = " + AnsiString( rb.brg ));

   //what would be the value of the midpoint
   //if it were a strait line (neutral gamma setting)?

   GetPtFromPt(x1, s1, rb.rng / 2.0, rb.brg, &m4, &s4);

   Memo1->Lines->Add("m4 = " + IntToStr( Round(m4) ) + "  s4=" + AnsiString(s4));
   Memo1->Lines->Add("s3 - s4 = " + AnsiString( s3-s4 ));

   x4 = Round(m4); //Rounding function call

   if(( s4 - s3 ) > 1 ){//we have a negative gamma curve (G<10)
      Memo1->Lines->Add("Negative Gamma Curve");
      for( i = 9; i > 1; i-- ){
         gamma=i/10;
         for( d = 0; d < 256; d++ ){
            DArray[d] = ( pow( (double)(d * 256) / 65535, 1 / gamma) * 65535) + 0.5;
         }
         for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
            level = 1 + ((j - 50) / 100);
            for( k = 0; k < 101; k++ ){//bright
               bright = 1 + (((k - 50) / 100) * 65535);
               for( m = 0; m < 101; m++ ){//contrast
                  cntrst = 1 + ((m - 50) / 100);
                  //Test only the mid-line value at first
                  //To see if a complete comparison is warranted
                  value = (((( DArray[x4] / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
                  value = value += bright;
                  value *= level;
                  if( value > 65535){ value = 65535; }
                  if( value < 0 ){ value = 0; }
		            if( (WORD) value == GammaArray[0][x4] ){
                     for( d = 0; d < 256; d++ ){
                        value = ((( (DArray[d] / 65535) - 0.5) * cntrst) + 0.5) * 65535;
                        value = value += bright;
                        value *= level;
                        if( value > 65535 ){ value = 65535;}
                        if( value < 0 ){ value = 0;}
                        CompArray[d] = (WORD) value;
                     }
                     if(memcmp( &CompArray[0], &GammaArray[0][0], 2*256) == 0){
                        goto ENDIT;
                     }
                  }
               }
            }
         }
      }
   }else if((s3-s4)>1){//we have a positive gamma curve(G>10)
      Memo1->Lines->Add("Positive Gamma Curve");
      for( i = 11; i < 51; i++ ){
         gamma=i/10;
         for( d = 0; d < 256; d++ ){
            DArray[d] = ( pow( (double)(d * 256) / 65535, 1 / gamma) * 65535) + 0.5;
         }
         for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
            level = 1 + ((j - 50) / 100);
            for( k = 0; k < 101; k++ ){//bright
               bright = 1 + (((k - 50) / 100) * 65535);
               for( m = 0; m < 101; m++ ){//contrast
                  cntrst = 1 + ((m - 50) / 100);
                  //Test only the mid-line value at first
                  //To see if a complete comparison is warranted
                  value = (((( DArray[x4] / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
                  value = value += bright;
                  value *= level;
                  if( value > 65535){ value = 65535; }
                  if( value < 0 ){ value = 0; }
		            if( (WORD) value == GammaArray[0][x4] ){
                     for( d = 0; d < 256; d++ ){
                        value = ((( (DArray[d] / 65535) - 0.5) * cntrst) + 0.5) * 65535;
                        value = value += bright;
                        value *= level;
                        if( value > 65535 ){ value = 65535;}
                        if( value < 0 ){ value = 0;}
                        CompArray[d] = (WORD) value;
                     }
                     if(memcmp( &CompArray[0], &GammaArray[0][0], 2*256) == 0){
                        goto ENDIT;
                     }
                  }
               }
            }
         }
      }

   }else{//no gamma curve (G=10)
      Memo1->Lines->Add("No Gamma Curve");
      i=10;
      gamma=1;  //same as 10 / 10
      for( d = 0; d < 256; d++ ){
         DArray[d] = ( pow( (double)(d * 256) / 65535, 1 / gamma) * 65535) + 0.5;
      }
      for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
         level = 1 + ((j - 50) / 100);
         for( k = 0; k < 101; k++ ){//bright
            bright = 1 + (((k - 50) / 100) * 65535);
            for( m = 0; m < 101; m++ ){//contrast
               cntrst = 1 + ((m - 50) / 100);
               //Test only the mid-line value at first
               //To see if a complete comparison is warranted
               value = (((( DArray[x4] / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
               value = value += bright;
               value *= level;
               if( value > 65535){ value = 65535; }
               if( value < 0 ){ value = 0; }
		            if( (WORD) value == GammaArray[0][x4] ){
                  for( d = 0; d < 256; d++ ){
                     value = ((( (DArray[d] / 65535) - 0.5) * cntrst) + 0.5) * 65535;
                     value = value += bright;
                     value *= level;
                     if( value > 65535 ){ value = 65535;}
                     if( value < 0 ){ value = 0;}
                     CompArray[d] = (WORD)value;
                  }
                  if(memcmp( &CompArray[0], &GammaArray[0][0], 2*256) == 0){
                     goto ENDIT;
                  }
               }
            }
         }
      }
   }

   Memo1->Lines->Add("Values NOT Discovered - Checking All Values...");

   //if for any reason we did not find a match, reiterate through
   //all possible gamma settings...

   for(i=2;i<51;i++){
      gamma=i/10;
      for( d = 0; d < 256; d++ ){
         DArray[d] = ( pow( (double)(d * 256) / 65535, 1 / gamma) * 65535) + 0.5;
      }
      for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
         level = 1 + ((j - 50) / 100);
         for( k = 0; k < 101; k++ ){//bright
            bright = 1 + (((k - 50) / 100) * 65535);
            for( m = 0; m < 101; m++ ){//contrast
               cntrst = 1 + ((m - 50) / 100);
               //Test only the mid-line value at first
               //To see if a complete comparison is warranted
               value = (((( DArray[x4] / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
               value = value += bright;
               value *= level;
               if( value > 65535){ value = 65535; }
               if( value < 0 ){ value = 0; }
		            if( (WORD) value == GammaArray[0][x4] ){
                  for( d = 0; d < 256; d++ ){
                     value = ((( (DArray[d] / 65535) - 0.5) * cntrst) + 0.5) * 65535;
                     value = value += bright;
                     value *= level;
                     if( value > 65535 ){ value = 65535;}
                     if( value < 0 ){ value = 0;}
                     CompArray[d] = (WORD) value;
                  }
                  if(memcmp( &CompArray[0], &GammaArray[0][0], 2*256) == 0){
                     goto ENDIT;
                  }
               }
            }
         }
      }
   }

   Memo1->Lines->Add("Values Still NOT Discovered!!!");
   Memo1->Lines->Add("Discovery Operation Failed.");
   return;

   ENDIT:

   Memo1->Lines->Add("Bright = " + IntToStr((int)k));
   Memo1->Lines->Add("Cntrst = " + IntToStr((int)m));
   Memo1->Lines->Add("Level = " + IntToStr((int)j));
   Memo1->Lines->Add("Gamma = " + IntToStr((int)i));
}
//---------------------------------------------------------------------------
short __fastcall TForm1::Round(double flt){
   short num=(short)flt;
   if(flt>=0){
      if(flt-num>=.5){num++;}
   }else{
      if(flt-num<=-.5){num--;}
   }
   return(num);
}
//----------------------------------------------------------------------------
bool __fastcall TForm1::PtToPtRngBrg(RngBrg *rb,double x1,double y1,double x2,double y2){//was PixToPixRngBrg
   rb->rng=0;rb->brg=0;
   //range is in pixels
   double diffx,diffy,dangle;
   if(x1>=x2){
      if(x1>=0&&x2<0){diffx=x1+fabs(x2);}else{diffx=x1-x2;}
   }else{
      if(x2>=0&&x1<0){diffx=x2+fabs(x1);}else{diffx=x2-x1;}
   }
   if(y1>=y2){
      if(y1>=0&&y2<0){diffy=y1+fabs(y2);}else{diffy=y1-y2;}
   }else{
      if(y2>=0&&y1<0){diffy=y2+fabs(y1);}else{diffy=y2-y1;}
   }

   if(diffx==0){
      rb->brg=0;rb->rng=y2-y1;
      return true;
   }
   if(diffy==0){
      rb->brg=90;rb->rng=x2-x1;
      return true;
   }
   dangle=atan(diffy/diffx);
   rb->rng=diffx/cos(dangle);//hyp
   dangle=dangle/DEG_RAD;
   rb->brg=90-dangle;
   return true;
}
//-----------------------------------------------------------------------
void __fastcall TForm1::GetPtFromPt(double x, double y,double rng,double brg,double *x2,double *y2){
   //Gets a pix(coord) from a pix (coord)
   //range is in absolute pixels
   if(brg>=360){brg-=360;}
   if(brg<0){brg+=360;}
   if(brg==360||brg==0){*x2=x;*y2=y+rng;return;}
   if(brg==270){*y2=y;*x2=x-rng;return;}
   if(brg==90){*y2=y;*x2=x+rng;return;}
   if(brg==180){*x2=x;*y2=y-rng;return;}

   if(brg<90){
      *x2=x+(rng*cos((90-brg)*DEG_RAD));
      *y2=y+(rng*sin((90-brg)*DEG_RAD));
      return;
   }
}
//---------------------------------------------------------------------------

Hi,

I am getting around to using a printer direct. It is a Steep Learning Curve! Prior to this, I produced Text Files, which could be Printed via Notepad.

Grabbed the Bull by the Horns, Want to print Straight from the Program.
I am using MFC42. The Target Machines are Win XP-SP1. (None are Internet Enabled, The System is Outside the Internet)

The Second Hand Win 8 computer I use to write on, has a Device Driver for an HP Printer. All goes well, until I hit the Print button in the Print Dlg. Then everything crashes.

End up After the Crash with a Dlg to tell me in very many words that the printer device could not be found!

Now, I know that there is no physical printer attached to my machine, but, there should be a more graceful idea of notifying me about that fact, other than crashing.
For Instance, Can I query the CDC about a Printer being Plugged In, etc.

Kind Regards,

Smile | :)

Bram van Kampen

Are you using CPrintDialog Class[^] to get the details of the printer? If you do not have a physical printer attached you can use the MS XPS writer, or if you have a PDF print application installed you can use that.

Well, Thanks Richard.

I worked the sample given by Chris Mauder on the MFC Forum about Printing without the Document-View Architecture. I use the CPrintDialog to obtain a pointer to a device Context, presumably in my case pointing to a HP Printer,(Apparently Installed by the Previous Owner of the Laptop) and all appears to work well. I retrieve a (pointer to) a CDC from the CPrintDialog, and the Pointer is Not NULL.

The Only thing is that there is no HP, (or, any) Printer Plugged In. (It is my Coding Laptop) My experience with say 'MS Office' is, that when the printer is not actually plugged in at the time, that the job gets spun off to the print spooler where it remains until that printer becomes available.

Is this a Feature of the Windows Print Spooler, or, a Feature of 'MS Office'?

The result in my case is a very major Foul Up, and, Minutes Later, a Message from the HP Driver that the Device cannot be found, complete with Major Advice to check Cable Connections, and a Range of Other Things.

Now, on Further Reflection, (time for quiet reflection is something that we are unlikely (and Unwisely) allow to afford ourselves when hunting for Bugs.)

It may well be that the HP Printer Driver is corrupted. My Coding Laptop is not on the Internet for obvious reasons.(Installation of the "Ms Dev Studio97" on a Win7 Computer gives an Immediate alarm under 'IsGenuine' for the OS)
I'll try to install another printer driver, (from a CD), and see how it goes.

I am ashamed to say that I have avoided Printing for the last 25 years, actually, since my Dos Days.
I have decided to bite the bullet on this Application.
I Dealt with printing in the past by sending things to a Text File, and to use NotePad, when a Printout was needed.

Also, seeing that I only need to print only a few pages, mostly One A4, sometimes 2 or 3, I did not go to the complication of doing this in a Worker Thread. I want to learn how to Crawl, before trying to learn how to Run.
Would this have an Impact. Chris Mauder's example did not mention threads.

The thing is, when things go wrong, and, especially in a for me a New and crucial Field, is: Am 'I' doing something Wrong, or Misunderstanding Something.

Once Again, thanks for your response, Richard.
I'll keep you posted on how I get on.

Smile | :)

Bram van Kampen

Bram van Kampen wrote:
Is this a Feature of the Windows Print Spooler, or, a Feature of 'MS Office'?

That's the spooler, which will try to send the file to the print driver. The driver may then pop up a dialog to say the printer is offline. In all my experience the file will remain in the spooler until it gets printed, or the user cancels it. What you call a major Foul Up sounds like normal behaviour. As I said before, you should have the Windows XPS print driver (creates an XPS file) installed so you can test with that.

He is using XP SP1. That does not has the XPS driver and installing it requires probably a higher SP version.

But using a PDF driver as already suggested by you should do the trick.

But using Win 8 for development.

You are right. I missed that.

That's OK, I missed the XP bit. Smile | :)

Well,
I Got it to Produce the XPS File without Complaining. However, The XPS Reader complains it Cannot Read the XPS File. Both in Win7 and Win 10. The Text I propose to Print is as Follows:-
It Renders in NotePad as:

C++

     Finding Old Orders in the Shop     
Printed by <????> on 01 09 16 - 23:40:14

Customer:-                              
TONY LOUGHLIN                           

If The Item(s) are Found you should     
Update the Computer Record, and         
Destroy this Page!                      
Otherwise Inform Management of the      
Discrepancies, by Returning this Page   
Marked Up Accordingly!                  

Order Nr 214058                         

Received on: 27/07/12 - 13:18:21        

Not Confirmed Present since Completion  

  Qty  Description                Amount
    1  lb Wash +Dry               £11.00
                                ========
       Total For Order            £11.00
       Due for This Order         £11.00

Packaging:- -1Wb                        

========================================

<pre>
        Actually Found:-

Hangers Pastics Flatpacks WashBags
+~~-+ +~~-+ +~~-+ +~~-+

| | | | | | | |

| | | | | | | |

| | | | | | | |

+~~-+ +~~-+ +~~-+ +~~-+

========================================

The XPS File I got was,in Binary.

There is nothing wrong with the way I present My Data,
Somehow the Printer will not Digest it.

I Need to get to the bottom of this, and everybodies help is much appreciated.
If Needed, will show the Code!

Regards, Smile | :)

Bram van Kampen

Bram van Kampen wrote:
The XPS File I got was,in Binary.

As you would expect, since it also includes formatting information about the content. I have used this to test printing in my applications, and never had a problem. I guess you need to look at your actual printing code.

Well,

The Binary I get refuses to open.

Here is my Printing Code:-

C++

///////////////////////////////////////////////////////////////////////////////////
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
//
// PRINTING!!
///////////////////////////////////////////////////////////////////////////////////

// OnClick the Print Button
void CConfirmOrdersStep1Dlg::OnPrint() 
{
    if(CreateViewForPrinting()==false){
        AfxMessageBox("No Orders have been Marked for Printing");
        return;
    }
    CDC dc;
    CPrintDialog printDlg(FALSE);

<pre>
if (printDlg.DoModal() == IDCANCEL)     // Get printer settings from user
    return;

dc.Attach(printDlg.GetPrinterDC());     // Get and attach a printer DC
dc.m_bPrinting = TRUE;

CString strTitle="Old Orders";                       // Get the application title
//strTitle.LoadString(AFX_IDS_APP_TITLE);

// strTitle.Format("Date:Confirming Old Orders By:- %s-%s", UserName,Date);

DOCINFO di;                             // Initialise print document details
memset(&di, 0,sizeof (DOCINFO));
di.cbSize = sizeof (DOCINFO);
di.lpszDocName = strTitle;

BOOL bPrintingOK = dc.StartDoc(&di);    // Begin a new print job

// Get the printing extents and store in the m_rectDraw field of a 
// CPrintInfo object
CPrintInfo Info;
Info.m_rectDraw.SetRect(0,0, 
                        dc.GetDeviceCaps(HORZRES), 
                        dc.GetDeviceCaps(VERTRES));

OnBeginPrinting(&dc, &Info);            // Call your "Init printing" function

// Now, Print every Page!
UINT page;
for (page=Info.GetMinPage(); page <= Info.GetMaxPage() && bPrintingOK;page++){

    dc.StartPage();                     // begin new page
    Info.m_nCurPage = page;
    PrintPage(&dc, &Info);                // Call your "Print page" function
    bPrintingOK = (dc.EndPage() > 0);   // end page
}
OnEndPrinting(&dc, &Info);              // Call your "Clean up" function

if (bPrintingOK)
    dc.EndDoc();                        // end a print job
else
    dc.AbortDoc();                      // abort job.

dc.DeleteDC();                          // delete the printer DC

}

// As from Chris Mauder.
// Instead of Global I made it a member
//
// m_pView (Type COrderPageView) contains a list of PageFragments
// The Fragment at index 0 is the header, to be printed at the Top
// of each Page (Customer Details, etc)
// CondensePages() does Nothing for Now.
//
// Anyways, This Works, as I can successfully print the Page to a Text
// File.

void CConfirmOrdersStep1Dlg::OnBeginPrinting(CDC * pDC, CPrintInfo * pInfo)
{
// Set the Font to "CourierNew"
CFont PrinterFont;

if(!PrinterFont.CreatePointFont( 
    100,                     //int nPointSize*10, 
    "Courier New",      //LPCTSTR lpszFaceName, 
    pDC)){              //CDC* pDC = NULL 
    ASSERT(NULL);
    return;
}

// Here we have m_pPageList, a poiner to a CPageList Object
// the First Entry is a Header, detailing the Customer,
// The Next Entries contain Order Bodies, complete with
// Totals and Check Boxes!
// We can find out how high each Line Rectangle is.
CSize Size=pDC->GetTextExtent("AAAA",4);

// We Print 40 Wide in a Fixed Pitch Font!
m_nCurrentPrintRectWidth=Size.cx*10;

m_nCurrentLineHeight=Size.cy;

// We know the size of the Print Rectangle, so, we can
// Calculate the number of Lines per Page.

int PageHeight=pInfo->m_rectDraw.Height();
m_nLinesPerPage=PageHeight/m_nCurrentLineHeight;

// Next, we calculate the Number of Pages required, taking
// into Consideration, that Each Page accomodates the Header 
// Page, and a One Line Footer: Page %i of %i.
// We Modify m_pPageList, so that Each Entry, Except the First
// (Header) entry, represents a Printable Page!

// We try to fit as many orders as possible on a single print page.
// we Need to do a Lorry Loading Calculation.

m_pView->CondensePages(m_nLinesPerPage);

}

/////////////////////////////////////////////////////////////////
//
// This is where we print, First the Header, and thereafter the Page Content

void CConfirmOrdersStep1Dlg::PrintPage(CDC * pDC, CPrintInfo * pInfo)
{
int PageNumber=pInfo->m_nCurPage;
m_nCurrentPrintRectTop=0;

COrderPageView* pView=(COrderPageView*)m_pView->GetDataFromIndex(0);
PrintDocFragment(pView,pDC);
COrderPageView* pOrder=(COrderPageView*)m_pView->GetDataFromIndex(PageNumber);
PrintDocFragment(pOrder,pDC);

}

void CConfirmOrdersStep1Dlg::OnEndPrinting(CDC * pDC, CPrintInfo * pInfo)
{

// Do as Little as Possibe Here
// We have to de-select the CFont object, and delete it.

}

// We Create a List of Set of lists of 40 char wide strings
// The First Item in this List is the Header, specifying the
// Customer Details
// The remaining items contain Order Details for the Same Customer
// This Part Works, As is shown by 'DumpToTextFile()'

bool CConfirmOrdersStep1Dlg::CreateViewForPrinting()
{
delete m_pView;
m_pView=new COrderPageList();
int i;
int ItemCount=0;
for(i=0;i<m_clist.getcount();i++){
if(m_clist.getcheck(i)="=1)ItemCount++;
" }
="" if(itemcount="=0)return" false;
="" tag_str_customer*="" pcust="m_pNode-">pCustomer;
COrderPageView* pPageHeader=new COrderPageView(NULL,40);
pPageHeader->m_pCustomer=m_pNode->pCustomer;
pPageHeader->PrintPageHeader();
m_pView->AddReference(pPageHeader);
for(i=0;i<m_clist.getcount();i++){
if(m_clist.getcheck(i)!="1)continue;
" int="" index="((int)m_cList.GetItemData(i))-BIAS;
" lpstr_order="" po="(LPSTR_ORDER)m_pOrderList-">GetDataFromIndex(Index);
COrderPageView* pPageView=new COrderPageView(pO,40);
pPageView->PrintOrderBody();
m_pView->AddReference(pPageView);
}

ifdef _DEBUG

m_pView->DumpToTextFile();

endif

return true;

}

///////////////////////////////////////////////////////////////////////////////
//
// THIS IS WHERE THE RUBBER MEETS THE ROAD!
//
// We Are Committing a Set of Lines of Text in an Incrementing
// List of adjusting Rectangles.

int CConfirmOrdersStep1Dlg::PrintDocFragment(COrderPageView * pView, CDC * pDC)
{
ASSERT(pView);
ASSERT(pDC);
int i;
for(i=0;i<pview->GetItemCount();i++){
RECT DrawingRect;
DrawingRect.left=0;
DrawingRect.top=m_nCurrentPrintRectTop;
m_nCurrentPrintRectTop+=m_nCurrentLineHeight;
DrawingRect.right=m_nCurrentPrintRectWidth;
DrawingRect.bottom=m_nCurrentPrintRectTop-1;

LPCSTR DrawingText=(LPCSTR)pView->GetDataFromIndex(i);
pDC->DrawText(DrawingText,-1,&DrawingRect,DT_LEFT);

}
return i;
}
Getting Desparate at this stage. I Guess I am doing something trivial wrong.

Thanks + Regards,

Smile | :)

Bram van Kampen

C / C++ / MFC

ifdef _DEBUG

endif