View Class Reference

#include <view.hh>

Inheritance diagram for View:

Collaboration diagram for View:

Public Types
using	Ptr = std::shared_ptr< View >
Public Types inherited from ViewInterface
using	Ptr = std::shared_ptr< ViewInterface >
using	WeakPtr = std::weak_ptr< ViewInterface >

Public Member Functions
	~View () override
	View (const View &)=delete
	View (View &&)=delete
View	operator= (const View &)=delete
View	operator= (View &&)=delete
void	redraw (cairo_t *cr)
void	hide ()
bool	hasPresentation ()
void	setPresentation (PresentationInterface::Ptr presentation)
void	clearPresentation ()
void	updateScrollbars ()
void	updateZoom ()
void	updateRulers ()
void	updateTextbox ()
void	toolButtonToggled (GtkToggleButton *button)
void	on_newPresentationInterfaces_update (const std::map< NewPresentationInterface::Ptr, std::string > &newPresentationInterfaces)
void	on_presentation_created (const PresentationInterface::Ptr &p)
void	on_presentation_destroyed ()
void	on_configure ()
void	on_window_size_changed (const Scroom::Utils::Point< int > &newSize)
void	on_zoombox_changed ()
void	on_textbox_value_changed (GtkEditable *editable)
void	on_scrollbar_value_changed (GtkAdjustment *adjustment)
void	on_scrollwheel (GdkEventScroll *event)
void	on_buttonPress (GdkEventButton *event)
void	on_buttonRelease (GdkEventButton *event)
void	on_motion_notify (GdkEventMotion *event)
void	setFullScreen ()
void	unsetFullScreen ()
void	invalidate () override
ProgressInterface::Ptr	getProgressInterface () override
void	addSideWidget (std::string title, GtkWidget *w) override
void	removeSideWidget (GtkWidget *w) override
void	addToToolbar (GtkToolItem *ti) override
void	removeFromToolbar (GtkToolItem *ti) override
void	registerSelectionListener (SelectionListener::Ptr listener) override
void	registerPostRenderer (PostRenderer::Ptr renderer) override
void	setStatusMessage (const std::string &message) override
PresentationInterface::Ptr	getCurrentPresentation () override
void	addToolButton (GtkToggleButton *, ToolStateListener::Ptr) override
Public Member Functions inherited from Scroom::Utils::Base
	Base ()=default
	Base (const Base &)=delete
	Base (Base &&)=delete
Base &	operator= (const Base &)=delete
Base &	operator= (Base &&)=delete
virtual	~Base ()=default
template<typename R >
std::shared_ptr< R >	shared_from_this ()
template<typename R >
std::shared_ptr< R const >	shared_from_this () const

Static Public Member Functions
static Ptr	create (GtkBuilder *scroomXml, const PresentationInterface::Ptr &presentation)
static void	updateScrollbar (GtkAdjustment *adj, int zoom, double value, double presentationStart, double presentationSize, double windowSize)

Private Types
enum	LocationChangeCause { SCROLLBAR , TEXTBOX , OTHER }

Private Member Functions
	View (GtkBuilder *scroomXml)
void	updateTweaks ()
Scroom::Utils::Point< double >	windowPointToPresentationPoint (Scroom::Utils::Point< double > wp) const
Scroom::Utils::Point< double >	presentationPointToWindowPoint (Scroom::Utils::Point< double > presentationpoint) const
Scroom::Utils::Point< double >	tweakedPosition () const
void	updateNewWindowMenu ()
void	on_zoombox_changed (int newzoom, const Scroom::Utils::Point< double > &mousePos)
void	updateXY (const Scroom::Utils::Point< double > &newPos, const LocationChangeCause &source)

Private Attributes
GtkBuilder *	scroomXml
PresentationInterface::Ptr	presentation
SidebarManager	sidebarManager
GtkWindow *	window
GtkWidget *	menubar
GtkWidget *	drawingArea
Scroom::Utils::Point< int >	drawingAreaSize
Scroom::Utils::Rectangle< double >	presentationRect
GtkScrollbar *	vscrollbar
GtkScrollbar *	hscrollbar
GtkAdjustment *	vscrollbaradjustment
GtkAdjustment *	hscrollbaradjustment
GtkDrawingArea *	hruler_area
GtkDrawingArea *	vruler_area
Ruler::Ptr	vruler
Ruler::Ptr	hruler
GtkComboBox *	zoomBox
GtkListStore *	zoomItems
GtkProgressBar *	progressBar
GtkStatusbar *	statusBar
GtkToolbar *	toolBar
GtkToolItem *	toolBarSeparator
GtkEntry *	xTextBox
GtkEntry *	yTextBox
GtkWidget *	statusArea
GtkWidget *	toolbarArea
unsigned	toolBarCount
int	statusBarContextId
int	zoom {0}
Freezable< Scroom::Utils::Point< double > >	position
std::optional< Selection >	selection
std::vector< SelectionListener::Ptr >	selectionListeners
std::vector< PostRenderer::Ptr >	postRenderers
std::map< GtkToggleButton *, ToolStateListener::Ptr >	tools
std::shared_ptr< Scroom::Utils::ITweakPresentationPosition >	tweakPresentationPosition
std::shared_ptr< Scroom::Utils::ITweakPositionTextBox >	tweakPositionTextBox
std::shared_ptr< Scroom::Utils::ITweakRulers >	tweakRulers
Scroom::Utils::ITweakSelection::Map	tweakSelection
gint	modifiermove {0}
Scroom::Utils::Point< double >	cachedPoint
ProgressBarManager::Ptr	progressBarManager
Scroom::Utils::WeakKeyMap< PresentationInterface::WeakPtr, GtkWidget * >	presentations
Scroom::Logger	logger

Member Typedef Documentation

Ptr

using View::Ptr = std::shared_ptr<View>

Member Enumeration Documentation

LocationChangeCause

enum View::LocationChangeCause

private

Enumerator
SCROLLBAR
TEXTBOX
OTHER

  {
    SCROLLBAR,
    TEXTBOX,
    OTHER
  };

Constructor & Destructor Documentation

View() [1/3]

View::View ( GtkBuilder *  scroomXml )

explicitprivate

  : scroomXml(scroomXml_)
  , tweakPresentationPosition(Scroom::Utils::getDefaultTweakPresentationPosition())
  , tweakPositionTextBox(Scroom::Utils::getDefaultTweakPositionTextBox())
  , tweakRulers(Scroom::Utils::getDefaultTweakRulers())
  , tweakSelection(Scroom::Utils::getDefaultTweakSelectionMap())
{
  PluginManager::Ptr const pluginManager = PluginManager::getInstance();
  window = GTK_WINDOW(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "scroom")));
  drawingArea = GTK_WIDGET(gtk_builder_get_object(scroomXml_, "drawingarea"));
  vscrollbar = GTK_SCROLLBAR(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "vscrollbar")));
  hscrollbar = GTK_SCROLLBAR(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "hscrollbar")));
  vscrollbaradjustment = gtk_range_get_adjustment(GTK_RANGE(vscrollbar));
  hscrollbaradjustment = gtk_range_get_adjustment(GTK_RANGE(hscrollbar));
  vruler_area = GTK_DRAWING_AREA(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "vruler_area")));
  hruler_area = GTK_DRAWING_AREA(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "hruler_area")));
  xTextBox = GTK_ENTRY(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "x_textbox")));
  yTextBox = GTK_ENTRY(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "y_textbox")));
 
  // Create rulers and attach ruler areas to them
  vruler = Ruler::create(Ruler::VERTICAL, GTK_WIDGET(vruler_area));
  hruler = Ruler::create(Ruler::HORIZONTAL, GTK_WIDGET(hruler_area));
 
  menubar = GTK_WIDGET(gtk_builder_get_object(scroomXml_, "menubar"));
  statusArea = GTK_WIDGET(gtk_builder_get_object(scroomXml_, "status_area"));
  toolbarArea = GTK_WIDGET(gtk_builder_get_object(scroomXml_, "toolbar_area"));
 
  zoomBox = GTK_COMBO_BOX(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "zoomboxcombo")));
  zoomItems = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_INT);
 
  gtk_combo_box_set_model(zoomBox, GTK_TREE_MODEL(zoomItems));
  GtkCellRenderer* txt = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
  gtk_cell_layout_pack_end(GTK_CELL_LAYOUT(zoomBox), txt, true);
  gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(zoomBox), txt, "text", COLUMN_TEXT, NULL);
 
  progressBar = GTK_PROGRESS_BAR(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "progressbar")));
  progressBarManager = ProgressBarManager::create(progressBar);
  statusBar = GTK_STATUSBAR(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "statusbar")));
  statusBarContextId = gtk_statusbar_get_context_id(statusBar, "View");
 
  GtkWidget* panelWindow = GTK_WIDGET(gtk_builder_get_object(scroomXml_, "panelWindow"));
  GtkBox* panel = GTK_BOX(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "panel")));
  sidebarManager.setWidgets(panelWindow, panel);
  toolBar = GTK_TOOLBAR(GTK_WIDGET(gtk_builder_get_object(scroomXml_, "toolbar")));
  toolBarSeparator = nullptr;
  toolBarCount = 0;
 
  on_newPresentationInterfaces_update(pluginManager->getNewPresentationInterfaces());
  updateNewWindowMenu();
  on_configure();
}

Here is the call graph for this function:

~View()

View::~View ( )

override

{
  logger->debug("Destroying view...");
  gtk_widget_destroy(GTK_WIDGET(window));
}

View() [2/3]

View::View ( const View &  )

delete

View() [3/3]

View::View ( View &&  )

delete

Member Function Documentation

addSideWidget()

void View::addSideWidget ( std::string  title, GtkWidget *  w  )

overridevirtual

Request that the given widget be added to the sidebar.

Precondition

Should be called from within a Gdk critical section (i.e. between gdk_threads_enter() and gdk_threads_leave() calls)

Implements ViewInterface.

{ sidebarManager.addSideWidget(title, w); }

Here is the call graph for this function:

addToolButton()

void View::addToolButton ( GtkToggleButton *  , ToolStateListener::Ptr    )

overridevirtual

Adds a new tool button to the toolbar. The given ToolStateListener will be informed when the tool is turned on or off. Only one tool will be active at the same time.

See also

ToolStateListener

Implements ViewInterface.

{
  Scroom::GtkHelpers::sync_on_ui_thread(
    [=, this]
    {
      GtkToolItem* toolItem = gtk_tool_item_new();
      gtk_container_add(GTK_CONTAINER(toolItem), GTK_WIDGET(button));
      gtk_widget_set_visible(GTK_WIDGET(button), true);
      g_signal_connect(static_cast<gpointer>(button), "toggled", G_CALLBACK(tool_button_toggled), this);
 
      addToToolbar(toolItem);
 
      tools[button] = callback;
      if(tools.size() == 1)
      {
        gtk_toggle_button_set_active(button, true);
        gtk_widget_set_sensitive(GTK_WIDGET(button), false);
        callback->onEnable();
      }
      else
      {
        gtk_toggle_button_set_active(button, false);
        gtk_widget_set_sensitive(GTK_WIDGET(button), true);
      }
    }
  );
}

Here is the call graph for this function:

addToToolbar()

void View::addToToolbar ( GtkToolItem *  ti )

overridevirtual

Request that the given tool item be added to the toolbar.

Precondition

Should be called from within a Gdk critical section (i.e. between gdk_threads_enter() and gdk_threads_leave() calls)

Implements ViewInterface.

{
  if(toolBarCount == 0)
  {
    toolBarSeparator = gtk_separator_tool_item_new();
    g_object_set(G_OBJECT(toolBarSeparator), "visible", true, "draw", true, NULL);
    gtk_toolbar_insert(toolBar, toolBarSeparator, -1);
  }
 
  g_object_set(G_OBJECT(ti), "visible", true, NULL);
 
  gtk_toolbar_insert(toolBar, ti, -1);
  toolBarCount++;
}

Referenced by addToolButton().

Here is the caller graph for this function:

clearPresentation()

void View::clearPresentation

(

)

{
  setPresentation(PresentationInterface::Ptr()); // null
}

Referenced by on_view_destroyed().

Here is the call graph for this function:

Here is the caller graph for this function:

create()

View::Ptr View::create ( GtkBuilder *  scroomXml, const PresentationInterface::Ptr &  presentation  )

static

{
  Ptr view(new View(scroomXml));
  view->logger->debug("Creating a new view");
 
  if(presentation)
  {
    view->setPresentation(presentation);
  }
 
  return view;
}

Referenced by create_scroom().

Here is the caller graph for this function:

getCurrentPresentation()

PresentationInterface::Ptr View::getCurrentPresentation ( )

overridevirtual

Returns a shared pointer to the current presentation.

See also

PresentationInterface

Implements ViewInterface.

{ return presentation; }

getProgressInterface()

ProgressInterface::Ptr View::getProgressInterface ( )

overridevirtual

Return a pointer to the progess interface associated with the View

Note

The progress bar should only be manipulated from within a Gdk critical section (i.e. between gdk_threads_enter() and gdk_threads_leave() calls)

Implements ViewInterface.

{ return progressBarManager; }

hasPresentation()

bool View::hasPresentation

(

)

{ return presentation != nullptr; }

hide()

void View::hide

(

)

{ gtk_widget_hide(GTK_WIDGET(window)); }

Referenced by on_close_activate().

Here is the caller graph for this function:

invalidate()

void View::invalidate ( )

overridevirtual

Request that the window content is redrawn.

Precondition

Should be called from within a Gdk critical section (i.e. between gdk_threads_enter() and gdk_threads_leave() calls)

Implements ViewInterface.

{ gdk_window_invalidate_rect(gtk_widget_get_window(drawingArea), nullptr, false); }

Referenced by on_buttonRelease(), on_motion_notify(), on_window_size_changed(), on_zoombox_changed(), setPresentation(), and updateXY().

Here is the caller graph for this function:

on_buttonPress()

void View::on_buttonPress

(

GdkEventButton *

event

)

{
  if(event->button == 1 && modifiermove == 0)
  {
    // Begin left-dragging
    modifiermove = GDK_BUTTON1_MASK;
    cachedPoint = eventToPoint(event);
  }
  else if(event->button == 3)
  {
    auto point = windowPointToPresentationPoint(eventToPoint(event));
    selection = point;
    for(const auto& listener: selectionListeners)
    {
      auto f = tweakSelection.find(listener->getSelectionType());
      auto tweaker = f == tweakSelection.end() ? tweakSelection.at(SelectionType::DEFAULT) : f->second;
      const auto tweakedSelection = tweaker->tweakSelection(*selection);
      listener->onSelectionStart(tweakedSelection, shared_from_this<ViewInterface>());
    }
  }
}

Referenced by on_button_press_event().

Here is the call graph for this function:

Here is the caller graph for this function:

on_buttonRelease()

void View::on_buttonRelease

(

GdkEventButton *

event

)

{
  if(event->button == 1 && modifiermove == GDK_BUTTON1_MASK)
  {
    // End left-dragging
    modifiermove = 0;
    cachedPoint.x = 0;
    cachedPoint.y = 0;
  }
  else if(event->button == 3 && selection)
  {
    selection->end = windowPointToPresentationPoint(eventToPoint(event));
    for(const auto& listener: selectionListeners)
    {
      auto f = tweakSelection.find(listener->getSelectionType());
      auto tweaker = f == tweakSelection.end() ? tweakSelection.at(SelectionType::DEFAULT) : f->second;
      const auto tweakedSelection = tweaker->tweakSelection(*selection);
      listener->onSelectionEnd(tweakedSelection, shared_from_this<ViewInterface>());
    }
    invalidate();
  }
}

Referenced by on_button_release_event().

Here is the call graph for this function:

Here is the caller graph for this function:

on_configure()

void View::on_configure

(

)

{
  // There should be a simpler way to do this...
  cairo_region_t* r = gdk_window_get_visible_region(gtk_widget_get_window(drawingArea));
  cairo_rectangle_int_t rect;
  cairo_region_get_extents(r, &rect);
 
  Scroom::Utils::Point<int> const newSize(rect.width, rect.height);
 
  if(drawingAreaSize != newSize)
  {
    on_window_size_changed(newSize);
  }
 
  cairo_region_destroy(r);
}

Referenced by on_drawingarea_configure_event(), and View().

Here is the call graph for this function:

Here is the caller graph for this function:

on_motion_notify()

void View::on_motion_notify

(

GdkEventMotion *

event

)

{
  if((event->state & GDK_BUTTON1_MASK) && modifiermove == GDK_BUTTON1_MASK)
  {
    auto mousePos = eventToPoint(event);
 
    const auto pixelSize = pixelSizeFromZoom(zoom);
    const auto newPos = position - (mousePos - cachedPoint) / pixelSize;
    cachedPoint = mousePos;
 
    updateXY(newPos, OTHER);
  }
  else if((event->state & GDK_BUTTON3_MASK) && selection)
  {
    selection->end = windowPointToPresentationPoint(eventToPoint(event));
    for(const auto& listener: selectionListeners)
    {
      auto f = tweakSelection.find(listener->getSelectionType());
      auto tweaker = f == tweakSelection.end() ? tweakSelection.at(SelectionType::DEFAULT) : f->second;
      const auto tweakedSelection = tweaker->tweakSelection(*selection);
      listener->onSelectionUpdate(tweakedSelection, shared_from_this<ViewInterface>());
    }
    invalidate();
  }
}

Referenced by on_motion_notify_event().

Here is the call graph for this function:

Here is the caller graph for this function:

on_newPresentationInterfaces_update()

void View::on_newPresentationInterfaces_update

(

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

newPresentationInterfaces

)

{
  GtkWidget* new_menu_item = GTK_WIDGET(gtk_builder_get_object(scroomXml, "new"));
 
  if(newPresentationInterfaces.empty())
  {
    gtk_widget_set_sensitive(new_menu_item, false);
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(new_menu_item), nullptr);
  }
  else
  {
    gtk_widget_set_sensitive(new_menu_item, true);
 
    GtkWidget* new_menu = gtk_menu_new();
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(new_menu_item), new_menu);
 
    for(auto cur = newPresentationInterfaces.begin(); cur != newPresentationInterfaces.end(); cur++)
    {
      GtkWidget* menu_item = gtk_menu_item_new_with_label(cur->second.c_str());
      gtk_widget_show(menu_item);
      gtk_container_add(GTK_CONTAINER(new_menu), menu_item);
 
      g_signal_connect(static_cast<gpointer>(menu_item), "activate", G_CALLBACK(on_new_activate), cur->first.get());
    }
  }
}

Referenced by View().

Here is the call graph for this function:

Here is the caller graph for this function:

on_presentation_created()

void View::on_presentation_created

(

const PresentationInterface::Ptr &

p

)

{
  presentations[p] = nullptr;
  updateNewWindowMenu();
}

Here is the call graph for this function:

on_presentation_destroyed()

void View::on_presentation_destroyed

(

)

{ updateNewWindowMenu(); }

Here is the call graph for this function:

on_scrollbar_value_changed()

void View::on_scrollbar_value_changed

(

GtkAdjustment *

adjustment

)

{
  auto newPos = position.get();
 
  if(adjustment == vscrollbaradjustment)
  {
    newPos.y = gtk_adjustment_get_value(adjustment);
  }
  else
  {
    newPos.x = gtk_adjustment_get_value(adjustment);
  }
 
  updateXY(newPos, SCROLLBAR);
}

Referenced by on_scrollbar_value_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

on_scrollwheel()

void View::on_scrollwheel

(

GdkEventScroll *

event

)

{
  if(event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_DOWN)
  {
    int newZoom = zoom + ((event->direction == GDK_SCROLL_UP) ? 1 : -1);
    newZoom = std::min(MaxZoom, newZoom);
 
    GtkTreeIter iter;
    for(
      bool valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(zoomItems), &iter); valid;
      valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(zoomItems), &iter)
    )
    {
      GValue value = G_VALUE_INIT;
      gtk_tree_model_get_value(GTK_TREE_MODEL(zoomItems), &iter, COLUMN_ZOOM, &value);
      const int foundZoom = g_value_get_int(&value);
 
      if(foundZoom == newZoom)
      {
        on_zoombox_changed(newZoom, {event->x, event->y});
        gtk_combo_box_set_active_iter(zoomBox, &iter);
        break;
      }
    }
  }
}

Referenced by on_scroll_event().

Here is the call graph for this function:

Here is the caller graph for this function:

on_textbox_value_changed()

void View::on_textbox_value_changed

(

GtkEditable *

editable

)

{
  try
  {
    auto newPos = tweakPositionTextBox->parse(gtk_entry_get_text(xTextBox), gtk_entry_get_text(yTextBox), drawingAreaSize, zoom);
 
    updateXY(newPos, TEXTBOX);
  }
  catch(boost::bad_lexical_cast& ex)
  {
    // User typed something invalid, probably a letter. Ignore...
  }
}

Referenced by on_textbox_value_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

on_window_size_changed()

void View::on_window_size_changed

(

const Scroom::Utils::Point< int > &

newSize

)

{
  auto pixelSize = pixelSizeFromZoom(zoom);
  position += (drawingAreaSize - newSize) / pixelSize / 2;
 
  std::scoped_lock const protect_position(position);
  drawingAreaSize = newSize;
  updateZoom();
  updateScrollbars();
  invalidate();
}

Referenced by on_configure().

Here is the call graph for this function:

Here is the caller graph for this function:

on_zoombox_changed() [1/2]

void View::on_zoombox_changed

(

)

