callbacks.hh File Reference

#include <list>
#include <map>
#include <string>
#include <gdk/gdk.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <scroom/presentationinterface.hh>
#include <scroom/scroominterface.hh>
#include "view.hh"

Include dependency graph for callbacks.hh:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
using	FileNameMap = std::map< std::string, std::list< std::string > >

Functions
void	on_scroom_hide (GtkWidget *widget, gpointer user_data)
void	on_new_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_open_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_save_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_save_as_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_quit_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_cut_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_copy_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_paste_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_delete_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_fullscreen_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_close_activate (GtkMenuItem *menuitem, gpointer user_data)
void	on_about_activate (GtkMenuItem *menuitem, gpointer user_data)
gboolean	on_drawingarea_expose_event (GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
gboolean	on_drawingarea_configure_event (GtkWidget *widget, GdkEventConfigure *event, gpointer user_data)
gboolean	on_idle (gpointer user_data)
void	on_done_loading_plugins ()
void	on_zoombox_changed (GtkComboBox *widget, gpointer user_data)
void	on_scrollbar_value_changed (GtkAdjustment *adjustment, gpointer user_data)
void	on_textbox_value_changed (GtkEditable *editable, gpointer user_data)
void	on_scroom_bootstrap (const FileNameMap &newFilenames)
void	on_scroom_terminating ()
void	find_or_create_scroom (const PresentationInterface::Ptr &presentation)
void	create_scroom (const PresentationInterface::Ptr &presentation)
void	on_newPresentationInterfaces_update (const std::map< NewPresentationInterface::Ptr, std::string > &newPresentationInterfaces)
void	on_presentation_created (const PresentationInterface::Ptr &p)
void	on_view_created (const View::Ptr &v)
void	on_presentation_added_to_view (const View::Ptr &v)
void	on_view_destroyed (View *v)
void	on_new_presentationobserver (const PresentationObserver::Ptr &po)
void	on_new_viewobserver (const ViewObserver::Ptr &viewObserver)
void	on_presentation_possibly_destroyed ()
bool	in_devmode ()

Variables
const std::string	REGULAR_FILES

Typedef Documentation

FileNameMap

using FileNameMap = std::map<std::string, std::list<std::string> >

Function Documentation

create_scroom()

void create_scroom

(

const PresentationInterface::Ptr &

presentation

)

{
  GtkBuilder* xml = gtk_builder_new();
  boost::scoped_array<char*> const obj{new gchar*[2]};
  const std::string str = "scroom";
  obj[0] = const_cast<char*>(str.c_str());
  obj[1] = nullptr;
  gtk_builder_add_objects_from_file(xml, xmlFileName.c_str(), obj.get(), nullptr);
 
  if(xml == nullptr)
  {
    logger->error("Opening xml failed");
    exit(-1); // NOLINT(concurrency-mt-unsafe)
  }
 
  View::Ptr const view = View::create(xml, presentation);
  on_view_created(view);
  if(presentation)
  {
    on_presentation_added_to_view(view);
  }
 
  GtkWidget* scroom = GTK_WIDGET(gtk_builder_get_object(xml, "scroom"));
  GtkWidget* openMenuItem = GTK_WIDGET(gtk_builder_get_object(xml, "open"));
  GtkWidget* closeMenuItem = GTK_WIDGET(gtk_builder_get_object(xml, "close"));
  GtkWidget* quitMenuItem = GTK_WIDGET(gtk_builder_get_object(xml, "quit"));
  GtkWidget* fullScreenMenuItem = GTK_WIDGET(gtk_builder_get_object(xml, "fullscreen_menu_item"));
  GtkWidget* aboutMenuItem = GTK_WIDGET(gtk_builder_get_object(xml, "about"));
  GtkWidget* drawingArea = GTK_WIDGET(gtk_builder_get_object(xml, "drawingarea"));
  GtkWidget* zoomBox = GTK_WIDGET(gtk_builder_get_object(xml, "zoomboxcombo"));
  GtkWidget* vscrollbar = GTK_WIDGET(gtk_builder_get_object(xml, "vscrollbar"));
  GtkWidget* hscrollbar = GTK_WIDGET(gtk_builder_get_object(xml, "hscrollbar"));
  GtkAdjustment* vscrollbaradjustment = gtk_range_get_adjustment(GTK_RANGE(vscrollbar));
  GtkAdjustment* hscrollbaradjustment = gtk_range_get_adjustment(GTK_RANGE(hscrollbar));
  GtkEditable* xTextBox = GTK_EDITABLE(GTK_WIDGET(gtk_builder_get_object(xml, "x_textbox")));
  GtkEditable* yTextBox = GTK_EDITABLE(GTK_WIDGET(gtk_builder_get_object(xml, "y_textbox")));
 
  g_signal_connect(static_cast<gpointer>(scroom), "hide", G_CALLBACK(on_scroom_hide), view.get());
  g_signal_connect(static_cast<gpointer>(closeMenuItem), "activate", G_CALLBACK(on_close_activate), view.get());
  g_signal_connect(static_cast<gpointer>(quitMenuItem), "activate", G_CALLBACK(on_quit_activate), view.get());
  g_signal_connect(static_cast<gpointer>(openMenuItem), "activate", G_CALLBACK(on_open_activate), scroom);
  g_signal_connect(static_cast<gpointer>(fullScreenMenuItem), "activate", G_CALLBACK(on_fullscreen_activate), view.get());
  g_signal_connect(static_cast<gpointer>(zoomBox), "changed", G_CALLBACK(on_zoombox_changed), view.get());
  g_signal_connect(
    static_cast<gpointer>(vscrollbaradjustment), "value-changed", G_CALLBACK(on_scrollbar_value_changed), view.get()
  );
  g_signal_connect(
    static_cast<gpointer>(hscrollbaradjustment), "value-changed", G_CALLBACK(on_scrollbar_value_changed), view.get()
  );
  g_signal_connect(static_cast<gpointer>(xTextBox), "changed", G_CALLBACK(on_textbox_value_changed), view.get());
  g_signal_connect(static_cast<gpointer>(yTextBox), "changed", G_CALLBACK(on_textbox_value_changed), view.get());
  // g_signal_connect ((gpointer) cut, "activate",
  //                   G_CALLBACK (on_cut_activate),
  //                   view.get());
  // g_signal_connect ((gpointer) copy, "activate",
  //                   G_CALLBACK (on_copy_activate),
  //                   view.get());
  // g_signal_connect ((gpointer) paste, "activate",
  //                   G_CALLBACK (on_paste_activate),
  //                   view.get());
  // g_signal_connect ((gpointer) delete, "activate",
  //                   G_CALLBACK (on_delete_activate),
  //                   view.get());
  g_signal_connect(static_cast<gpointer>(aboutMenuItem), "activate", G_CALLBACK(on_about_activate), view.get());
  g_signal_connect(static_cast<gpointer>(drawingArea), "draw", G_CALLBACK(on_drawingarea_expose_event), view.get());
  g_signal_connect(static_cast<gpointer>(drawingArea), "configure_event", G_CALLBACK(on_drawingarea_configure_event), view.get());
  g_signal_connect(static_cast<gpointer>(drawingArea), "button-press-event", G_CALLBACK(on_button_press_event), view.get());
  g_signal_connect(static_cast<gpointer>(drawingArea), "button-release-event", G_CALLBACK(on_button_release_event), view.get());
  g_signal_connect(static_cast<gpointer>(drawingArea), "scroll-event", G_CALLBACK(on_scroll_event), view.get());
  g_signal_connect(static_cast<gpointer>(drawingArea), "motion-notify-event", G_CALLBACK(on_motion_notify_event), view.get());
 
  char uriList[] = "text/uri-list";
  GtkTargetEntry targets[] = {{uriList, 0, 0}};
  gtk_drag_dest_set(
    scroom, GTK_DEST_DEFAULT_ALL, targets, 1, static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK)
  );
 
  g_signal_connect(static_cast<gpointer>(scroom), "drag_data_received", G_CALLBACK(onDragDataReceived), NULL);
  // delete xml; //Breaks code for some reason. It seems that this xml is freed somewhere else...
}

