Logo Search packages:      
Sourcecode: xbase-clients version File versions  Download package

xvidtune.c

/* $XFree86: xc/programs/xvidtune/xvidtune.c,v 3.35tsi Exp $ */

/*

Copyright (c) 1995  Kaleb S. KEITHLEY

Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES 
OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of Kaleb S. KEITHLEY 
shall not be used in advertising or otherwise to promote the sale, use 
or other dealings in this Software without prior written authorization
from Kaleb S. KEITHLEY.

*/

#include <X11/Intrinsic.h>
#include <X11/Shell.h>
#include <X11/StringDefs.h>
#include <X11/Xatom.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Scrollbar.h>
#include <X11/Xaw/Label.h>
#include <X11/Xaw/Command.h>
#include <X11/Xaw/AsciiText.h>
#include <X11/Xaw/Box.h>
#include <X11/Xaw/Toggle.h>
#include <X11/Xmu/StdSel.h>
#include <X11/Xmd.h>
#include <X11/extensions/xf86vmode.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

int MajorVersion, MinorVersion;
int EventBase, ErrorBase;
int dot_clock, mode_flags;
unsigned long    TestTimeout=5000;  /* Default test timeout */
XtSignalId sigId;

/* Minimum extension version required */
#define MINMAJOR 0
#define MINMINOR 5

/* Mode flags -- ignore flags not in V_FLAG_MASK */
#define V_FLAG_MASK     0x1FF;
#define V_PHSYNC  0x001 
#define V_NHSYNC  0x002
#define V_PVSYNC  0x004
#define V_NVSYNC  0x008
#define V_INTERLACE     0x010 
#define V_DBLSCAN 0x020
#define V_CSYNC         0x040
#define V_PCSYNC  0x080
#define V_NCSYNC  0x100

typedef enum { HDisplay, HSyncStart, HSyncEnd, HTotal,
      VDisplay, VSyncStart, VSyncEnd, VTotal, Flags, 
      InvertVclk, BlankDelay1, BlankDelay2, EarlySc,
      PixelClock, HSyncRate, VSyncRate, fields_num } fields;

typedef struct {
    fields  me;
    fields  use;
    int           val;
    int           lastpercent;
    int           range;
    Widget  textwidget;
    Widget  scrollwidget;
} ScrollData;

static struct _AppResources {
    ScrollData    field[fields_num];
    Bool    ad_installed;
    int           orig[fields_num];
    int           old[fields_num];
} AppRes = {
    {
      { HDisplay, },
      { HSyncStart, HDisplay, },
      { HSyncEnd, HDisplay, },
      { HTotal, HDisplay, },
      { VDisplay, },
      { VSyncStart, VDisplay, },
      { VSyncEnd, VDisplay, },
      { VTotal, VDisplay, },
      { Flags, },
      { InvertVclk, },
      { BlankDelay1, },
      { BlankDelay2, },
      { EarlySc, },
      { PixelClock, },
      { HSyncRate, },
      { VSyncRate, },
    },
};

static XtResource Resources[] = {
    { "adInstalled", "AdInstalled", XtRBool, sizeof(Bool),
      XtOffsetOf(struct _AppResources, ad_installed),
      XtRImmediate, (XtPointer)FALSE },
    { "hSyncStartRange", "SyncStartRange", XtRInt, sizeof(int),
      XtOffsetOf(struct _AppResources, field[HSyncStart].range), 
      XtRImmediate, (XtPointer)200 },
    { "hSyncEndRange", "SyncEndRange", XtRInt, sizeof(int),
      XtOffsetOf(struct _AppResources, field[HSyncEnd].range), 
      XtRImmediate, (XtPointer)400 },
    { "hTotalRange", "TotalRange", XtRInt, sizeof(int),
      XtOffsetOf(struct _AppResources, field[HTotal].range), 
      XtRImmediate, (XtPointer)400 },
    { "vSyncStartRange", "SyncStartRange", XtRInt, sizeof(int),
      XtOffsetOf(struct _AppResources, field[VSyncStart].range), 
      XtRImmediate, (XtPointer)20 },
    { "vSyncEndRange", "SyncEndRange", XtRInt, sizeof(int),
      XtOffsetOf(struct _AppResources, field[VSyncEnd].range), 
      XtRImmediate, (XtPointer)40 },
    { "vTotalRange", "TotalRange", XtRInt, sizeof(int),
      XtOffsetOf(struct _AppResources, field[VTotal].range), 
      XtRImmediate, (XtPointer)80 },
};

static XtTranslations trans;

static Atom wm_delete_window;
static Widget invalid_mode_popup;
static Widget testing_popup;
static Widget Top;
static Widget auto_apply_toggle;

static Bool S3Specials = False;
static char modebuf[160];

static void UpdateSyncRates(Bool dolabels);

static void
CleanUp(Display *dpy)
{
    /* Make sure mode switching is not locked out at exit */
    XF86VidModeLockModeSwitch(dpy, DefaultScreen(dpy), FALSE);
    XFlush(dpy);
}

static void
CatchSig(int signal)
{
    XtNoticeSignal(sigId);
}

static void
CatchXtSig(XtPointer closure, XtSignalId *id)
{
    CleanUp(XtDisplay(Top));
    exit(3);
}

static Bool
GetModeLine (Display* dpy, int scrn)
{
    XF86VidModeModeLine mode_line;
    fields i;

    if (!XF86VidModeGetModeLine (dpy, scrn, &dot_clock, &mode_line))
      return FALSE;

    AppRes.field[HDisplay].val = mode_line.hdisplay;
    AppRes.field[HSyncStart].val = mode_line.hsyncstart;
    AppRes.field[HSyncEnd].val = mode_line.hsyncend;
    AppRes.field[HTotal].val = mode_line.htotal;
    AppRes.field[VDisplay].val = mode_line.vdisplay;
    AppRes.field[VSyncStart].val = mode_line.vsyncstart;
    AppRes.field[VSyncEnd].val = mode_line.vsyncend;
    AppRes.field[VTotal].val = mode_line.vtotal;
    mode_flags = mode_line.flags;
    AppRes.field[Flags].val = mode_flags & V_FLAG_MASK;
    AppRes.field[PixelClock].val = dot_clock;
    UpdateSyncRates(FALSE);
    if (mode_line.privsize && mode_line.private) {
      S3Specials = True;
      AppRes.field[InvertVclk].val = mode_line.private[1];
      AppRes.field[BlankDelay1].val = mode_line.private[2] & 7;
      AppRes.field[BlankDelay2].val = (mode_line.private[2] >> 4) & 7;
      AppRes.field[EarlySc].val = mode_line.private[3];
    }

    for (i = HDisplay; i < fields_num; i++) 
      AppRes.orig[i] = AppRes.field[i].val;
    return TRUE;
}

static Bool
GetMonitor (Display* dpy, int scrn)
{
    XF86VidModeMonitor monitor;
    int i;

    if (!XF86VidModeGetMonitor (dpy, scrn, &monitor))
      return FALSE;

    printf("Vendor: %s, Model: %s\n", monitor.vendor, monitor.model);
    printf("Num hsync: %d, Num vsync: %d\n", monitor.nhsync, monitor.nvsync);
    for (i = 0; i < monitor.nhsync; i++) {
      printf("hsync range %d: %6.2f - %6.2f\n", i, monitor.hsync[i].lo,
             monitor.hsync[i].hi);
    }
    for (i = 0; i < monitor.nvsync; i++) {
      printf("vsync range %d: %6.2f - %6.2f\n", i, monitor.vsync[i].lo,
             monitor.vsync[i].hi);
    }
    return TRUE;
}

static Bool
ModeSettable(void)
{
    if (AppRes.field[HTotal].val == 0 || AppRes.field[VTotal].val == 0)
      return FALSE;
    return TRUE;
}

static int hitError = 0;
static int (*xtErrorfunc)(Display *, XErrorEvent *);

static int
vidmodeError(Display *dis, XErrorEvent *err)
{
  if ((err->error_code >= ErrorBase &&
      err->error_code < ErrorBase + XF86VidModeNumberErrors) ||
      err->error_code == BadValue) {
     hitError=1;
  } else {
     CleanUp(dis);
     if (xtErrorfunc) 
      (*xtErrorfunc)(dis, err);
  }
  return 0; /* ignored */
}

static void
SetScrollbars (void)
{
    fields i;

    for (i = HDisplay; i <= Flags; i++) {

      ScrollData* sdp = &AppRes.field[i];

      if (sdp->scrollwidget != (Widget) NULL) {
          int base;
          float percent;

          base = AppRes.field[sdp->use].val;
          percent = ((float)(sdp->val - base)) / ((float)sdp->range);
          XawScrollbarSetThumb (sdp->scrollwidget, percent, 0.0);
      }
    }
}

static void
QuitCB (Widget w, XtPointer client, XtPointer call)
{
    CleanUp(XtDisplay(w));
#if XtSpecificationRelease < 6
    exit (0);
#else
    XtAppSetExitFlag (XtWidgetToApplicationContext (w));
#endif
}

static void
popdownInvalid(Widget w, XtPointer client, XtPointer call)
{
   XtPopdown((Widget)client);
}

static void
ApplyCB (Widget w, XtPointer client, XtPointer call)
{
    XF86VidModeModeLine mode_line;
    INT32 S3private[4];
    unsigned int i;
    char* string;
    Boolean state;

    mode_line.hdisplay = AppRes.field[HDisplay].val;
    mode_line.hsyncstart = AppRes.field[HSyncStart].val;
    mode_line.hsyncend = AppRes.field[HSyncEnd].val;
    mode_line.htotal = AppRes.field[HTotal].val;
    mode_line.vdisplay = AppRes.field[VDisplay].val;
    mode_line.vsyncstart = AppRes.field[VSyncStart].val;
    mode_line.vsyncend = AppRes.field[VSyncEnd].val;
    mode_line.vtotal = AppRes.field[VTotal].val;
    /* Don't read flags from widget */
#if 0
    XtVaGetValues (AppRes.field[Flags].textwidget,
            XtNstring, &string, NULL);
    (void) sscanf (string, "%x", &i);
#endif
    mode_line.flags = mode_flags;
    if (S3Specials) {
      mode_line.privsize = 4;
      mode_line.private = S3private;
      mode_line.private[0] = (1 << 1) | (1 << 2) | (1 << 3);
      XtVaGetValues(AppRes.field[InvertVclk].textwidget,
                  XtNstate, &state, NULL);
      AppRes.field[InvertVclk].val = state ? 1 : 0;
      mode_line.private[1] = AppRes.field[InvertVclk].val;
      XtVaGetValues (AppRes.field[BlankDelay1].textwidget,
                  XtNstring, &string, NULL);
      (void) sscanf (string, "%x", &i);
      AppRes.field[BlankDelay1].val = i;
      mode_line.private[2] = AppRes.field[BlankDelay1].val;
      XtVaGetValues (AppRes.field[BlankDelay2].textwidget,
                  XtNstring, &string, NULL);
      (void) sscanf (string, "%x", &i);
      AppRes.field[BlankDelay2].val = i;
      mode_line.private[2] |= AppRes.field[BlankDelay2].val << 4;
      XtVaGetValues(AppRes.field[EarlySc].textwidget,
                  XtNstate, &state, NULL);
      AppRes.field[EarlySc].val = state ? 1 : 0;
      mode_line.private[3] = AppRes.field[EarlySc].val;
    } else
      mode_line.privsize = 0;
    
   hitError = 0;

   XF86VidModeModModeLine (XtDisplay (w), DefaultScreen (XtDisplay (w)), 
            &mode_line);
   XSync(XtDisplay (w), False); /* process errors  */
   if (hitError) {
       XBell(XtDisplay (w), 80);
       XtPopup(invalid_mode_popup, XtGrabExclusive /*XtGrabNone*/);
   }
}


static void
SetLabel(fields i)
{
   ScrollData* sdp = &AppRes.field[i];

   if (sdp->textwidget != (Widget) NULL) {
      char buf[10];
      Boolean state;

      /*
       * Disable AutoApply so that the apply doesn't happen more than
       * once as a consequence of callbacks being called because of the
       * XtSetValues calls
       */

      XtVaGetValues(auto_apply_toggle, XtNstate, &state, NULL);
      if (state)
       XtVaSetValues(auto_apply_toggle, XtNstate, 0, NULL);

      if (i == Flags)
       (void) sprintf (buf, "%04x", sdp->val);
      else if (i >= PixelClock && i <= VSyncRate)
       (void) sprintf (buf, "%6.2f", (float)sdp->val / 1000.0);
      else if (i == BlankDelay1 || i == BlankDelay2) {
       (void) sprintf (buf, "%d", sdp->val);
      } else
       (void) sprintf (buf, "%5d", sdp->val);
       
      sdp->lastpercent = -1;
      if (i == Flags) {
       XawTextBlock text;

       text.firstPos = 0;
       text.length = 4;
       text.ptr = buf;
       text.format = XawFmt8Bit;
       XawTextReplace (sdp->textwidget, 0, 4, &text);
      } else if (i == BlankDelay1 || i == BlankDelay2) {
       XawTextBlock text;

       text.firstPos = 0;
       text.length = 1;
       text.ptr = buf;
       XawTextReplace (sdp->textwidget, 0, 1, &text);
      } else if (i == InvertVclk || i == EarlySc) {
      XtVaSetValues (sdp->textwidget, XtNstate, sdp->val, NULL);
      } else
      XtVaSetValues (sdp->textwidget, XtNlabel, buf, NULL);

      if (state)
       XtVaSetValues(auto_apply_toggle, XtNstate, 1, NULL);
   }

}

static void
UpdateSyncRates(Bool dolabels)
{
    if (!ModeSettable())
      return;
    
    AppRes.field[HSyncRate].val = AppRes.field[PixelClock].val * 1000 /
                          AppRes.field[HTotal].val;
    AppRes.field[VSyncRate].val = AppRes.field[HSyncRate].val * 1000 /
                          AppRes.field[VTotal].val;
    if (mode_flags & V_INTERLACE)
      AppRes.field[VSyncRate].val *= 2;
    else if (mode_flags & V_DBLSCAN)
      AppRes.field[VSyncRate].val /= 2;
    if (dolabels) {
      SetLabel(HSyncRate);
      SetLabel(VSyncRate);
    }
}