{
  GtkTreeIter iter;
  GValue value = G_VALUE_INIT;
  gtk_combo_box_get_active_iter(zoomBox, &iter);
 
  if(gtk_list_store_iter_is_valid(zoomItems, &iter))
  {
    gtk_tree_model_get_value(GTK_TREE_MODEL(zoomItems), &iter, COLUMN_ZOOM, &value);
    const int newZoom = g_value_get_int(&value);
    on_zoombox_changed(newZoom, drawingAreaSize.to<double>() / 2);
  }
}

Referenced by on_scrollwheel(), on_zoombox_changed(), and on_zoombox_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

on_zoombox_changed() [2/2]

void View::on_zoombox_changed ( int  newzoom, const Scroom::Utils::Point< double > &  mousePos  )

private

{
  if(newzoom != zoom)
  {
    position += mousePos / pixelSizeFromZoom(zoom);
    position -= mousePos / pixelSizeFromZoom(newzoom);
 
    std::scoped_lock const protect_position(position);
    zoom = newzoom;
    updateScrollbars();
    updateTextbox();
    invalidate();
  }
}

Here is the call graph for this function:

operator=() [1/2]

View View::operator= ( const View &  )

delete

operator=() [2/2]

View View::operator= ( View &&  )

delete

presentationPointToWindowPoint()

Scroom::Utils::Point< double > View::presentationPointToWindowPoint ( Scroom::Utils::Point< double >  presentationpoint ) const

private

{
  return (presentationpoint - tweakedPosition()) * pixelSizeFromZoom(zoom);
}

Here is the call graph for this function:

redraw()

void View::redraw

(

cairo_t *

cr

)

{
  if(presentation)
  {
    const double pixelSize = pixelSizeFromZoom(zoom);
    Scroom::Utils::Point<double> const visibleRegionSize = drawingAreaSize.to<double>() / pixelSize;
 
    auto rect = Scroom::Utils::make_rect(tweakedPosition(), visibleRegionSize);
 
    presentation->redraw(shared_from_this<View>(), cr, rect, zoom);
    for(const auto& renderer: postRenderers)
    {
      renderer->render(shared_from_this<View>(), cr, rect, zoom);
    }
  }
  else
  {
    // A logo here would be nice...
 
    // char buffer[] = "View says \"Hi\"";
    //
    // cairo_move_to(cr, 50, 50);
    // cairo_show_text(cr, buffer);
  }
}

Referenced by on_drawingarea_expose_event().

Here is the call graph for this function:

Here is the caller graph for this function:

registerPostRenderer()

void View::registerPostRenderer ( PostRenderer::Ptr  )

overridevirtual

Register a postrenderer to be updated whenever a redraw occurs. When this happens, the 'render' function gets called on the instance that is passed to the given instance.

Note that the order in which different registered instances get updated is the order in which they register to the view. This order remains constant throughout the view's lifetime.

See also

PostRenderer

Implements ViewInterface.

{ postRenderers.push_back(renderer); }

registerSelectionListener()

void View::registerSelectionListener ( SelectionListener::Ptr  )

overridevirtual

Register a SelectionListener to be updated whenever the user selects a region . When the user changes the selection, various functions on the given instance are called.

See also

SelectionListener

Implements ViewInterface.

{ selectionListeners.push_back(listener); }

removeFromToolbar()

void View::removeFromToolbar ( GtkToolItem *  ti )

overridevirtual

Request that the given tool item be removed from the toolbar.

Precondition

Should be called from within a Gdk critical section (i.e. between gdk_threads_enter() and gdk_threads_leave() calls)

Implements ViewInterface.

{
  gtk_container_remove(GTK_CONTAINER(toolBar), GTK_WIDGET(ti));
  toolBarCount--;
 
  if(toolBarCount == 0)
  {
    gtk_container_remove(GTK_CONTAINER(toolBar), GTK_WIDGET(toolBarSeparator));
    toolBarSeparator = nullptr;
  }
}

removeSideWidget()

void View::removeSideWidget ( GtkWidget *  w )

overridevirtual

Request that the given widget be removed from the sidebar.

Precondition

Should be called from within a Gdk critical section (i.e. between gdk_threads_enter() and gdk_threads_leave() calls)

Implements ViewInterface.

{ sidebarManager.removeSideWidget(w); }

Here is the call graph for this function:

setFullScreen()

void View::setFullScreen

(

)

{
  gtk_window_fullscreen(window);
  gtk_widget_set_visible(toolbarArea, false);
  gtk_widget_set_visible(statusArea, false);
}

setPresentation()

void View::setPresentation

(

PresentationInterface::Ptr

presentation

)

{
  View::Ptr const me = shared_from_this<View>();
 
  if(presentation)
  {
    presentation->close(me);
    presentation.reset();
  }
 
  presentation = std::move(presentation_);
 
  if(presentation)
  {
    presentation->open(me);
    presentationRect = presentation->getRect();
    std::string s = presentation->getTitle();
 
    updateTweaks();
 
    if(!s.empty())
    {
      s = "Scroom - " + s;
    }
    else
    {
      s = "Scroom";
    }
    gtk_window_set_title(window, s.c_str());
  }
 
  zoom = 0;
  const double pixelSize = pixelSizeFromZoom(zoom);
  position = -drawingAreaSize.to<double>() / pixelSize / 2;
 
  updateZoom();
  updateScrollbars();
  updateTextbox();
  invalidate();
}

Referenced by clearPresentation().

Here is the call graph for this function:

Here is the caller graph for this function:

setStatusMessage()

void View::setStatusMessage ( const std::string &  )

overridevirtual

Sets the status message in the status bar of the application.

Implements ViewInterface.

{
  gtk_statusbar_pop(statusBar, statusBarContextId);
  gtk_statusbar_push(statusBar, statusBarContextId, message.c_str());
}

toolButtonToggled()

void View::toolButtonToggled

(

GtkToggleButton *

button

)

{
  if(gtk_toggle_button_get_active(button))
  {
    for(const auto& tool: tools)
    {
      if(tool.first != button && gtk_toggle_button_get_active(tool.first))
      {
        gtk_toggle_button_set_active(tool.first, false);
        gtk_widget_set_sensitive(GTK_WIDGET(tool.first), true);
        tools[tool.first]->onDisable();
      }
    }
    gtk_widget_set_sensitive(GTK_WIDGET(button), false);
    tools[button]->onEnable();
  }
}

tweakedPosition()

Scroom::Utils::Point< double > View::tweakedPosition ( ) const

private

{
  return tweakPresentationPosition->tweakPosition(position, drawingAreaSize, zoom);
}

Referenced by presentationPointToWindowPoint(), redraw(), updateRulers(), and windowPointToPresentationPoint().

Here is the caller graph for this function:

unsetFullScreen()

void View::unsetFullScreen

(

)

{
  gtk_window_unfullscreen(window);
  gtk_widget_set_visible(toolbarArea, true);
  gtk_widget_set_visible(statusArea, true);
}

updateNewWindowMenu()

void View::updateNewWindowMenu ( )

private

{
  GtkWidget* newWindow_menu_item = GTK_WIDGET(gtk_builder_get_object(scroomXml, "newWindow"));
 
  GtkWidget* newWindow_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(newWindow_menu_item));
  if(!newWindow_menu)
  {
    newWindow_menu = gtk_menu_new();
  }
  g_object_ref_sink(G_OBJECT(newWindow_menu));
 
  auto cur = presentations.begin();
  auto end = presentations.end();
 
  while(cur != end)
  {
    auto next = cur;
    next++;
 
    PresentationInterface::Ptr const p = cur->first.lock();
    GtkWidget* m = cur->second;
    if(p && m)
    {
      // Do nothing
    }
    else if(p && !m)
    {
      // Add a menu item
      std::string s = p->getTitle();
      if(s.empty())
      {
        s = "Default";
      }
      m = gtk_menu_item_new_with_label(s.c_str());
      gtk_widget_show(m);
      cur->second = m;
      gtk_container_add(GTK_CONTAINER(newWindow_menu), m);
 
      g_signal_connect(
        static_cast<gpointer>(m),
        "activate",
        G_CALLBACK(on_newWindow_activate),
        const_cast<PresentationInterface::WeakPtr*>(&cur->first)
      );
    }
    else if(!p && m)
    {
      // Remove menu item, then remove this element from the map
      cur->second = nullptr;
      gtk_widget_destroy(m);
      presentations.erase(cur);
    }
    else if(!p && !m)
    {
      // Remove this element from the map (menu already gone)
      presentations.erase(cur);
    }
    else
    {
      // This cannot happen
      defect();
    }
 
    cur = next;
  }
 
  if(presentations.empty())
  {
    gtk_widget_set_sensitive(newWindow_menu_item, false);
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(newWindow_menu_item), nullptr);
  }
  else
  {
    gtk_widget_set_sensitive(newWindow_menu_item, true);
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(newWindow_menu_item), newWindow_menu);
  }
 
  g_object_unref(G_OBJECT(newWindow_menu));
}

Referenced by on_presentation_created(), on_presentation_destroyed(), and View().

Here is the caller graph for this function:

updateRulers()

void View::updateRulers

(

)

{
  auto visible = tweakRulers->tweakRulers(tweakedPosition(), drawingAreaSize, zoom);
 
  const auto topLeft = visible.getTopLeft();
  const auto bottomRight = visible.getBottomRight();
 
  hruler->setRange(topLeft.x, bottomRight.x);
  vruler->setRange(topLeft.y, bottomRight.y);
}

Referenced by updateScrollbars(), and updateXY().

Here is the call graph for this function:

Here is the caller graph for this function:

updateScrollbar()

void View::updateScrollbar ( GtkAdjustment *  adj, int  zoom, double  value, double  presentationStart, double  presentationSize, double  windowSize  )

static

{
  const double pixelSize = pixelSizeFromZoom(zoom_);
 
  presentationStart -= windowSize / pixelSize / 2;
  presentationSize += windowSize / pixelSize;
 
  gtk_adjustment_configure(
    adj,
    value,
    presentationStart,
    presentationStart + presentationSize,
    1 / pixelSize / 2,
    3 * windowSize / pixelSize / 4,
    windowSize / pixelSize
  );
}

Referenced by updateScrollbars().

Here is the call graph for this function:

Here is the caller graph for this function:

updateScrollbars()

void View::updateScrollbars

(

)

{
  if(presentation)
  {
    gtk_widget_set_sensitive(GTK_WIDGET(vscrollbar), true);
    gtk_widget_set_sensitive(GTK_WIDGET(hscrollbar), true);
 
    updateScrollbar(hscrollbaradjustment, zoom, position->x, presentationRect.x(), presentationRect.width(), drawingAreaSize.x);
    updateScrollbar(vscrollbaradjustment, zoom, position->y, presentationRect.y(), presentationRect.height(), drawingAreaSize.y);
    updateRulers();
  }
  else
  {
    gtk_widget_set_sensitive(GTK_WIDGET(vscrollbar), false);
    gtk_widget_set_sensitive(GTK_WIDGET(hscrollbar), false);
  }
}

Referenced by on_window_size_changed(), on_zoombox_changed(), setPresentation(), and updateXY().

Here is the call graph for this function:

Here is the caller graph for this function:

updateTextbox()

void View::updateTextbox

(

)

{
  if(presentation)
  {
    gtk_widget_set_sensitive(GTK_WIDGET(xTextBox), true);
    gtk_widget_set_sensitive(GTK_WIDGET(yTextBox), true);
 
    const auto [xs, ys] = tweakPositionTextBox->display(position, drawingAreaSize, zoom);
 
    gtk_entry_set_text(xTextBox, xs.c_str());
    gtk_entry_set_text(yTextBox, ys.c_str());
  }
  else
  {
    gtk_widget_set_sensitive(GTK_WIDGET(xTextBox), false);
    gtk_widget_set_sensitive(GTK_WIDGET(yTextBox), false);
  }
}

Referenced by on_zoombox_changed(), setPresentation(), and updateXY().

Here is the caller graph for this function:

updateTweaks()

void View::updateTweaks ( )

private

{
  using namespace Scroom::Utils;
 
  auto context = presentation->getContext();
 
  tweakPresentationPosition = get_or<ITweakPresentationPosition::Ptr>(context, getDefaultTweakPresentationPosition());
  tweakRulers = get_or<ITweakRulers::Ptr>(context, getDefaultTweakRulers());
  tweakPositionTextBox = get_or<ITweakPositionTextBox::Ptr>(context, getDefaultTweakPositionTextBox());
  tweakSelection = get_or<ITweakSelection::Map>(context, getDefaultTweakSelectionMap());
}

Referenced by setPresentation().

Here is the caller graph for this function:

updateXY()

void View::updateXY ( const Scroom::Utils::Point< double > &  newPos, const LocationChangeCause &  source  )

private

{
  if(position.get() != newPos)
  {
    position = newPos;
 
    std::scoped_lock const protect_position(position);
    if(source != SCROLLBAR)
    {
      updateScrollbars();
    }
    else
    {
      updateRulers();
    }
 
    if(source != TEXTBOX)
    {
      updateTextbox();
    }
 
    invalidate();
  }
}

Referenced by on_motion_notify(), on_scrollbar_value_changed(), and on_textbox_value_changed().

Here is the call graph for this function:

Here is the caller graph for this function:

updateZoom()

void View::updateZoom

(

)

{
  if(presentation)
  {
    int presentationHeight = presentationRect.height();
    int presentationWidth = presentationRect.width();
    int minZoom = 0;
 
    while(presentationHeight > drawingAreaSize.y / 2 || presentationWidth > drawingAreaSize.x / 2)
    {
      presentationHeight >>= 1;
      presentationWidth >>= 1;
      minZoom--;
    }
 
    gtk_widget_set_sensitive(GTK_WIDGET(zoomBox), true);
 
    int zMax = MaxZoom - minZoom;
    zMax = std::max(zMax, 1 + MaxZoom - zoom);
    zMax = std::min<size_t>(zMax, sizeof(zoomfactor) / sizeof(zoomfactor[0]));
 
    gtk_list_store_clear(zoomItems);
    for(int z = 0; z < zMax; z++)
    {
      GtkTreeIter iter;
      gtk_list_store_insert_with_values(zoomItems, &iter, z, COLUMN_TEXT, zoomfactor[z], COLUMN_ZOOM, MaxZoom - z, -1);
 
      if(zoom == MaxZoom - z)
      {
        gtk_combo_box_set_active_iter(zoomBox, &iter);
      }
    }
  }
  else
  {
    gtk_widget_set_sensitive(GTK_WIDGET(zoomBox), false);
    gtk_list_store_clear(zoomItems);
    GtkTreeIter iter;
    gtk_list_store_insert_with_values(zoomItems, &iter, 0, COLUMN_TEXT, zoomfactor[0], COLUMN_ZOOM, MaxZoom, -1);
  }
}

Referenced by on_window_size_changed(), and setPresentation().

Here is the call graph for this function:

Here is the caller graph for this function:

windowPointToPresentationPoint()

Scroom::Utils::Point< double > View::windowPointToPresentationPoint ( Scroom::Utils::Point< double >  wp ) const

private

{
  return tweakedPosition() + wp / pixelSizeFromZoom(zoom);
}

Referenced by on_buttonPress(), on_buttonRelease(), and on_motion_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cachedPoint

Scroom::Utils::Point<double> View::cachedPoint

private

Referenced by on_buttonPress(), on_buttonRelease(), and on_motion_notify().

drawingArea

GtkWidget* View::drawingArea

private

Referenced by invalidate(), on_configure(), and View().

drawingAreaSize

Scroom::Utils::Point<int> View::drawingAreaSize

private

Referenced by on_configure(), on_textbox_value_changed(), on_window_size_changed(), on_zoombox_changed(), redraw(), setPresentation(), tweakedPosition(), updateRulers(), updateScrollbars(), updateTextbox(), and updateZoom().

hruler

Ruler::Ptr View::hruler

private

Referenced by updateRulers(), and View().

hruler_area

GtkDrawingArea* View::hruler_area

private

Referenced by View().

hscrollbar

GtkScrollbar* View::hscrollbar

private

Referenced by updateScrollbars(), and View().

hscrollbaradjustment

GtkAdjustment* View::hscrollbaradjustment

private

Referenced by updateScrollbars(), and View().

logger

Scroom::Logger View::logger

private