Referenced by find_or_create_scroom(), and on_scroom_bootstrap().

Here is the call graph for this function:

Here is the caller graph for this function:

find_or_create_scroom()

void find_or_create_scroom

(

const PresentationInterface::Ptr &

presentation

)

{
  require(presentation);
 
  for(const Views::value_type& p: views)
  {
    View::Ptr const view = p.first;
    if(!view->hasPresentation())
    {
      view->setPresentation(presentation);
      on_presentation_added_to_view(view);
      return;
    }
  }
  create_scroom(presentation);
}

Referenced by create(), load(), on_done_loading_plugins(), anonymous_namespace{view.cc}::on_newWindow_activate(), and ScroomInterfaceImpl::showPresentation().

Here is the call graph for this function:

Here is the caller graph for this function:

in_devmode()

bool in_devmode

(

)

{ return nullptr != getenv(SCROOM_DEV_MODE.c_str()); }

Referenced by main(), and on_scroom_bootstrap().

Here is the caller graph for this function:

on_about_activate()

void on_about_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{
  // GtkWidget* aboutdialog;
  // aboutdialog = create_aboutdialog ();
  gtk_dialog_run(GTK_DIALOG(aboutDialog));
  gtk_widget_hide(aboutDialog);
  // gtk_widget_destroy (aboutdialog);
}

Referenced by create_scroom().

Here is the caller graph for this function:

on_close_activate()

void on_close_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{
  View* view = static_cast<View*>(user_data);
 
  view->hide();
}

Referenced by create_scroom().

Here is the call graph for this function:

Here is the caller graph for this function:

on_copy_activate()

void on_copy_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{}

on_cut_activate()

void on_cut_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{}

on_delete_activate()

void on_delete_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{}

on_done_loading_plugins()

void on_done_loading_plugins

(

)

{
  if(!filenames.empty())
  {
    {
      std::list<std::string>& fn = filenames[REGULAR_FILES];
 
      while(!fn.empty())
      {
        const std::string& file = fn.front();
        try
        {
          load(file);
        }
        catch(std::exception& ex)
        {
          logger->error(ex.what());
          on_presentation_possibly_destroyed();
        }
        gchar* dir = g_path_get_dirname(file.c_str());
        currentFolder = dir;
        g_free(dir);
        fn.pop_front();
      }
    }
    filenames.erase(REGULAR_FILES);
 
    PluginManager::Ptr const instance = PluginManager::getInstance();
    std::map<std::string, NewAggregateInterface::Ptr> const& newAggregateInterfaces = instance->getNewAggregateInterfaces();
 
    for(FileNameMap::value_type const& v: filenames)
    {
      const std::string& aggregateName = v.first;
      std::list<std::string> const& files = v.second;
 
      auto i = newAggregateInterfaces.find(aggregateName);
      if(i != newAggregateInterfaces.end())
      {
        try
        {
          Aggregate::Ptr const aggregate = i->second->createNew();
          PresentationInterface::Ptr const aggregatePresentation = std::dynamic_pointer_cast<PresentationInterface>(aggregate);
 
          if(aggregatePresentation)
          {
            for(const std::string& file: files)
            {
              PresentationInterface::Ptr const p = loadPresentation(file);
              aggregate->addPresentation(p);
            }
 
            on_presentation_created(aggregatePresentation);
            find_or_create_scroom(aggregatePresentation);
          }
          else
          {
            logger->error("Don't know how to display a {}", aggregateName);
          }
        }
        catch(std::exception& ex)
        {
          logger->error("While creating {}: {}", aggregateName, ex.what());
          on_presentation_possibly_destroyed();
        }
      }
      else
      {
        logger->error("Don't know how to create {}", aggregateName);
      }
    }
 
    if(presentations.empty())
    {
      // Apparently, we couldn't load any of our presentations. Terminate...
      ensure(views.empty());
      gtk_main_quit();
    }
  }
}

Referenced by PluginManager::doWork().

Here is the call graph for this function:

Here is the caller graph for this function:

on_drawingarea_configure_event()

gboolean on_drawingarea_configure_event	(	GtkWidget *	widget,
		GdkEventConfigure *	event,
		gpointer	user_data
	)

{
  View* view = static_cast<View*>(user_data);
  view->on_configure();
  return FALSE;
}

Referenced by create_scroom().

Here is the call graph for this function:

Here is the caller graph for this function:

on_drawingarea_expose_event()

gboolean on_drawingarea_expose_event	(	GtkWidget *	widget,
		GdkEventExpose *	event,
		gpointer	user_data
	)

{
  cairo_region_t* re = cairo_region_create();
 
  GdkDrawingContext* dc;
  dc = gdk_window_begin_draw_frame(gtk_widget_get_window(widget), re);
 
  cairo_t* cr = gdk_drawing_context_get_cairo_context(dc);
 
  View* view = static_cast<View*>(user_data);
  view->redraw(cr);
 
  gdk_window_end_draw_frame(gtk_widget_get_window(widget), dc);
 
  cairo_region_destroy(re);
 
  return FALSE;
}

Referenced by create_scroom().

Here is the call graph for this function:

Here is the caller graph for this function:

on_fullscreen_activate()

void on_fullscreen_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{
  View* view = static_cast<View*>(user_data);
  GtkCheckMenuItem* cmi = GTK_CHECK_MENU_ITEM(item);
  const gboolean active = gtk_check_menu_item_get_active(cmi);
 
  if(active)
  {
    view->setFullScreen();
  }
  else
  {
    view->unsetFullScreen();
  }
}

Referenced by create_scroom().

Here is the caller graph for this function:

on_idle()

gboolean on_idle

(

gpointer

user_data

)

{
  if(user_data == nullptr)
  {
    return 0;
  }
 
  return reinterpret_cast<WorkInterface*>(user_data)->doWork();
}

Referenced by PluginManager::addHook(), and anonymous_namespace{progressbarmanager.cc}::ProgressBarPulser::start().

Here is the caller graph for this function:

on_new_activate()

void on_new_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{
  auto* newPresentationInterface = static_cast<NewPresentationInterface*>(user_data);
  create(newPresentationInterface);
}

Referenced by View::on_newPresentationInterfaces_update().

Here is the call graph for this function:

Here is the caller graph for this function:

on_new_presentationobserver()

void on_new_presentationobserver

(

const PresentationObserver::Ptr &

po

)

{
  for(auto& presentation: presentations)
  {
    PresentationInterface::Ptr const p = presentation.lock();
    if(p)
    {
      po->presentationAdded(p);
    }
  }
}

on_new_viewobserver()

void on_new_viewobserver

(

const ViewObserver::Ptr &

viewObserver

)

{
  for(auto& [view, token]: views)
  {
    if(view->hasPresentation())
    {
      token.add(viewObserver->viewAdded(view));
    }
  }
}

Referenced by PluginManager::registerViewObserver().

Here is the call graph for this function:

Here is the caller graph for this function:

on_newPresentationInterfaces_update()

void on_newPresentationInterfaces_update

(

const std::map< NewPresentationInterface::Ptr, std::string > &

newPresentationInterfaces

)

{
  for(const Views::value_type& p: views)
  {
    p.first->on_newPresentationInterfaces_update(newPresentationInterfaces);
  }
}

Referenced by PluginManager::registerNewPresentationInterface().

Here is the caller graph for this function:

on_open_activate()

void on_open_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{
  GtkWidget* dialog;
  auto* scroom = static_cast<GtkWidget*>(user_data);
 
  logger->debug("Creating the open dialog");
  dialog = gtk_file_chooser_dialog_new(
    "Open File",
    GTK_WINDOW(scroom),
    GTK_FILE_CHOOSER_ACTION_OPEN,
    ("_Cancel"),
    GTK_RESPONSE_CANCEL,
    ("_Open"),
    GTK_RESPONSE_ACCEPT,
    NULL
  );
  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), currentFolder.c_str());
 
  const auto pm = PluginManager::getInstance();
  const auto& openInterfaces = pm->getOpenInterfaces();
  const auto& openPresentationInterfaces = pm->getOpenPresentationInterfaces();
 
  // Store all the file filters so that we can create a custom file filter that allows any supported type (by default)
  std::vector<GtkFileFilter*> filters;
  GtkFileFilter* allSupportedFileTypesFilter = gtk_file_filter_new();
  gtk_file_filter_set_name(allSupportedFileTypesFilter, "Any supported file type");
 
  // Cannot beforehand determine which data might be needed for the plugins, so we ask GTK to load everything!
  auto filterFlags = static_cast<GtkFileFilterFlags>(
    GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_MIME_TYPE | GTK_FILE_FILTER_DISPLAY_NAME | GTK_FILE_FILTER_URI
  );
 
  gtk_file_filter_add_custom(allSupportedFileTypesFilter, filterFlags, &combinedFileFilter, &filters, nullptr);
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), allSupportedFileTypesFilter);
 
  for(auto const& cur: openPresentationInterfaces)
  {
    for(auto const& f: cur.first->getFilters())
    {
      gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), f);
      filters.push_back(f);
    }
  }
  for(auto const& cur: openInterfaces)
  {
    for(auto const& f: cur.first->getFilters())
    {
      gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(dialog), f);
      filters.push_back(f);
    }
  }
 
  if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
  {
    GFile* file = g_file_new_for_path(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)));
    GFileInfo* fileInfo = g_file_query_info(file, "standard::*", G_FILE_QUERY_INFO_NONE, nullptr, nullptr);
    GtkFileFilterInfo filterInfo;
    filterInfo.filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
    filterInfo.mime_type = g_content_type_get_mime_type(g_file_info_get_content_type(fileInfo));
    filterInfo.display_name = g_file_info_get_display_name(fileInfo);
    filterInfo.contains =
      static_cast<GtkFileFilterFlags>(GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_DISPLAY_NAME | GTK_FILE_FILTER_MIME_TYPE);
    logger->debug("Opening file {}", filterInfo.filename);
 
    try
    {
      load(filterInfo);
    }
    catch(std::exception& ex)
    {
      logger->error(ex.what());
      on_presentation_possibly_destroyed();
    }
  }
  gchar* cf = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
  if(cf)
  {
    currentFolder = cf;
    g_free(cf);
  }
  gtk_widget_destroy(dialog);
}

Referenced by create_scroom().

Here is the call graph for this function:

Here is the caller graph for this function:

on_paste_activate()

void on_paste_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{}

on_presentation_added_to_view()

void on_presentation_added_to_view

(

const View::Ptr &

v

)

{
  const std::map<ViewObserver::Ptr, std::string>& viewObservers = PluginManager::getInstance()->getViewObservers();
 
  auto cur = viewObservers.begin();
  auto end = viewObservers.end();
  for(; cur != end; cur++)
  {
    views[v].add(cur->first->viewAdded(v));
  }
}

Referenced by create_scroom(), and find_or_create_scroom().

Here is the call graph for this function:

Here is the caller graph for this function:

on_presentation_created()

void on_presentation_created

(

const PresentationInterface::Ptr &

p

)

{
  presentations.emplace_back(presentation);
 
  for(const Views::value_type& p: views)
  {
    p.first->on_presentation_created(presentation);
  }
 
  const std::map<PresentationObserver::Ptr, std::string>& presentationObservers =
    PluginManager::getInstance()->getPresentationObservers();
 
  auto cur = presentationObservers.begin();
  auto end = presentationObservers.end();
  for(; cur != end; cur++)
  {
    cur->first->presentationAdded(presentation);
  }
}

Referenced by create(), load(), loadPresentation(), ScroomInterfaceImpl::newAggregate(), ScroomInterfaceImpl::newPresentation(), on_done_loading_plugins(), and ScroomInterfaceImpl::showPresentation().

Here is the call graph for this function:

Here is the caller graph for this function:

on_presentation_possibly_destroyed()

void on_presentation_possibly_destroyed

(

)

{
  bool presentationDestroyed = false;
 
  for(auto cur = presentations.begin(); cur != presentations.end(); cur++)
  {
    PresentationInterface::Ptr const p = cur->lock();
    if(!p)
    {
      presentationDestroyed = true;
      auto temp = cur;
      temp--;
      presentations.erase(cur);
      cur = temp;
    }
  }
  if(presentationDestroyed)
  {
    for(auto const& p: views)
    {
      p.first->on_presentation_destroyed();
    }
 
    const std::map<PresentationObserver::Ptr, std::string>& presentationObservers =
      PluginManager::getInstance()->getPresentationObservers();
 
    for(auto const& p: presentationObservers)
    {
      p.first->presentationDeleted();
    }
  }
}

Referenced by on_done_loading_plugins(), on_open_activate(), and on_view_destroyed().

Here is the call graph for this function:

Here is the caller graph for this function:

on_quit_activate()

void on_quit_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{
  Views const v(views);
  for(const Views::value_type& p: v)
  {
    p.first->hide();
  }
  gtk_main_quit();
}

Referenced by create_scroom().

Here is the caller graph for this function:

on_save_activate()

void on_save_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{}

on_save_as_activate()

void on_save_as_activate	(	GtkMenuItem *	menuitem,
		gpointer	user_data
	)

{}

on_scrollbar_value_changed()

void on_scrollbar_value_changed	(	GtkAdjustment *	adjustment,
		gpointer	user_data
	)

{
  View* view = static_cast<View*>(user_data);
  view->on_scrollbar_value_changed(adjustment);
}

Referenced by create_scroom().

Here is the call graph for this function:

Here is the caller graph for this function:

on_scroom_bootstrap()

void on_scroom_bootstrap

(

const FileNameMap &

newFilenames

)

{
  logger->info("Bootstrapping Scroom...");
  filenames = newFilenames;
  currentFolder = ".";
 
  const bool devMode = in_devmode();
  if(devMode)
  {
    logger->info("+----------------------------------------------------------------------+");
    logger->info("| ENTERING DEVELOPMENT MODE                                            |");
    logger->info("| All the default directories are not searched                         |");
    logger->info("| Instead, only environment variables and the local source tree        |");
    logger->info("| are consulted.                                                       |");
    logger->info("+----------------------------------------------------------------------+");
  }
 
  startPluginManager(devMode);
 
  if(devMode)
  {
    xmlFileName = TOP_SRCDIR "/gui/scroom.glade";
  }
  else
  {
#ifdef _WIN32
    // We want to keep everything portable on windows so we look for the .glade file in the same directory as the .exe
    xmlFileName = (boost::dll::program_location().parent_path() / "scroom.glade").generic_string();
#else
    xmlFileName = PACKAGE_DATA_DIR "/scroom.glade";
#endif
  }
 
  aboutDialogXml = gtk_builder_new();
  boost::scoped_array<gchar*> const obj{new gchar*[2]};
  const std::string str = "aboutDialog";
  obj[0] = const_cast<char*>(str.c_str());
  obj[1] = nullptr;
  gtk_builder_add_objects_from_file(aboutDialogXml, xmlFileName.c_str(), obj.get(), nullptr);
 
  if(aboutDialogXml != nullptr)
  {
    aboutDialog = GTK_WIDGET(gtk_builder_get_object(aboutDialogXml, "aboutDialog"));
    gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(aboutDialog), "Scroom");
    gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(aboutDialog), PACKAGE_VERSION);
#ifdef _WIN32
    g_signal_connect(G_OBJECT(aboutDialog), "activate-link", G_CALLBACK(on_open_scroom_website), NULL);
#endif
  }
  else
  {
    logger->error("Opening xml failed");
    exit(-1); // NOLINT(concurrency-mt-unsafe)
  }
 
  if(filenames.empty())
  {
    create_scroom(PresentationInterface::Ptr());
  }
}

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

on_scroom_hide()

void on_scroom_hide	(	GtkWidget *	widget,
		gpointer	user_data
	)

{
  View* view = static_cast<View*>(user_data);
  on_view_destroyed(view);
 
  if(views.empty())
  {
    gtk_main_quit();
  }
}

Referenced by create_scroom().

Here is the call graph for this function:

Here is the caller graph for this function:

on_scroom_terminating()

void on_scroom_terminating

(

)

{ ensure(views.empty()); }

Referenced by main().

Here is the caller graph for this function:

on_textbox_value_changed()

void on_textbox_value_changed	(	GtkEditable *	editable,
		gpointer	user_data
	)

{
  View* view = static_cast<View*>(user_data);
  view->on_textbox_value_changed(editable);
}

Referenced by create_scroom().

Here is the call graph for this function:

Here is the caller graph for this function:

on_view_created()

void on_view_created

(

const View::Ptr &

v

)

{
  Scroom::Bookkeeping::Token const t;
  views[v] = t;
 
  for(auto& presentation: presentations)
  {
    PresentationInterface::Ptr const p = presentation.lock();
    if(p)
    {
      v->on_presentation_created(p);
    }
  }
}

Referenced by create_scroom().

Here is the caller graph for this function:

on_view_destroyed()

void on_view_destroyed

(

View *

v

)

{
  View::Ptr view = v->shared_from_this<View>();
  view->clearPresentation();
 
  views.erase(view);
  view.reset();
 
  on_presentation_possibly_destroyed();
}

Referenced by on_scroom_hide().

Here is the call graph for this function:

Here is the caller graph for this function:

on_zoombox_changed()

void on_zoombox_changed	(	GtkComboBox *	widget,
		gpointer	user_data
	)

{
  View* view = static_cast<View*>(user_data);
  view->on_zoombox_changed();
}

Referenced by create_scroom().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

REGULAR_FILES

const std::string REGULAR_FILES

extern

Referenced by main(), and on_done_loading_plugins().