static void
RestoreCB (Widget w, XtPointer client, XtPointer call)
{
    fields i;
    Boolean state;

    for (i = HDisplay; i < fields_num; i++) {
      AppRes.field[i].val = AppRes.orig[i];
      SetLabel(i);
    }
    SetScrollbars ();
    XtVaGetValues(auto_apply_toggle, XtNstate, &state, NULL);
    if (state)
       ApplyCB (w, client, call);
}


static void
ApplyIfAutoCB (Widget w, XtPointer client, XtPointer call)
{
   Boolean state;

   XtVaGetValues(auto_apply_toggle, XtNstate, &state, NULL);
   if (state)
       ApplyCB (w, client, call);
}


static void
FetchCB (Widget w, XtPointer client, XtPointer call)
{
    fields i;
    (void) GetModeLine(XtDisplay (w), DefaultScreen (XtDisplay (w)));
    SetScrollbars ();
    for (i = HDisplay; i < fields_num; i++) {
        SetLabel(i);
    }   
}

static XtIntervalId TOid;

static void
TestTO (XtPointer client, XtIntervalId* id)
{
    fields i;
    for (i = HDisplay; i < fields_num; i++)
      AppRes.field[i].val = AppRes.orig[i];

    ApplyCB ((Widget) client, NULL, NULL);

    for (i = HDisplay; i < fields_num; i++)
      AppRes.field[i].val = AppRes.old[i];
    SetScrollbars ();

    XtPopdown(testing_popup);
}

static void
TestTOCB (Widget w, XtPointer client, XtPointer call)
{
  XtRemoveTimeOut(TOid);
  TestTO(w, (XtIntervalId *) NULL);
}

static void
TestCB (Widget w, XtPointer client, XtPointer call)
{
    fields i;
    for (i = HDisplay; i < fields_num; i++)
      AppRes.old[i] = AppRes.field[i].val;

    XtPopup(testing_popup, XtGrabExclusive /*XtGrabNone*/);
    XSync(XtDisplay(w), False);   
    TOid = XtAppAddTimeOut (XtWidgetToApplicationContext (w),
            TestTimeout, TestTO, (XtPointer) w);

    ApplyCB (w, client, call);
}

static Boolean
ConvertSelection(
    Widget w,
    Atom *selection, Atom *target, Atom *type,
    XtPointer *value,
    unsigned long *length,
    int *format)
{
    if (XmuConvertStandardSelection(w, CurrentTime, selection, target, type,
                                    (XPointer *) value, length, format))
        return True;

    if (*target == XA_STRING) {
        *type = XA_STRING;
        *value = modebuf;
        *length = strlen(*value);
        *format = 8;
        return True;
    }
    return False;
}

static void
ShowCB(Widget w, XtPointer client, XtPointer call)
{
    Time time;
    char tmpbuf[16];

    sprintf(tmpbuf, "\"%dx%d\"",
         AppRes.field[HDisplay].val, AppRes.field[VDisplay].val);
    sprintf(modebuf, "%-11s   %6.2f   %4d %4d %4d %4d   %4d %4d %4d %4d",
         tmpbuf, (float)dot_clock/1000.0,
         AppRes.field[HDisplay].val,
         AppRes.field[HSyncStart].val,
         AppRes.field[HSyncEnd].val,
         AppRes.field[HTotal].val,
         AppRes.field[VDisplay].val,
         AppRes.field[VSyncStart].val,
         AppRes.field[VSyncEnd].val,
         AppRes.field[VTotal].val);
    /* Print out the flags (if any) */
    if (mode_flags & V_PHSYNC)    strcat(modebuf, " +hsync");
    if (mode_flags & V_NHSYNC)    strcat(modebuf, " -hsync");
    if (mode_flags & V_PVSYNC)    strcat(modebuf, " +vsync");
    if (mode_flags & V_NVSYNC)    strcat(modebuf, " -vsync");
    if (mode_flags & V_INTERLACE) strcat(modebuf, " interlace");
    if (mode_flags & V_CSYNC)     strcat(modebuf, " composite");
    if (mode_flags & V_PCSYNC)    strcat(modebuf, " +csync");
    if (mode_flags & V_NCSYNC)    strcat(modebuf, " -csync");
    if (mode_flags & V_DBLSCAN)   strcat(modebuf, " doublescan");
    printf("%s\n", modebuf);
    time = XtLastTimestampProcessed(XtDisplay(w));
    XtOwnSelection(w, XA_PRIMARY, time, ConvertSelection, NULL, NULL);
    if (S3Specials) {
      unsigned int i;
      Boolean state;
      char *string;

      XtVaGetValues(AppRes.field[InvertVclk].textwidget,
                  XtNstate, &state, NULL);
      AppRes.field[InvertVclk].val = state ? 1 : 0;
      XtVaGetValues (AppRes.field[BlankDelay1].textwidget,
                  XtNstring, &string, NULL);
      (void) sscanf (string, "%x", &i);
      AppRes.field[BlankDelay1].val = i;
      XtVaGetValues (AppRes.field[BlankDelay2].textwidget,
                  XtNstring, &string, NULL);
      (void) sscanf (string, "%x", &i);
      AppRes.field[BlankDelay2].val = i;
      XtVaGetValues(AppRes.field[EarlySc].textwidget,
                  XtNstate, &state, NULL);
      AppRes.field[EarlySc].val = state ? 1 : 0;
      if (AppRes.field[InvertVclk].val != AppRes.orig[InvertVclk])
          printf("InvertVCLK\t\"%dx%d\" %d\n", AppRes.field[HDisplay].val,
            AppRes.field[VDisplay].val, AppRes.field[InvertVclk].val);
      if (AppRes.field[EarlySc].val != AppRes.orig[EarlySc])
          printf("EarlySC\t\t\"%dx%d\" %d\n", AppRes.field[HDisplay].val,
            AppRes.field[VDisplay].val, AppRes.field[EarlySc].val);
      if (AppRes.field[BlankDelay1].val != AppRes.orig[BlankDelay1]
          || AppRes.field[BlankDelay2].val != AppRes.orig[BlankDelay2])
          printf("BlankDelay\t\"%dx%d\" %d %d\n", AppRes.field[HDisplay].val,
            AppRes.field[VDisplay].val, AppRes.field[BlankDelay1].val,
            AppRes.field[BlankDelay2].val);
    }
    printf("\n");
}

