main.cc File Reference

#include <cstdlib>
#include <iostream>
#include <list>
#include <string>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/spdlog.h>
#include <boost/lexical_cast.hpp>
#include <boost/program_options.hpp>
#include <gtk/gtk.h>
#include <scroom/logger.hh>
#include "callbacks.hh"

Include dependency graph for main.cc:

Functions
void	usage (const Scroom::Logger &logger, const std::string &me, const po::options_description &desc, const std::string &message=std::string())
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

{
  const std::string me = argv[0]; // NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
  std::map<std::string, std::list<std::string>> filenames;
 
  auto loggerContainer = Scroom::LoggerContainer::instance();
  Scroom::Logger logger(loggerContainer);
 
#ifdef _WIN32
  // In windows, redirect all logging to file.
  // On the off-chance that we're running in a debugger that does capture console logging, redirect to console as well.
  const auto logDirParent = in_devmode() ? boost::filesystem::path(TOP_SRCDIR) : boost::dll::program_location().parent_path();
  const auto logDir = logDirParent / "logs";
  const auto logFile = logDir / fmt::format("scroom-log-{}.txt", getpid());
 
  boost::filesystem::create_directory(logDir);
 
  auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
  auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(logFile.string(), true);
 
  auto spdlogger = std::make_shared<spdlog::logger>("scroom", spdlog::sinks_init_list{console_sink, file_sink});
  loggerContainer->set(spdlogger);
#else
  auto spdlogger = loggerContainer->get();
#endif
 
  spdlogger->set_level(spdlog::level::trace);
  spdlogger->set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%t] [%^%-5l%$] %v");
 
  po::options_description desc("Available options");
  desc.add_options()("help,h", "Show this help message")("load,l", po::value<std::vector<std::string>>(), "Load given filenames")(
    "transparent-overlay", po::value<std::vector<std::string>>()->multitoken(), "Show given files in transparent overlay"
  );
 
  po::positional_options_description p;
  p.add("load", -1);
 
  po::variables_map vm;
 
  try
  {
    po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
    po::notify(vm);
 
    if(vm.count("help"))
    {
      usage(logger, me, desc);
    }
 
    if(vm.count("load"))
    {
      const auto& names = vm["load"].as<std::vector<std::string>>();
      filenames[REGULAR_FILES].assign(names.begin(), names.end());
    }
 
    if(vm.count("transparent-overlay"))
    {
      const auto& names = vm["transparent-overlay"].as<std::vector<std::string>>();
      filenames["Transparent Overlay"].assign(names.begin(), names.end());
    }
  }
  catch(std::exception& ex)
  {
    usage(logger, me, desc, ex.what());
  }
 
  setlocale(LC_ALL, ""); // NOLINT(concurrency-mt-unsafe)
  gtk_init(&argc, &argv);
 
  on_scroom_bootstrap(filenames);
 
  gtk_main();
 
  on_scroom_terminating();
  logger->debug("Scroom terminating...");
  return 0;
}

Here is the call graph for this function:

usage()

void usage	(	const Scroom::Logger &	logger,
		const std::string &	me,
		const po::options_description &	desc,
		const std::string &	message = std::string()
	)

{
  if(!message.empty())
  {
    logger->error("{}", message);
  }
 
  logger->info("Usage: {}  [options] [input files]", me);
 
  logger->info("{}", boost::lexical_cast<std::string>(desc));
 
  exit(-1); // NOLINT(concurrency-mt-unsafe)
}

Referenced by main().

Here is the caller graph for this function: