gtk/joblist.hh

Go to the documentation of this file.

/* $Id: joblist.hh,v 1.5 2003/08/15 11:38:30 atterer Exp $ -*- C++ -*-
  __   _
  |_) /|  Copyright (C) 2001-2003  |  richard@
  | \/¯|  Richard Atterer          |  atterer.net
  ¯ '` ¯
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License, version 2. See
  the file COPYING for details.

*/
#ifndef JOBLIST_HH
#define JOBLIST_HH

#include <config.h>

#include <string>
#include <vector>
#if DEBUG
#  include <iostream>
#endif

#include <debug.hh>
#include <download.hh>
#include <gui.hh>
#include <jobline.fh>
#include <log.hh>
#include <nocopy.hh>
//______________________________________________________________________

class JobList : NoCopy {
public:
  enum {
    COLUMN_STATUS,
    COLUMN_OBJECT,
    COLUMN_DATA,
    NR_OF_COLUMNS
  };
  static const int WIDTH_STATUS = 280;

  static const int TICK_INTERVAL = 250; // = progress report update interval

  LOCAL_DEBUG_UNIT_DECL;

  typedef unsigned size_type;
  inline JobList();
  ~JobList();
  void finalize();

  inline GtkTreeStore* store() const;
  inline GtkTreeView* view() const;

  inline size_type size() const;
  inline size_type entryCount() const;
  inline bool empty() const;

  inline JobLine* get(GtkTreeIter* row) const;
  inline void set(size_type n, JobLine* j);
  void erase(GtkTreeIter* row);
  inline void insert(size_type n, JobLine* j);
  void prepend(JobLine* j, JobLine* parent = 0);
  void append(JobLine* j, JobLine* parent = 0);
  void makeRowBlank(GtkTreeIter* row);

  inline void setWindowOwner(JobLine* j);
  inline bool isWindowOwner(JobLine* j) const;
  inline JobLine* windowOwner() const;

  inline void registerTicks();
  inline void unregisterTicks();

  void postGtkInit();
# if DEBUG

  void assertValid() const;
# else
  void assertValid() const { }
# endif

private:
  // GTK+ timeout function: calls tick() on stored JobLine objects
  static gint timeoutCallback(gpointer jobList);
  // GTK+ callback function, called when a line in the list is selected
  static gboolean selectRowCallback(GtkTreeSelection*, GtkTreeModel*,
                                    GtkTreePath*, gboolean, gpointer);
  /* Function registered with GTK+, sets up pixbuf with progress bar in the
     GtkTreeView. */
  static void pixbufForJobLine(GtkTreeViewColumn*, GtkCellRenderer* cell,
                               GtkTreeModel*, GtkTreeIter* iter,
                               gpointer data);
  // Load file with progress bar images, prepare it for display
  static void pixbufForJobLine_init();
  // Helper for prepend()
  static gboolean progressScrollToTop(gpointer view);
  // Set selectRowIdleId to 0
  static gboolean selectRowIdle(gpointer data);

  /* Used by initAfterGtk(): Nr of pixbufs to subdivide the progress XPM
     into, filename to load from. */
  static const unsigned PROGRESS_SUBDIV = 61;
  static const char* const PROGRESS_IMAGE_FILE;
  static GdkPixbuf* progressImage; // Pixel data
  static vector<GdkPixbuf*> progressGfx; // sub-GdkPixbufs of progressImage
  static GValue progressValue;

  GtkTreeStore* storeVal; // GTK store of the displayed list

  unsigned sizeVal; // Number of rows in table
  unsigned entryCountVal; // Number of entries (= sizeVal - nr_of_empty_rows)
  JobLine* windowOwnerValue;

  /* Count the number of entries in the list which are in a state in which
     they need tick() calls. */
  int needTicks;
  int timeoutId; // as returned by gtk_timeout_add()

  // Callback avoids mult. calls to entries' selectRow()
  unsigned selectRowIdleId;
};
//______________________________________________________________________

namespace GUI {
  extern JobList jobList;
}

//======================================================================

JobList::JobList() : storeVal(0), sizeVal(0), entryCountVal(0),
                     windowOwnerValue(0), needTicks(0),
                     selectRowIdleId(0) {
  // Mustn't access widgets here because GTK+ is not initialized yet!
}

JobList::size_type JobList::size() const { return sizeVal; }
bool JobList::empty() const { return sizeVal == 0; }
JobList::size_type JobList::entryCount() const { return entryCountVal; }
GtkTreeStore* JobList::store() const { return storeVal; }
GtkTreeView* JobList::view() const {
  return GTK_TREE_VIEW(GUI::window.jobs);
}

JobLine* JobList::get(GtkTreeIter* row) const {
  gpointer ptr;
  gtk_tree_model_get(GTK_TREE_MODEL(store()), row, COLUMN_DATA, &ptr, -1);
  return static_cast<JobLine*>(ptr);
}
#if 0
Job* JobList::get(size_type n) {
  return static_cast<JobLine*>(gtk_clist_get_row_data(list(), n));
}
void JobList::set(size_type n, JobLine* j) {
  gtk_clist_unselect_row(list(), n, 0);
  gtk_clist_set_row_data(list(), n, j);
  if (j) {
    j->jobVec = this;
    j->rowVal = n;
  }
}
void JobList::insert(size_type n, JobLine* j) {
  Paranoid(j != 0);
  gtk_clist_insert(list(), n, noText); // 0 => no text initially
  gtk_clist_set_row_data(list(), n, j);
  ++sizeVal;
  ++entryCountVal;
  j->jobVec = this;
  j->rowVal = n;
  j->run();
}
#endif

void JobList::registerTicks() {
  if (++needTicks == 1) {
    timeoutId = g_timeout_add(TICK_INTERVAL, timeoutCallback, this);
  }
  debug("registerTicks: %1", needTicks);
}
/* No further action is required. The timeout function will unregister itself
   next time it is called, by returning FALSE. */
void JobList::unregisterTicks() {
  if (--needTicks == 0)
    g_source_remove(timeoutId);
  debug("unregisterTicks: %1", needTicks);
}

void JobList::setWindowOwner(JobLine* j) { windowOwnerValue = j; }
bool JobList::isWindowOwner(JobLine* j) const { return windowOwnerValue==j; }
JobLine* JobList::windowOwner() const { return windowOwnerValue; }

#endif

---