static void
AdjustCB(Widget w, XtPointer client, XtPointer call)
{
   int what = (long) client;
   Boolean state;
   
   switch (what) {
    case HSyncStart:
      if (AppRes.field[HSyncEnd].val + 4 < AppRes.field[HTotal].val) {
       AppRes.field[HSyncEnd].val += 4;
       AppRes.field[HSyncStart].val += 4;
       SetLabel(HSyncStart);   
       SetLabel(HSyncEnd);           
      } else
      XBell(XtDisplay(w), 80);
      break;
    case -HSyncStart:
      if (AppRes.field[HSyncStart].val - 4 > AppRes.field[HDisplay].val) {
       AppRes.field[HSyncEnd].val -= 4;
       AppRes.field[HSyncStart].val -= 4;
       SetLabel(HSyncStart);   
       SetLabel(HSyncEnd);                 
      } else
      XBell(XtDisplay(w), 80);
      break;
    case HTotal:
      AppRes.field[HTotal].val += 4;
      SetLabel(HTotal);        
      UpdateSyncRates(TRUE);
      break;      
    case -HTotal:
      if (AppRes.field[HTotal].val - 4 >  AppRes.field[HSyncEnd].val) {  
      AppRes.field[HTotal].val -= 4;
      SetLabel(HTotal);  
      UpdateSyncRates(TRUE);
      } else
      XBell(XtDisplay(w), 80);
      break;
    case VSyncStart:
      if (AppRes.field[VSyncEnd].val + 4 < AppRes.field[VTotal].val) {
       AppRes.field[VSyncEnd].val += 4;
       AppRes.field[VSyncStart].val += 4;
       SetLabel(VSyncStart);   
       SetLabel(VSyncEnd);     
      } else
      XBell(XtDisplay(w), 80);
      break;
    case -VSyncStart:
      if (AppRes.field[VSyncStart].val - 4 > AppRes.field[VDisplay].val) {
       AppRes.field[VSyncEnd].val -= 4;
       AppRes.field[VSyncStart].val -= 4;
       SetLabel(VSyncStart);   
       SetLabel(VSyncEnd);           
      } else
      XBell(XtDisplay(w), 80);
      break;
    case VTotal:
      AppRes.field[VTotal].val += 4;
      SetLabel(VTotal);      
      UpdateSyncRates(TRUE);
      break;      
    case -VTotal:
      if (AppRes.field[VTotal].val - 4 >  AppRes.field[VSyncEnd].val) {  
      AppRes.field[VTotal].val -= 4;
      SetLabel(VTotal);
      UpdateSyncRates(TRUE);
      } else
      XBell(XtDisplay(w), 80);
      break;
   }  
   SetScrollbars ();
   XtVaGetValues(auto_apply_toggle, XtNstate, &state, NULL);
   if (state)
       ApplyCB (w, client, call);
}


#if 0
static void
EditCB (Widget w, XtPointer client, XtPointer call)
{
    int base, current, i, len;
    int lower, upper;
    float percent;
    ScrollData* sdp = (ScrollData*) client;

    len = strlen (sdp->string);

    for (i = 0; i < len; i++) {
      if (!(isdigit (sdp->string[i]) || isspace (sdp->string[i]))) {
          XBell (XtDisplay(XtParent(w)), 100);
          return;
      }
    }
    switch (sdp->me) {
    case HSyncStart: 
      lower = atoi (AppRes.field[HDisplay].string);
      upper = atoi (AppRes.field[HSyncEnd].string);
      break;

    case HSyncEnd:
      lower = atoi (AppRes.field[HSyncStart].string);
      upper = atoi (AppRes.field[HTotal].string);
      break;

    case HTotal:
      lower = atoi (AppRes.field[HSyncEnd].string);
      upper = atoi (AppRes.field[HDisplay].string) + 
            AppRes.field[HTotal].range;
      break;

    case VSyncStart: 
      lower = atoi (AppRes.field[VDisplay].string);
      upper = atoi (AppRes.field[VSyncEnd].string);
      break;

    case VSyncEnd:
      lower = atoi (AppRes.field[VSyncStart].string);
      upper = atoi (AppRes.field[VTotal].string);
      break;

    case VTotal:
      lower = atoi (AppRes.field[VSyncEnd].string);
      upper = atoi (AppRes.field[VDisplay].string) + 
            AppRes.field[VTotal].range;
      break;
    }
    current = atoi (sdp->string);
    if (current < lower || current > upper) {
      XawTextBlock text;
      char tmp[6];

      if (current < lower) {
          (void) sprintf (tmp, "%5d", lower);
          current = lower;
      } else {
          (void) sprintf (tmp, "%5d", upper);
          current = upper;
      }
      text.firstPos = 0;
      text.length = strlen (tmp);
      text.ptr = tmp;
      text.format = XawFmt8Bit;
      XawTextReplace (sdp->textwidget, 0, text.length, &text);
    }
    base = atoi (AppRes.field[sdp->use].string);
    percent = ((float)(current - base)) / ((float)sdp->range);
    XawScrollbarSetThumb (sdp->scrollwidget, percent, 0.0);
}
#endif

static void
FlagsEditCB (Widget w, XtPointer client, XtPointer call)
{
    int i, len;
    char* string;
    fields findex = (fields) (unsigned long) client;
    ScrollData* sdp = &AppRes.field[findex];

    XtVaGetValues (w, XtNstring, &string, NULL);
    len = strlen (string);
    if (len > 4) {
      char buf[5];

      XBell (XtDisplay(XtParent(w)), 100);
      (void) strncpy (buf, string, 4);
      buf[4] = '\0';
      XtVaSetValues (sdp->textwidget, XtNstring, buf, NULL);
      XawTextSetInsertionPoint (sdp->textwidget, 4);
    }

    for (i = 0; i < len; i++) {
      if (!isxdigit (string[i])) {
          XBell (XtDisplay(XtParent(w)), 100);
      }
    }
}

static void
BlankEditCB (Widget w, XtPointer client, XtPointer call)
{
    int len;
    char* string;
    fields findex = (fields) (unsigned long) client;
    ScrollData* sdp = &AppRes.field[findex];
    char buf[2], old;
    Boolean state;
    Boolean noAuto = False;

    XtVaGetValues (w, XtNstring, &string, NULL);
    len = strlen (string);
    if (len == 0) {
      XBell (XtDisplay(XtParent(w)), 100);
      strcpy(buf, "0");
      XtVaSetValues (sdp->textwidget, XtNstring, buf, NULL);
      XawTextSetInsertionPoint (sdp->textwidget, 1);
        return;
    }
    if (len > 1) {
      if (XawTextGetInsertionPoint(sdp->textwidget) < 1) {
          buf[0] = string[0];
          old = string[1];
      } else {
          buf[0] = string[1];
          old = string[0];
      }
      if (buf[0] == '+' && old < '7')
          buf[0] = old + 1;
      else if (buf[0] == '-' && old > '0')
          buf[0] = old - 1;
      if (!isdigit(buf[0]) || buf[0] > '7') {
          XBell (XtDisplay(XtParent(w)), 100);
          buf[0] = old;
          if (!isdigit(buf[0]) || buf[0] > '7')
            buf[0] = '0';
          noAuto = True;
      }
      buf[1] = '\0';
      XtVaSetValues (sdp->textwidget, XtNstring, buf, NULL);
      XawTextSetInsertionPoint (sdp->textwidget, 1);
    }
    XtVaGetValues(auto_apply_toggle, XtNstate, &state, NULL);
    if (state && !noAuto)
      ApplyCB (sdp->textwidget, client, call);
}

static void
ChangeBlankCB (Widget w, XtPointer client, XtPointer call)
{
    char* string;
    char buf[2];
    fields findex;
    ScrollData* sdp;
    Boolean state;
    int what = (long) client;


    if (what < 0)
      findex = (fields)-what;
    else
      findex = (fields)what;
    sdp = &AppRes.field[findex];

    XtVaGetValues (sdp->textwidget, XtNstring, &string, NULL);
    if (what > 0)
      string[0]++;
    else
      string[0]--;

    if (string[0] < '0' || string[0] > '7') {
      XBell (XtDisplay(XtParent(w)), 100);
      return;
    }

    buf[0] = string[0];
    buf[1] = '\0';
    XtVaSetValues (sdp->textwidget, XtNstring, buf, NULL);
    XawTextSetInsertionPoint (sdp->textwidget, 1);

    XtVaGetValues(auto_apply_toggle, XtNstate, &state, NULL);
    if (state)
      ApplyCB (sdp->textwidget, client, call);
}

