path: root/src/common/helper.c

/*
     This file is part of GNUnet
     (C) 2003, 2004, 2005 Christian Grothoff (and other contributing authors)

     GNUnet is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published
     by the Free Software Foundation; either version 2, or (at your
     option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with GNUnet; see the file COPYING.  If not, write to the
     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
*/
/**
 * @file src/common/helper.c
 * @brief This file contains some GUI helper functions
 * @author Igor Wronsky
 * @author Christian Grothoff
 */

#include "platform.h"
#include "gnunetgtk_common.h"

#define HELPER_DEBUG NO

static GladeXML * mainXML;

static char * gladeFile;

static GtkWidget * infoWindow;

static GtkWidget * infoText;

/**
 * the main thread 
 */
static PTHREAD_T mainThread;

typedef struct {
  Semaphore * sem;
  void * args;
  SimpleCallback func;
} SaveCall;

static SaveCall ** psc;

static unsigned int pscCount;

static Mutex sclock;

static int saveCallsUp;

static gboolean saveCallWrapper(gpointer data) {
  SaveCall * call = data;

  call->func(call->args);
  if (call->sem != NULL)
    SEMAPHORE_UP(call->sem);
  return FALSE;
}

/**
 * Call a callback function from the mainloop/main thread ("SaveCall").
 * Since GTK doesn't work with multi-threaded applications under Windows,
 * all GTK operations have to be done in the main thread
 */
void gtkSaveCall(SimpleCallback func, 
		 void * args) {
  SaveCall call;
  int i;

  MUTEX_LOCK(&sclock);
  if ( (saveCallsUp == NO) ||
       (! PTHREAD_SELF_TEST(&mainThread)) ) {
    call.args = args;
    call.func = func;
    call.sem  = SEMAPHORE_NEW(0);
    GROW(psc,
	 pscCount,
	 pscCount+1);
    psc[pscCount-1] = &call;
    MUTEX_UNLOCK(&sclock);
    gtk_idle_add(&saveCallWrapper, 
		 &call);
    SEMAPHORE_DOWN(call.sem);
    /* remove from psc list */
    MUTEX_LOCK(&sclock);
    for (i=0;i<pscCount;i++) {
      if (psc[i] == &call) {
	psc[i] = psc[pscCount-1];
	break;
      }
    }
    GNUNET_ASSERT(i != pscCount);
    GROW(psc,
	 pscCount,
	 pscCount-1);
    MUTEX_UNLOCK(&sclock);
    SEMAPHORE_FREE(call.sem);
  } else {
    MUTEX_UNLOCK(&sclock);
    func(args);
  }
}

int gtkRunSomeSaveCalls() {
  int i;

  if (! PTHREAD_SELF_TEST(&mainThread))
    return NO;
  MUTEX_LOCK(&sclock);
  if (pscCount == 0) {
    MUTEX_UNLOCK(&sclock);
    return NO;
  }
  i = randomi(pscCount);
  if (TRUE == g_idle_remove_by_data(psc[i]))
    psc[i]->func(psc[i]);
  MUTEX_UNLOCK(&sclock);
  gnunet_util_sleep(50 * cronMILLIS);
  /* sleep here is somewhat important, first of
     all, after completion we need to give the
     semaphore-mechanism time to remove the save-call
     from the list to avoid running it twice; 
     also, this function might be called in a tight
     loop (see search.c), so we should give the
     other threads some time to run.  */

  return YES;
}

/**
 * Callback for handling "delete_event": close the window 
 */
static gint 
deleteEvent(GtkWidget * widget,
	    GdkEvent * event,
	    gpointer data) {
  return FALSE;
}

static void hideWindow(GtkWidget * widget,
		       gpointer data) {
  if (widget != NULL)
    gtk_widget_hide(widget);
}

/**
 * Closure for doInfoMessage.
 */
typedef struct {
  int doPopup;
  char * note;
} InfoMessage;

/**
 * Callback for infoMessage()
 *
 * FIXME: use GLADE (or direct GTK functionality) here!
 */
