Пример #1
0
 void NanosMain::set_instrumentation(const std::string& str)
 {
     parse_boolean_option("instrument",
             str,
             _instrumentation_enabled,
             "Ignoring invalid value for 'instrument");
 }
Пример #2
0
 void NanosMain::set_nanos_main(const std::string& str)
 {
     parse_boolean_option("nanos_main_enabled",
             str,
             _nanos_main_enabled,
             "Ignoring invalid value for 'nanos_main_enabled'");
 }
Пример #3
0
int
main(int argc, char *argv[])
{
    Visual visual;
    XSetWindowAttributes xswa;
    int i;
    char *displayname = NULL;
    Display *dpy;
    Colormap cmap;
    enum e_action action = doDefault;
    unsigned long mask;
    int screen;
    int x, y, width, height;
    char *geom = NULL;
    int geom_result;
    int display_width, display_height;
    char *solidcolor = NULL;
    XColor cdef;

    ProgramName = argv[0];

    for (i = 1; i < argc; i++) {
        char *arg = argv[i];

        if (arg[0] == '-') {
            if (isabbreviation ("-display", arg, 2)) {
                if (++i >= argc) Syntax ();
                displayname = argv[i];
                continue;
            } else if (isabbreviation ("-geometry", arg, 2)) {
                if (++i >= argc) Syntax ();
                geom = argv[i];
                continue;
            } else if (isabbreviation ("-black", arg, 2)) {
                action = doBlack;
                continue;
            } else if (isabbreviation ("-white", arg, 2)) {
                action = doWhite;
                continue;
            } else if (isabbreviation ("-solid", arg, 2)) {
                if (++i >= argc) Syntax ();
                solidcolor = argv[i];
                action = doSolid;
                continue;
            } else if (isabbreviation ("-none", arg, 2)) {
                action = doNone;
                continue;
            } else if (isabbreviation ("-root", arg, 2)) {
                action = doRoot;
                continue;
            } else
                Syntax ();
        } else if (arg[0] == '=')			/* obsolete */
            geom = arg;
        else
            Syntax ();
    }

    if ((dpy = XOpenDisplay(displayname)) == NULL) {
        fprintf (stderr, "%s:  unable to open display '%s'\n",
                 ProgramName, XDisplayName (displayname));
        exit (1);
    }

    if (action == doDefault) {
        char *def;

        if ((def = XGetDefault (dpy, ProgramName, "Solid")) != NULL) {
            solidcolor = strdup (def);
            if (solidcolor == NULL) {
                fprintf (stderr,
                         "%s:  unable to allocate memory for string.\n",
                         ProgramName);
                exit (1);
            }
            action = doSolid;
        } else {
            struct s_pair *pp;

            for (pp = pair_table; pp->resource_name != NULL; pp++) {
                def = XGetDefault (dpy, ProgramName, pp->resource_name);
                if (def && parse_boolean_option (def) == 1) {
                    action = pp->action;
                }
            }
        }
    }

    if (geom == NULL) geom = XGetDefault (dpy, ProgramName, "Geometry");

    screen = DefaultScreen (dpy);
    display_width = DisplayWidth (dpy, screen);
    display_height = DisplayHeight (dpy, screen);
    x = y = 0;
    width = display_width;
    height = display_height;

    if (DisplayCells (dpy, screen) <= 2 && action == doSolid) {
        if (strcmp (solidcolor, "black") == 0)
            action = doBlack;
        else if (strcmp (solidcolor, "white") == 0)
            action = doWhite;
        else {
            fprintf (stderr,
                     "%s:  can't use colors on a monochrome display.\n",
                     ProgramName);
            action = doNone;
        }
    }

    if (geom)
        geom_result = XParseGeometry (geom, &x, &y,
                                      (unsigned int *)&width,
                                      (unsigned int *)&height);
    else
        geom_result = NoValue;

    /*
     * For parsing geometry, we want to have the following
     *
     *     =                (0,0) for (display_width,display_height)
     *     =WxH+X+Y         (X,Y) for (W,H)
     *     =WxH-X-Y         (display_width-W-X,display_height-H-Y) for (W,H)
     *     =+X+Y            (X,Y) for (display_width-X,display_height-Y)
     *     =WxH             (0,0) for (W,H)
     *     =-X-Y            (0,0) for (display_width-X,display_height-Y)
     *
     * If we let any missing values be taken from (0,0) for
     * (display_width,display_height) we just have to deal with the
     * negative offsets.
     */

    if (geom_result & XNegative) {
        if (geom_result & WidthValue) {
            x = display_width - width + x;
        } else {
            width = display_width + x;
            x = 0;
        }
    }
    if (geom_result & YNegative) {
        if (geom_result & HeightValue) {
            y = display_height - height + y;
        } else {
            height = display_height + y;
            y = 0;
        }
    }

    mask = 0;
    switch (action) {
    case doBlack:
        xswa.background_pixel = BlackPixel (dpy, screen);
        mask |= CWBackPixel;
        break;
    case doWhite:
        xswa.background_pixel = WhitePixel (dpy, screen);
        mask |= CWBackPixel;
        break;
    case doSolid:
        cmap = DefaultColormap (dpy, screen);
        if (XParseColor (dpy, cmap, solidcolor, &cdef) &&
                XAllocColor (dpy, cmap, &cdef)) {
            xswa.background_pixel = cdef.pixel;
            mask |= CWBackPixel;
        } else {
            fprintf (stderr,"%s:  unable to allocate color '%s'.\n",
                     ProgramName, solidcolor);
            action = doNone;
        }
        break;
    case doDefault:
    case doNone:
        xswa.background_pixmap = None;
        mask |= CWBackPixmap;
        break;
    case doRoot:
        xswa.background_pixmap = ParentRelative;
        mask |= CWBackPixmap;
        break;
    }
    xswa.override_redirect = True;
    xswa.backing_store = NotUseful;
    xswa.save_under = False;
    mask |= (CWOverrideRedirect | CWBackingStore | CWSaveUnder);
    visual.visualid = CopyFromParent;
    win = XCreateWindow(dpy, DefaultRootWindow(dpy), x, y, width, height,
                        0, DefaultDepth(dpy, screen), InputOutput, &visual, mask, &xswa);

    /*
     * at some point, we really ought to go walk the tree and turn off
     * backing store;  or do a ClearArea generating exposures on all windows
     */
    XMapWindow (dpy, win);
    /* the following will free the color that we might have allocateded */
    XCloseDisplay (dpy);
    exit (0);
}
Пример #4
0
 void Lowering::set_instrumentation(const std::string& str)
 {
     parse_boolean_option("instrument", str, _instrumentation_enabled, "Assuming false.");
 }