static int
isValid(int val, int field)
{
   switch(field) {
     case HSyncStart:
      if (val+8 > AppRes.field[HSyncEnd].val)
         val = AppRes.field[HSyncEnd].val - 8;
        break;
     case HSyncEnd:
        if (val-8 < AppRes.field[HSyncStart].val)
          val = AppRes.field[HSyncStart].val + 8;
        if (val > AppRes.field[HTotal].val)
          val = AppRes.field[HTotal].val;
        break;
     case HTotal:
      if (val < AppRes.field[HSyncEnd].val)
         val = AppRes.field[HSyncEnd].val;
         break;
     case VSyncStart:
      if (val+8 > AppRes.field[VSyncEnd].val)
         val = AppRes.field[VSyncEnd].val - 8;
        break;
     case VSyncEnd:
        if (val-8 < AppRes.field[VSyncStart].val)
          val = AppRes.field[VSyncStart].val + 8;
        if (val > AppRes.field[VTotal].val)
          val = AppRes.field[VTotal].val;
        break;
     case VTotal:
      if (val < AppRes.field[VSyncEnd].val)
         val = AppRes.field[VSyncEnd].val;
        break;
   }
   return val;
}

static void
ScrollCB (Widget w, XtPointer client, XtPointer call)
{
    float percent = *(float*) call;
    int ipercent = percent * 100;
    int fieldindex = (long) client;
    ScrollData* sdp = &AppRes.field[fieldindex];


    
    if (ipercent != sdp->lastpercent) {
        int tmp_val;
      char buf[6];

      tmp_val = AppRes.field[sdp->use].val;
      tmp_val += (int) (((float)sdp->range) * percent);

        sdp->val = isValid(tmp_val, fieldindex);
        
      sdp->lastpercent = ipercent;
      (void) sprintf (buf, "%5d", sdp->val);
      XtVaSetValues (sdp->textwidget, XtNlabel, buf, NULL);
        if (sdp->val != tmp_val) {
            int base;
            float percent;

            base = AppRes.field[sdp->use].val;
            percent = ((float)(sdp->val - base)) / ((float)sdp->range);
            /* This doesn't always work, why? */
            XawScrollbarSetThumb (sdp->scrollwidget, percent, 0.0);
      }
      if (fieldindex == HTotal || fieldindex == VTotal)
          UpdateSyncRates(TRUE);
    }
}

static void
SwitchCB (Widget w, XtPointer client, XtPointer call)
{
    XF86VidModeLockModeSwitch(XtDisplay(w), DefaultScreen (XtDisplay (w)),
                        FALSE);
    XF86VidModeSwitchMode(XtDisplay(w), DefaultScreen (XtDisplay (w)),
                    (int)(long) client);
    XF86VidModeLockModeSwitch(XtDisplay(w), DefaultScreen (XtDisplay (w)),
                        TRUE);
    FetchCB(w, NULL, NULL);
}

static void
AddCallback (
    Widget w,
    String  callback_name,
    XtCallbackProc callback,
    XtPointer client_data)
{
    Widget src;

    XtVaGetValues (w, XtNtextSource, &src, NULL);
    XtAddCallback (src, callback_name, callback, client_data);
}

static void
CreateTyp (
    Widget form,
    fields findex,
    String w1name,
    String w2name,
    String w3name)
{
    Widget wids[3];
    char buf[10];

    wids[0] = XtCreateWidget (w1name, labelWidgetClass, form, NULL, 0);
    if (findex >= PixelClock && findex <= VSyncRate)
      (void) sprintf(buf, "%6.2f", (float)AppRes.field[findex].val / 1000.0);
    else
      (void) sprintf (buf, "%5d", AppRes.field[findex].val);
    wids[1] = XtVaCreateWidget (w2name, labelWidgetClass,
            form, XtNlabel, buf, NULL);
    if (w3name != NULL) {
      wids[2] = XtCreateWidget (w3name, scrollbarWidgetClass, form, NULL, 0);
      XtAddCallback (wids[2], XtNjumpProc, ScrollCB, (XtPointer) findex);
      XtManageChildren (wids, 3);
    } else {
      wids[2] = (Widget) NULL;
      XtManageChildren (wids, 2);
    }
    AppRes.field[findex].textwidget = wids[1];
    AppRes.field[findex].scrollwidget = wids[2];
}


static void
AckWarn (Widget w, XtPointer client, XtPointer call)
{
    XtPopdown((Widget) client);
    XtDestroyWidget((Widget) client);
}

static void
AckNoTune (Widget w, XtPointer client, XtPointer call)
{
    CleanUp(XtDisplay(w));
#if XtSpecificationRelease < 6
    exit (0);
#else
    XtAppSetExitFlag (XtWidgetToApplicationContext (w));
#endif
}

static void
displayWarning(Widget top)
{
    Widget w, popup, popupBox;
    int x, y;

    x =  DisplayWidth(XtDisplay (top),DefaultScreen (XtDisplay (top))) / 3;
    y =  DisplayHeight(XtDisplay (top),DefaultScreen (XtDisplay (top))) / 3;

    popup = XtVaCreatePopupShell("Warning", 
                      transientShellWidgetClass, top,
                      XtNtitle, "WARNING",
                      XtNx, x,
                      XtNy, y,
                      NULL);

    popupBox = XtVaCreateManagedWidget(
               "WarningBox",
               boxWidgetClass,
               popup,
               NULL);

    w = XtVaCreateManagedWidget( "WarnLabel",
                                     labelWidgetClass,
                             popupBox,
                                     NULL);

    w = XtVaCreateManagedWidget( "WarnOK",
                                     commandWidgetClass,
                             popupBox,
                                     NULL);

    XtAddCallback (w, XtNcallback, AckWarn, (XtPointer)popup);

    w = XtVaCreateManagedWidget( "WarnCancel",
                                     commandWidgetClass,
                             popupBox,
                                     NULL);
    XtAddCallback (w, XtNcallback, QuitCB, (XtPointer)NULL);

    XtPopup(popup, XtGrabExclusive);
    
}

static void
displayNoTune(Widget top)
{
    Widget w, popup, popupBox;

    popup = XtCreateWidget ("Notice", formWidgetClass, top, NULL, 0);
    popupBox = XtVaCreateManagedWidget(
               "WarningBox",
               boxWidgetClass,
               popup,
               NULL);

    w = XtVaCreateManagedWidget( "NoTuneLabel",
                                     labelWidgetClass,
                             popupBox,
                                     NULL);

    w = XtVaCreateManagedWidget( "NoTuneOK",
                                     commandWidgetClass,
                             popupBox,
                                     NULL);

    XtAddCallback (w, XtNcallback, AckNoTune, (XtPointer)popup);

    XtManageChild (popup);
}

