Esempio n. 1
0
/** configure from preferences */
static NftResult _this_from_prefs(
        NftPrefs * prefs,
        void **newObj,
        NftPrefsNode * node,
        void *userptr)
{
		/* window geometry */
		gint x = 0, y = 0, width = 0, height = 0;
        nft_prefs_node_prop_int_get(node, "x", &x);
        nft_prefs_node_prop_int_get(node, "y", &y);
        nft_prefs_node_prop_int_get(node, "width", &width);
        nft_prefs_node_prop_int_get(node, "height", &height);

        if(width > 0 && height > 0)
                gtk_window_resize(GTK_WINDOW(UI("window")), width, height);
        if(x > 0 && y > 0)
                gtk_window_move(GTK_WINDOW(UI("window")), x, y);
		
		/* log visible? */
		bool boolean = false;
		nft_prefs_node_prop_boolean_get(node, "window-visible", &boolean);
		gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(niftyconf_ui("item_log_win")), boolean);
		ui_log_show(boolean);

		/* log level */
		char *loglevel;
		if((loglevel = nft_prefs_node_prop_string_get(node, "loglevel")))
		{
				nft_log_level_set(nft_log_level_from_string(loglevel));
				nft_prefs_free(loglevel);
		}

		/* log flags */
		nft_prefs_node_prop_boolean_get(node, "show-file", &boolean);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(UI("checkbutton_file")), boolean);
		nft_prefs_node_prop_boolean_get(node, "show-line", &boolean);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(UI("checkbutton_line")), boolean);
		nft_prefs_node_prop_boolean_get(node, "show-function", &boolean);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(UI("checkbutton_function")), boolean);
		
		return NFT_SUCCESS;
}
Esempio n. 2
0
/** parse commandline arguments */
static NftResult _parse_args(int argc, char *argv[])
{
	int index, argument;

	static struct option loptions[] =
	{
		{"help", 0, 0, 'h'},
                {"plugin-help", 0, 0, 'p'},
		{"loglevel", required_argument, 0, 'l'},
		{"config", required_argument, 0, 'c'},
                {"dimensions", required_argument, 0, 'd'},
                {"fps", required_argument, 0, 'F'},
                {"format", required_argument, 0, 'f'},
                {"big-endian", no_argument, 0, 'b'},
                {"loop", no_argument, 0, 'L'},
#if HAVE_IMAGEMAGICK == 1
                {"raw", no_argument, 0, 'r'},
#endif
		{0,0,0,0}
	};

#if HAVE_IMAGEMAGICK == 1
	const char arglist[] = "hpl:c:d:F:f:bLr";
#else
	const char arglist[] = "hpl:c:d:F:f:bL";
#endif
	while((argument = getopt_long(argc, argv, arglist, loptions, &index)) >= 0)
	{

		switch(argument)
		{
			/* --help */
			case 'h':
			{
				_print_help(argv[0]);
				return NFT_FAILURE;
			}

                        /* --plugin-help */
                        case 'p':
                        {
                                _print_plugin_help();
                                return NFT_FAILURE;
                        }

			/* --config */
			case 'c':
			{
				/* save filename for later */
				strncpy(_c.prefsfile, optarg, sizeof(_c.prefsfile));
				break;
			}

                        /** --loop */
                        case 'L':
                        {
                                _c.do_loop = TRUE;
                                break;
                        }

                        /** --dimensions */
                        case 'd':
                        {
                                if(sscanf(optarg, "%dx%d", (int*) &_c.width, (int*) &_c.height) != 2)
				{
					NFT_LOG(L_ERROR, "Invalid dimension \"%s\" (Use something like 320x400)", optarg);
					return NFT_FAILURE;
				}
                                break;
                        }

                        /** --fps */
                        case 'F':
                        {
                                if(sscanf(optarg, "%d", (int*) &_c.fps) != 1)
				{
					NFT_LOG(L_ERROR, "Invalid framerate \"%s\" (Use an integer)", optarg);
					return NFT_FAILURE;
				}
				break;
                        }

			/** --loglevel */
			case 'l':
			{
				if(!nft_log_level_set(nft_log_level_from_string(optarg)))
                                {
                                        _print_loglevels();
                                        return NFT_FAILURE;
                                }

				break;
			}

                        /** --format */
                        case 'f':
                        {
                                strncpy(_c.pixelformat, optarg, sizeof(_c.pixelformat));
                                break;
                        }

#if HAVE_IMAGEMAGICK == 1
                        /** --raw */
                        case 'r':
                        {
                                _c.raw = TRUE;
                                break;
                        }
#endif

                        /** --big-endian */
                        case 'b':
                        {
                                _c.is_big_endian = TRUE;
                                break;
                        }

			/* invalid argument */
			case '?':
			{
				NFT_LOG(L_ERROR, "argument %d is invalid", index);
				_print_help(argv[0]);
				return NFT_FAILURE;
			}

			/* unhandled arguments */
			default:
			{
				NFT_LOG(L_ERROR, "argument %d is invalid", index);
				break;
			}
		}
	}


	_c.files = &argv[optind];


	return NFT_SUCCESS;
}
Esempio n. 3
0
/** parse commandline arguments */
static NftResult _parse_args(int argc, char *argv[])
{
	int index, argument;

	static struct option loptions[] =
	{
		{"help", 0, 0, 'h'},
                {"plugin-help", 0, 0, 'p'},
		{"loglevel", required_argument, 0, 'l'},
		{"config", required_argument, 0, 'c'},
                {"x", required_argument, 0, 'x'},
                {"y", required_argument, 0, 'y'},
                {"dimensions", required_argument, 0, 'd'},
                {"fps", required_argument, 0, 'f'},
                {"mechanism", required_argument, 0, 'm'},
		{0,0,0,0}
	};

	while((argument = getopt_long(argc, argv, "hpl:c:x:y:d:f:m:", loptions, &index)) >= 0)
	{

		switch(argument)
		{
			/** --help */
			case 'h':
			{
				_print_help(argv[0]);
				return NFT_FAILURE;
			}

                        /* --plugin-help */
                        case 'p':
                        {
                                _print_plugin_help();
                                return NFT_FAILURE;
                        }

                        /* --mechanism */
                        case 'm':
                        {
                                _c.method = capture_method_from_string(optarg);
                                break;
                        }

			/** --config */
			case 'c':
			{
				/* save filename for later */
				strncpy(_c.prefsfile, optarg, sizeof(_c.prefsfile));
				break;
			}

                        /** --x */
                        case 'x':
                        {
                                if(sscanf(optarg, "%d", (int*) &_c.x) != 1)
				{
					NFT_LOG(L_ERROR, "Invalid x-coordinate \"%s\" (Use an integer)", optarg);
					return NFT_FAILURE;
				}
				break;
                        }

                        /** --y */
                        case 'y':
                        {
                                if(sscanf(optarg, "%d", (int*) &_c.y) != 1)
				{
					NFT_LOG(L_ERROR, "Invalid y-coordinate \"%s\" (Use an integer)", optarg);
					return NFT_FAILURE;
				}
				break;
                        }

                        /** --dimensions */
                        case 'd':
                        {
                                if(sscanf(optarg, "%dx%d", (int*) &_c.width, (int*) &_c.height) != 2)
				{
					NFT_LOG(L_ERROR, "Invalid dimension \"%s\" (Use something like 320x400)", optarg);
					return NFT_FAILURE;
				}
                                break;
                        }

                        /** --fps */
                        case 'f':
                        {
                                if(sscanf(optarg, "%d", (int*) &_c.fps) != 1)
				{
					NFT_LOG(L_ERROR, "Invalid framerate \"%s\" (Use an integer)", optarg);
					return NFT_FAILURE;
				}
				break;
                        }

			/** --loglevel */
			case 'l':
			{
				if(!nft_log_level_set(nft_log_level_from_string(optarg)))
                                {
                                        _print_loglevels();
                                        return NFT_FAILURE;
                                }
				break;
			}

			/* invalid argument */
			case '?':
			{
				NFT_LOG(L_ERROR, "argument %d is invalid", index);
				_print_help(argv[0]);
				return NFT_FAILURE;
			}

			/* unhandled arguments */
			default:
			{
				NFT_LOG(L_ERROR, "argument %d is invalid", index);
				break;
			}
		}
	}


	return NFT_SUCCESS;
}