static void doInfoMessage(void * args) {
  const InfoMessage * info = args;
  GtkTextIter iter;
  GtkTextBuffer * buffer;

  if (! infoWindow) {
    GtkWidget * box1;
    GtkWidget * button;
    GtkWidget * scrolled_window;

    infoWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_signal_connect(GTK_OBJECT(infoWindow),
                       "delete_event",
                       GTK_SIGNAL_FUNC(deleteEvent),
                       NULL);

    gtk_window_set_title(GTK_WINDOW(infoWindow),
                         _("Messages"));
    gtk_widget_set_usize(GTK_WIDGET(infoWindow),
                         780,
                         300);

    box1 = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER (infoWindow),
                      box1);
    gtk_widget_show(box1);
    
    /* create a scrollable window */
    scrolled_window = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
    				   GTK_POLICY_AUTOMATIC,
				   GTK_POLICY_ALWAYS);
    gtk_box_pack_start(GTK_BOX(box1),
    		       scrolled_window,
		       TRUE,
		       TRUE,
		       0);
    gtk_widget_show(scrolled_window);

    /* create a text widget */
    infoText = gtk_text_view_new();
    
    gtk_text_view_set_editable(GTK_TEXT_VIEW (infoText),
			       FALSE);
    gtk_container_add(GTK_CONTAINER(scrolled_window),
    		      infoText);
    gtk_widget_show(infoText);
    gtk_widget_realize(infoText);
  
    /* finish with a close button */
    button = gtk_button_new_with_label(_("Close"));
    gtk_box_pack_start(GTK_BOX (box1),
                       button,
                       FALSE,
                       FALSE,
                       0);
    gtk_signal_connect_object(GTK_OBJECT(button),
                              "clicked",
                              GTK_SIGNAL_FUNC(hideWindow),
                              GTK_OBJECT(infoWindow));
    gtk_signal_connect_object(GTK_OBJECT(infoWindow), 
			      "delete_event",
                              GTK_SIGNAL_FUNC(hideWindow),
                              GTK_OBJECT(infoWindow));
    gtk_signal_connect_object(GTK_OBJECT(infoWindow), 
			      "destroy",
                              GTK_SIGNAL_FUNC(hideWindow),
                              GTK_OBJECT(infoWindow));
    gtk_widget_show(button);
  }
  if (info->doPopup==YES)
    gtk_widget_show(infoWindow);

  /* append the text */
  buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(infoText));
  gtk_text_buffer_get_iter_at_offset(buffer, &iter, -1);
  gtk_text_buffer_insert(buffer,
			 &iter,
			 info->note, 
			 -1);
}

/** 
 * Appends a message to the info window
 *
 * @param doPopup do we open the window, YES or NO
 */
void infoMessage(int doPopup,
		 const char * format,
		 ...) {
  va_list args;
  InfoMessage info;

  va_start(args, format);
  info.note = g_strdup_vprintf(format, args);
  va_end(args);
  info.doPopup = doPopup;
  gtkSaveCall(&doInfoMessage, 
	      &info);
  g_free(info.note);
}

static void saveAddLogEntry(void * args) {
  static GtkWidget * s = NULL;
  static int once = 1;
  static guint id;

  if (once) {
    once = 0;
    s = glade_xml_get_widget(mainXML,
			     "statusbar");
    id = gtk_statusbar_get_context_id(GTK_STATUSBAR(s),
				      "LOG");
  } else
    gtk_statusbar_pop(GTK_STATUSBAR(s),
		      id);
  gtk_statusbar_push(GTK_STATUSBAR(s),
		     id,
		     (const char*) args);
}

/** 
 * Appends a log entry to the info window
 *
 * @param txt the log entry
 *
 */
void addLogEntry(const char * txt) {
  infoMessage(NO, txt);
  gtkSaveCall(&saveAddLogEntry,
	      (void*) txt);
}

/**
 * Simple accessor method.
 */
const char * getGladeFileName() {
  return gladeFile;
}

/**
 * Simple accessor method.
 */
GladeXML * getMainXML() {
  return mainXML;
}

void initGNUnetGTKCommon() {
  MUTEX_CREATE_RECURSIVE(&sclock);
  PTHREAD_GET_SELF(&mainThread);
  saveCallsUp = YES;

  /* load the interface */
#ifdef MINGW
  gladeFile = MALLOC(_MAX_PATH + 1);
  plibc_conv_to_win_path(PACKAGE_DATA_DIR"/gnunet-gtk.glade", gladeFile);
#else
  gladeFile = STRDUP(PACKAGE_DATA_DIR"/gnunet-gtk.glade");
#endif

  mainXML = glade_xml_new(gladeFile,
			  "mainWindow",
			  NULL);
}

void doneGNUnetGTKCommon() {
  int i;

  UNREF(mainXML);
  mainXML = NULL;
  FREE(gladeFile);
  gladeFile = NULL;

  saveCallsUp = NO;
  PTHREAD_REL_SELF(&mainThread);
  MUTEX_LOCK(&sclock);
  for (i=0;i<pscCount;i++) 
    psc[i]->func(psc[i]);
  i = pscCount;
  MUTEX_UNLOCK(&sclock);  
  /* wait until all PSC-jobs have left
     the gtkSaveCall method before destroying
     the mutex! */
  while (i != 0) {
    gnunet_util_sleep(50 * cronMILLIS);    
    MUTEX_LOCK(&sclock);
    i = pscCount;
    MUTEX_UNLOCK(&sclock);
  }
  MUTEX_DESTROY(&sclock);

}

/* end of helper.c */