#if 0
static void
s3Special(Widget top)
{
    Widget w, popup, form, invert_vclk_toggle, wids[6];
    char buf1[5] = {'\0',};
    int x, y;

    x =  DisplayWidth(XtDisplay (top),DefaultScreen (XtDisplay (top))) / 3;
    y =  DisplayHeight(XtDisplay (top),DefaultScreen (XtDisplay (top))) / 3;

    popup = XtVaCreatePopupShell("S3Adjust", 
                      transientShellWidgetClass, top,
                      XtNtitle, "S3Adjust",
                      XtNx, x,
                      XtNy, y,
                      NULL);

    form = XtVaCreateManagedWidget(
               "S3Box",
               formWidgetClass,
               popup,
               NULL);

    w = XtVaCreateManagedWidget( "S3Title",
                                     labelWidgetClass,
                             form,
                                     NULL);

    invert_vclk_toggle = XtVaCreateManagedWidget( "InvertVclk-toggle",
                                     toggleWidgetClass,
                             form,
                                     NULL);

    wids[0] = XtCreateWidget ("Blank1-label", labelWidgetClass,
            form, NULL, 0);
    wids[1] = XtVaCreateWidget ("Blank1-text", asciiTextWidgetClass,
            form, XtNstring, buf1, NULL);
    AddCallback (wids[1], XtNcallback, FlagsEditCB, (XtPointer) NULL);

    XtManageChildren (wids, 2);

    XtPopup(popup, XtGrabNone);
    
}
#endif



static void
CreateHierarchy(Widget top)
{
    char buf[5];
    Widget form, forms[14], s3form;
    Widget wids[10];
    Widget boxW, popdownW, w;   
    int i;
    int x, y;
    static String form_names[] = {
      "HDisplay-form",
      "HSyncStart-form",
      "HSyncEnd-form",
      "HTotal-form",
      "VDisplay-form",
      "VSyncStart-form",
      "VSyncEnd-form",
      "VTotal-form",
      "Flags-form",
      "Buttons-form",
      "PixelClock-form",
      "HSyncRate-form",
      "VSyncRate-form",
      "Buttons2-form",
      };

    form = XtCreateWidget ("form", formWidgetClass, top, NULL, 0);
    for (i = 0; i < 14; i++)
      forms[i] = XtCreateWidget (form_names[i], formWidgetClass, 
            form, NULL, 0);

    CreateTyp (forms[0], HDisplay, "HDisplay-label", "HDisplay-text", NULL);
    CreateTyp (forms[1], HSyncStart, "HSyncStart-label",
            "HSyncStart-text", "HSyncStart-scrollbar");
    CreateTyp (forms[2], HSyncEnd, "HSyncEnd-label", "HSyncEnd-text", 
            "HSyncEnd-scrollbar");
    CreateTyp (forms[3], HTotal, "HTotal-label", "HTotal-text", 
            "HTotal-scrollbar");

    w = XtVaCreateManagedWidget(
                                     "Left-button",
                                     commandWidgetClass,
                                     forms[3],
                                     NULL);
    XtAddCallback (w, XtNcallback, AdjustCB, (XtPointer)HSyncStart);
    w = XtVaCreateManagedWidget(
                                     "Right-button",
                                     commandWidgetClass,
                                     forms[3],
                                     NULL);
    XtAddCallback (w, XtNcallback, AdjustCB, (XtPointer)-HSyncStart);
    w=  XtVaCreateManagedWidget(
                                     "Wider-button",
                                     commandWidgetClass,
                                     forms[3],
                                     NULL);
    XtAddCallback (w, XtNcallback, AdjustCB, (XtPointer)-HTotal);
    w = XtVaCreateManagedWidget(
                                     "Narrower-button",
                                     commandWidgetClass,
                                     forms[3],
                                     NULL);
    XtAddCallback (w, XtNcallback, AdjustCB, (XtPointer)HTotal);
    CreateTyp (forms[4], VDisplay, "VDisplay-label", "VDisplay-text", NULL);
    CreateTyp (forms[5], VSyncStart, "VSyncStart-label",
            "VSyncStart-text", "VSyncStart-scrollbar");
    CreateTyp (forms[6], VSyncEnd, "VSyncEnd-label", "VSyncEnd-text", 
            "VSyncEnd-scrollbar");
    CreateTyp (forms[7], VTotal, "VTotal-label", "VTotal-text", 
            "VTotal-scrollbar");
    w = XtVaCreateManagedWidget(
                                     "Up-button",
                                     commandWidgetClass,
                                     forms[7],
                                     NULL);
    XtAddCallback (w, XtNcallback, AdjustCB, (XtPointer)VSyncStart);
    w = XtVaCreateManagedWidget(
                                     "Down-button",
                                     commandWidgetClass,
                                     forms[7],
                                     NULL);
    XtAddCallback (w, XtNcallback, AdjustCB, (XtPointer)-VSyncStart);   
    w=  XtVaCreateManagedWidget(
                                     "Shorter-button",
                                     commandWidgetClass,
                                     forms[7],
                                     NULL);
    XtAddCallback (w, XtNcallback, AdjustCB, (XtPointer)VTotal);   
    w = XtVaCreateManagedWidget(
                                     "Taller-button",
                                     commandWidgetClass,
                                     forms[7],
                                     NULL);
    XtAddCallback (w, XtNcallback, AdjustCB, (XtPointer)-VTotal);

    (void) sprintf (buf, "%04x", AppRes.field[Flags].val);
    wids[0] = XtCreateWidget ("Flags-label", labelWidgetClass,
            forms[8], NULL, 0);
    wids[1] = XtVaCreateWidget ("Flags-text", asciiTextWidgetClass,
            forms[8], XtNstring, buf, XtNtranslations, trans, NULL);
    AddCallback (wids[1], XtNcallback, FlagsEditCB, (XtPointer) Flags);
    XtManageChildren (wids, 2);
    AppRes.field[Flags].textwidget = wids[1];

    wids[0] = XtCreateWidget ("Quit-button", commandWidgetClass, 
            forms[9], NULL, 0);
    XtAddCallback (wids[0], XtNcallback, QuitCB, NULL);

    wids[1] = XtCreateWidget ("Apply-button", commandWidgetClass, 
            forms[9], NULL, 0);
    XtAddCallback (wids[1], XtNcallback, ApplyCB, NULL);

    wids[2] = XtCreateWidget ("AutoApply-toggle", toggleWidgetClass, 
            forms[9], NULL, 0);
    auto_apply_toggle = wids[2];

    wids[3] = XtCreateWidget ("Test-button", commandWidgetClass, 
            forms[9], NULL, 0);
    XtAddCallback (wids[3], XtNcallback, TestCB, NULL);

    wids[4] = XtCreateWidget ("Restore-button", commandWidgetClass, 
            forms[9], NULL, 0);
    XtAddCallback (wids[4], XtNcallback, RestoreCB, NULL);

    XtManageChildren (wids, 5);


    CreateTyp (forms[10], PixelClock, "PixelClock-label", "PixelClock-text",
             NULL);
    CreateTyp (forms[11], HSyncRate, "HSyncRate-label", "HSyncRate-text",
             NULL);
    CreateTyp (forms[12], VSyncRate, "VSyncRate-label", "VSyncRate-text",
             NULL);

    wids[0] = XtCreateWidget ("Fetch-button", commandWidgetClass, 
            forms[13], NULL, 0);
    XtAddCallback (wids[0], XtNcallback, FetchCB, NULL);

    wids[1] = XtCreateWidget ("Show-button", commandWidgetClass, 
            forms[13], NULL, 0);
    XtAddCallback (wids[1], XtNcallback, ShowCB, NULL);

    wids[2] = XtCreateWidget ("Next-button", commandWidgetClass, 
            forms[13], NULL, 0);
    XtAddCallback (wids[2], XtNcallback, SwitchCB, (XtPointer)1);

    wids[3] = XtCreateWidget ("Prev-button", commandWidgetClass, 
            forms[13], NULL, 0);
    XtAddCallback (wids[3], XtNcallback, SwitchCB, (XtPointer)-1);

    XtManageChildren (wids, 4);

    XtManageChildren (forms, 14);

    if (S3Specials) {
      char buf[2] = "0";
      s3form = XtCreateWidget ("S3-form", formWidgetClass, 
            form, NULL, 0);
      wids[0] = XtVaCreateWidget("InvertVclk-toggle", toggleWidgetClass,
                  s3form, XtNstate, AppRes.field[InvertVclk].val, NULL);
      XtAddCallback (wids[0], XtNcallback, ApplyIfAutoCB, NULL);
      AppRes.field[InvertVclk].textwidget = wids[0];
      wids[1] = XtVaCreateWidget("EarlySc-toggle", toggleWidgetClass,
                  s3form, XtNstate, AppRes.field[EarlySc].val, NULL);
      XtAddCallback (wids[1], XtNcallback, ApplyIfAutoCB, NULL);
      AppRes.field[EarlySc].textwidget = wids[1];
      wids[2] = XtCreateWidget("Blank1-label", labelWidgetClass, s3form,
                  NULL, 0);
      wids[3] = XtVaCreateWidget("Blank1Dec-button", commandWidgetClass,
                           s3form, NULL);
      XtAddCallback (wids[3], XtNcallback, ChangeBlankCB,
                  (XtPointer)-BlankDelay1);
      (void) sprintf (buf, "%d", AppRes.field[BlankDelay1].val);
      wids[4] = XtVaCreateWidget("Blank1-text", asciiTextWidgetClass,
                  s3form, XtNstring, buf, XtNtranslations, trans, NULL);
      AddCallback(wids[4], XtNcallback, BlankEditCB, (XPointer) BlankDelay1);
      AppRes.field[BlankDelay1].textwidget = wids[4];
      wids[5] = XtVaCreateWidget("Blank1Inc-button", commandWidgetClass,
                           s3form, NULL);
      XtAddCallback (wids[5], XtNcallback, ChangeBlankCB,
                  (XtPointer)BlankDelay1);

      wids[6] = XtCreateWidget("Blank2-label", labelWidgetClass, s3form,
                  NULL, 0);
      wids[7] = XtVaCreateWidget("Blank2Dec-button", commandWidgetClass,
                           s3form, NULL);
      XtAddCallback (wids[7], XtNcallback, ChangeBlankCB,
                  (XtPointer)-BlankDelay2);
      (void) sprintf (buf, "%d", AppRes.field[BlankDelay2].val);
      wids[8] = XtVaCreateWidget("Blank2-text", asciiTextWidgetClass,
                  s3form, XtNstring, buf, XtNtranslations, trans, NULL);
      AddCallback(wids[8], XtNcallback, BlankEditCB, (XPointer) BlankDelay2);
      AppRes.field[BlankDelay2].textwidget = wids[8];
      wids[9] = XtVaCreateWidget("Blank2Inc-button", commandWidgetClass,
                           s3form, NULL);
      XtAddCallback (wids[9], XtNcallback, ChangeBlankCB,
                  (XtPointer)BlankDelay2);
      XtManageChildren (wids, 10);
      XtManageChild(s3form);
    }

    XtManageChild (form);

    SetScrollbars ();
    x = DisplayWidth(XtDisplay (top),DefaultScreen (XtDisplay (top))) / 2;
    y = DisplayHeight(XtDisplay (top),DefaultScreen (XtDisplay (top))) / 2;

    invalid_mode_popup = XtVaCreatePopupShell("invalidMode", 
                      transientShellWidgetClass, top,
                      XtNtitle, "Invalid Mode requested",
                      XtNx, x - 20,
                      XtNy, y - 40,
                      NULL);

    testing_popup = XtVaCreatePopupShell("testing", 
                      transientShellWidgetClass, top,
                      XtNtitle, "Testing_1_2_3",
                      XtNx, x - 20,
                      XtNy, y - 40,
                      NULL);
    boxW = XtVaCreateManagedWidget(
                                   "TestingBox",
                                   boxWidgetClass,
                                   testing_popup,
                                   NULL);

    w = XtVaCreateManagedWidget(
               "testingMessage",
                   labelWidgetClass,
                   boxW,
                   NULL);

    w = XtVaCreateManagedWidget(
                               "Abort",
                                commandWidgetClass,
                                boxW,
                                NULL);

    XtAddCallback (w, XtNcallback, (XtCallbackProc) TestTOCB,
              (XtPointer) NULL);

    boxW = XtVaCreateManagedWidget(
                                   "invalidBox",
                                   boxWidgetClass,
                                   invalid_mode_popup,
                                   NULL);
        
    (void) XtVaCreateManagedWidget(
               "ErrorMessage",
                   labelWidgetClass,
                   boxW,
                   NULL);

    popdownW = XtVaCreateManagedWidget(
                                     "AckError",
                                     commandWidgetClass,
                                     boxW,
                                     NULL);

    XtAddCallback (popdownW, XtNcallback, (XtCallbackProc)popdownInvalid, 
               (XtPointer) invalid_mode_popup);
}