Referenced by ~View().

menubar

GtkWidget* View::menubar

private

Referenced by View().

modifiermove

gint View::modifiermove {0}

private

{0};

Referenced by on_buttonPress(), on_buttonRelease(), and on_motion_notify().

position

Freezable<Scroom::Utils::Point<double> > View::position

private

of the top left visible pixel

Referenced by on_motion_notify(), on_scrollbar_value_changed(), on_window_size_changed(), on_zoombox_changed(), setPresentation(), tweakedPosition(), updateScrollbars(), updateTextbox(), and updateXY().

postRenderers

std::vector<PostRenderer::Ptr> View::postRenderers

private

Referenced by redraw(), and registerPostRenderer().

presentation

PresentationInterface::Ptr View::presentation

private

Referenced by create(), getCurrentPresentation(), hasPresentation(), redraw(), setPresentation(), updateScrollbars(), updateTextbox(), updateTweaks(), and updateZoom().

presentationRect

Scroom::Utils::Rectangle<double> View::presentationRect

private

Referenced by setPresentation(), updateScrollbars(), and updateZoom().

presentations

Scroom::Utils::WeakKeyMap<PresentationInterface::WeakPtr, GtkWidget*> View::presentations

private

Referenced by on_presentation_created(), and updateNewWindowMenu().

progressBar

GtkProgressBar* View::progressBar

private

Referenced by View().

progressBarManager

ProgressBarManager::Ptr View::progressBarManager

private

Referenced by getProgressInterface(), and View().

scroomXml

GtkBuilder* View::scroomXml

private

Referenced by create(), on_newPresentationInterfaces_update(), and updateNewWindowMenu().

selection

std::optional<Selection> View::selection

private

Referenced by on_buttonPress(), on_buttonRelease(), and on_motion_notify().

selectionListeners

std::vector<SelectionListener::Ptr> View::selectionListeners

private

Referenced by on_buttonPress(), on_buttonRelease(), on_motion_notify(), and registerSelectionListener().

sidebarManager

SidebarManager View::sidebarManager

private

Referenced by addSideWidget(), removeSideWidget(), and View().

statusArea

GtkWidget* View::statusArea

private

Referenced by setFullScreen(), unsetFullScreen(), and View().

statusBar

GtkStatusbar* View::statusBar

private

Referenced by setStatusMessage(), and View().

statusBarContextId

int View::statusBarContextId

private

Referenced by setStatusMessage(), and View().

toolBar

GtkToolbar* View::toolBar

private

Referenced by addToToolbar(), removeFromToolbar(), and View().

toolbarArea

GtkWidget* View::toolbarArea

private

Referenced by setFullScreen(), unsetFullScreen(), and View().

toolBarCount

unsigned View::toolBarCount

private

Referenced by addToToolbar(), removeFromToolbar(), and View().

toolBarSeparator

GtkToolItem* View::toolBarSeparator

private

Referenced by addToToolbar(), removeFromToolbar(), and View().

tools

std::map<GtkToggleButton*, ToolStateListener::Ptr> View::tools

private

Referenced by addToolButton(), and toolButtonToggled().

tweakPositionTextBox

std::shared_ptr<Scroom::Utils::ITweakPositionTextBox> View::tweakPositionTextBox

private

Referenced by on_textbox_value_changed(), updateTextbox(), and updateTweaks().

tweakPresentationPosition

std::shared_ptr<Scroom::Utils::ITweakPresentationPosition> View::tweakPresentationPosition

private

Referenced by tweakedPosition(), and updateTweaks().

tweakRulers

std::shared_ptr<Scroom::Utils::ITweakRulers> View::tweakRulers

private

Referenced by updateRulers(), and updateTweaks().

tweakSelection

Scroom::Utils::ITweakSelection::Map View::tweakSelection

private

Referenced by on_buttonPress(), on_buttonRelease(), on_motion_notify(), and updateTweaks().

vruler

Ruler::Ptr View::vruler

private

Referenced by updateRulers(), and View().

vruler_area

GtkDrawingArea* View::vruler_area

private

Referenced by View().

vscrollbar

GtkScrollbar* View::vscrollbar

private

Referenced by updateScrollbars(), and View().

vscrollbaradjustment

GtkAdjustment* View::vscrollbaradjustment

private

Referenced by on_scrollbar_value_changed(), updateScrollbars(), and View().

window

GtkWindow* View::window

private

Referenced by hide(), setFullScreen(), setPresentation(), unsetFullScreen(), View(), and ~View().

xTextBox

GtkEntry* View::xTextBox

private

Referenced by on_textbox_value_changed(), updateTextbox(), and View().

yTextBox

GtkEntry* View::yTextBox

private

Referenced by on_textbox_value_changed(), updateTextbox(), and View().

zoom

int View::zoom {0}

private

{0};

Referenced by on_motion_notify(), on_scrollwheel(), on_textbox_value_changed(), on_window_size_changed(), on_zoombox_changed(), presentationPointToWindowPoint(), redraw(), setPresentation(), tweakedPosition(), updateRulers(), updateScrollbars(), updateTextbox(), updateZoom(), and windowPointToPresentationPoint().

zoomBox

GtkComboBox* View::zoomBox

private

Referenced by on_scrollwheel(), on_zoombox_changed(), updateZoom(), and View().

zoomItems

GtkListStore* View::zoomItems

private

Referenced by on_scrollwheel(), on_zoombox_changed(), updateZoom(), and View().

---

The documentation for this class was generated from the following files:

• gui/src/view.hh
• gui/src/view.cc