static void
QuitAction (Widget w, XEvent* e, String* vector, Cardinal* count)
{
    if ((e->type == ClientMessage
      && e->xclient.data.l[0] == (long) wm_delete_window)
      || e->type == KeyPress)
      QuitCB(w, NULL, NULL);
}

static void
RestoreAction (Widget w, XEvent* e, String* vector, Cardinal* count)
{
    Boolean state;

    RestoreCB(w, NULL, NULL);
    XtVaGetValues(auto_apply_toggle, XtNstate, &state, NULL);
    if (!state)
      ApplyCB (w, NULL, NULL);
}


static void
ShowAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
    ShowCB(w, NULL, NULL);
}

static void
MoveLeftAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
    AdjustCB(w, (XtPointer)HSyncStart, NULL);
}

static void
MoveRightAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
    AdjustCB(w, (XtPointer)-HSyncStart, NULL);
}

static void
NarrowerAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
    AdjustCB(w, (XtPointer)HTotal, NULL);
}

static void
WiderAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
    AdjustCB(w, (XtPointer)-HTotal, NULL);
}

static void
MoveUpAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
    AdjustCB(w, (XtPointer)VSyncStart, NULL);
}

static void
MoveDownAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
    AdjustCB(w, (XtPointer)-VSyncStart, NULL);
}

static void
TallerAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
    AdjustCB(w, (XtPointer)-VTotal, NULL);
}

static void
ShorterAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
    AdjustCB(w, (XtPointer)VTotal, NULL);
}

static void
NextModeAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
      SwitchCB(w, (XPointer) 1, NULL);
}

static void
PrevModeAction(Widget w, XEvent* e, String* vector, Cardinal* count)
{
      SwitchCB(w, (XPointer) -1, NULL);
}



static void
usage(void)
{
    fprintf(stderr, "Usage: xvidtune [option]\n");
    fprintf(stderr, "    where option is one of:\n");
    fprintf(stderr, "        -show                             Print current modeline to stdout\n");
    fprintf(stderr, "        -next                             Switch to next video mode\n");
    fprintf(stderr, "        -prev                             Switch to previous video mode\n");
    fprintf(stderr, "        -unlock                           Enable mode switch hot-keys\n");
    fprintf(stderr, "        -timeout [seconds]                Set testmode timeout in seconds,\n");
    exit(1);
}


int
main (int argc, char** argv)
{
    Widget top;
    XtAppContext app;
    Display* dpy;
    Bool modeSettable = TRUE;
    
    static XtActionsRec actions[] = { { "xvidtune-quit", QuitAction },
                              { "xvidtune-restore", RestoreAction },
                              { "xvidtune-show", ShowAction },
                              {     "xvidtune-moveleft", MoveLeftAction },
                              {     "xvidtune-moveright", MoveRightAction },
                              {     "xvidtune-wider", WiderAction },
                              {     "xvidtune-narrower", NarrowerAction },
                              {     "xvidtune-moveup", MoveUpAction },
                              {     "xvidtune-movedown", MoveDownAction },
                              {     "xvidtune-taller", TallerAction },
                              {     "xvidtune-shorter", ShorterAction },
                              {     "xvidtune-nextmode", NextModeAction },
                              {     "xvidtune-prevmode", PrevModeAction } };

    Top = top = XtVaOpenApplication (&app, "Xvidtune", NULL, 0, &argc, argv,
            NULL, applicationShellWidgetClass, 
            XtNmappedWhenManaged, False, NULL);

    XtGetApplicationResources (top, (XtPointer)&AppRes,
            Resources, XtNumber(Resources),
            NULL, 0);

    if (!AppRes.ad_installed) {
      fprintf(stderr, "Please install the program before using\n");
      return 3;
    }

    if (!XF86VidModeQueryVersion(XtDisplay (top), &MajorVersion, &MinorVersion)) {
      fprintf(stderr, "Unable to query video extension version\n");
      return 2;
    }

    if (!XF86VidModeQueryExtension(XtDisplay (top), &EventBase, &ErrorBase)) {
      fprintf(stderr, "Unable to query video extension information\n");
      return 2;
    }

    /* Fail if the extension version in the server is too old */
    if (MajorVersion < MINMAJOR || 
      (MajorVersion == MINMAJOR && MinorVersion < MINMINOR)) {
      fprintf(stderr,
            "Xserver is running an old XFree86-VidModeExtension version"
            " (%d.%d)\n", MajorVersion, MinorVersion);
      fprintf(stderr, "Minimum required version is %d.%d\n",
            MINMAJOR, MINMINOR);
      exit(2);
    }
 
    /* This should probably be done differently */

    if(  argc == 3  ) { /* this can only be the timeout case */
        if(  (!strcmp(argv[1], "-timeout"))  ) {
            TestTimeout = ((unsigned long) atol( argv[2] )) * 1000L;
      } 
      else
          usage();
    }

    if (argc > 1) {
      int i = 0;
        
      if (argc != 2)
            usage();
      if (!strcmp(argv[1], "-show")) {
        if (!GetModeLine(XtDisplay (top), DefaultScreen (XtDisplay (top)))) {
          fprintf(stderr, "Unable to get mode info\n");
          CleanUp(XtDisplay (top));
          return 2;
        }
        ShowCB(top, NULL, NULL);
        return 0;
      } else if (!strcmp(argv[1], "-next"))
          i = 1;
      else if (!strcmp(argv[1], "-prev"))
          i = -1;
      else if (!strcmp(argv[1], "-unlock")) {
          CleanUp(XtDisplay (top));
          XSync(XtDisplay (top), True);
          return 0;
      } else
            usage();
      if (i != 0) {
          XF86VidModeSwitchMode(XtDisplay (top),
                          DefaultScreen (XtDisplay (top)), i);
          XSync(XtDisplay (top), True);
          return 0;
      }
    }
    if (!GetMonitor(XtDisplay (top), DefaultScreen (XtDisplay (top)))) {
      fprintf(stderr, "Unable to query monitor info\n");
      return 2;
    }

    if (!XF86VidModeLockModeSwitch(XtDisplay (top),
                           DefaultScreen (XtDisplay (top)), TRUE)) {
      fprintf(stderr, "Failed to disable mode-switch hot-keys\n");
      return 2;
    }

    signal(SIGINT, CatchSig);
    signal(SIGQUIT, CatchSig);
    signal(SIGTERM, CatchSig);
    signal(SIGHUP, CatchSig);
    sigId = XtAppAddSignal(app, CatchXtSig, NULL);

    if (!GetModeLine(XtDisplay (top), DefaultScreen (XtDisplay (top)))) {
      fprintf(stderr, "Unable to get mode info\n");
      CleanUp(XtDisplay (top));
      return 2;
    }

    xtErrorfunc = XSetErrorHandler(vidmodeError); 

    trans = XtParseTranslationTable ("\
      <Key>0: insert-char()\n<Key>1: insert-char()\n\
      <Key>2: insert-char()\n<Key>3: insert-char()\n\
      <Key>4: insert-char()\n<Key>5: insert-char()\n\
      <Key>6: insert-char()\n<Key>7: insert-char()\n\
      <Key>8: insert-char()\n<Key>9: insert-char()\n\
      <Key>a: insert-char()\n<Key>b: insert-char()\n\
      <Key>c: insert-char()\n<Key>d: insert-char()\n\
      <Key>e: insert-char()\n<Key>f: insert-char()\n\
      <Key>+: insert-char()\n<Key>-: insert-char()\n\
      <Key>r: xvidtune-restore()\n<Key>q: xvidtune-quit()\n\
      <Key>BackSpace: delete-previous-character()\n\
      <Key>Right: forward-character()\n<Key>KP_Right: forward-character()\n\
      <Key>Left: backward-character()\n<Key>KP_Left: backward-character()\n\
      <Key>Delete: delete-previous-character()\n\
      <Key>KP_Delete: delete-previous-character()\n\
      <EnterWindow>: enter-window()\n<LeaveWindow>: leave-window()\n\
      <FocusIn>: focus-in()\n<FocusOut>: focus-out()\n\
      <Btn1Down>: select-start()\n");

    if (!ModeSettable()) {
      printf("Video are not settable on this chip\n");
      displayNoTune(top);
      modeSettable = FALSE;
    } else
      CreateHierarchy (top);
    

    XtAppAddActions (app, actions, XtNumber(actions));

    XtOverrideTranslations (top,
            XtParseTranslationTable ("<Message>WM_PROTOCOLS: xvidtune-quit()"));

    XtRealizeWidget (top);

    dpy = XtDisplay(top);

    wm_delete_window = XInternAtom (dpy, "WM_DELETE_WINDOW", False);

    (void) XSetWMProtocols (dpy, XtWindow (top), &wm_delete_window, 1);

    XtMapWidget (top);

    if (modeSettable)
      displayWarning(top);

    /* really we should run our own event dispatching here until the
     * warning has been read...
     */
    XtAppMainLoop (app);

    return 0;
}

Generated by  Doxygen 1.6.0   Back to index