s_page.c

Go to the documentation of this file.

/* gEDA - GPL Electronic Design Automation
 * libgeda - gEDA's library
 * Copyright (C) 1998-2010 Ales Hvezda
 * Copyright (C) 1998-2010 gEDA Contributors (see ChangeLog for details)
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <config.h>

#include <stdio.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include "libgeda_priv.h"

#ifdef HAVE_LIBDMALLOC
#include <dmalloc.h>
#endif

static gint global_pid = 0;

/* Called just before removing an OBJECT from a PAGE. */
static void
object_added (TOPLEVEL *toplevel, PAGE *page, OBJECT *object)
{
  /* Set up object parent pointer */
#ifndef NDEBUG
  if (object->page != NULL) {
    g_critical ("Object %p already has parent page %p!", object, object->page);
  }
#endif
  object->page = page;

  /* Add object to tile system. */
  s_tile_add_object (toplevel, object);

  /* Update object connection tracking */
  s_conn_update_object (toplevel, object);

  o_emit_change_notify (toplevel, object);
}

/* Called just before removing an OBJECT from a PAGE. */
static void
pre_object_removed (TOPLEVEL *toplevel, PAGE *page, OBJECT *object)
{
  o_emit_pre_change_notify (toplevel, object);

  /* Clear object parent pointer */
#ifndef NDEBUG
  if (object->page == NULL) {
    g_critical ("Object %p has NULL parent page!", object);
  }
#endif
  object->page = NULL;

  /* Clear page's object_lastplace pointer if set */
  if (page->object_lastplace == object) {
    page->object_lastplace = NULL;
  }

  /* Remove object from connection system */
  s_conn_remove_object (toplevel, object);

  /* Remove object from tile system */
  s_tile_remove_object (object);
}

PAGE *s_page_new (TOPLEVEL *toplevel, const gchar *filename)
{
  PAGE *page;

  /* Now create a blank page */
  page = (PAGE*)g_new0 (PAGE, 1);

  page->pid = global_pid++;

  page->CHANGED = 0;

  /* big assumption here that page_filename isn't null */
  if (g_path_is_absolute (filename)) {
    page->page_filename = g_strdup (filename);
  } else {
    gchar *pwd = g_get_current_dir ();
    page->page_filename = g_build_filename (pwd, filename, NULL);
    g_free (pwd);
  }
    
  g_assert (toplevel->init_bottom != 0);
  page->coord_aspectratio = (
    ((float) toplevel->init_right) / ((float) toplevel->init_bottom));

  page->up = -2;
  page->page_control = 0;

  /* Init tile array */
  s_tile_init (toplevel, page);

  /* Init the object list */
  page->_object_list = NULL;

  /* new selection mechanism */
  page->selection_list = o_selection_new();

  page->place_list = NULL;

  /* init undo struct pointers */
  s_undo_init(page);
  
  page->object_lastplace = NULL;

  page->weak_refs = NULL;
  
  set_window (toplevel, page,
              toplevel->init_left, toplevel->init_right,
              toplevel->init_top,  toplevel->init_bottom);

  /* Backup variables */
  g_get_current_time (&page->last_load_or_save_time);
  page->ops_since_last_backup = 0;
  page->saved_since_first_loaded = 0;
  page->do_autosave_backup = 0;

  /* now append page to page list of toplevel */
  geda_list_add( toplevel->pages, page );

  return page;
}

void s_page_delete (TOPLEVEL *toplevel, PAGE *page)
{
  PAGE *tmp;
  gchar *backup_filename;
  gchar *real_filename;

  /* We need to temporarily make the page being deleted current because
   * various functions called below (some indirectly) assume they are
   * deleting objects from the current page.
   *
   * These functions are known to include:
   *   s_delete_object ()
   */

  /* save page_current and switch to page */
  if (page == toplevel->page_current) {
    tmp = NULL;
  } else {
    tmp = toplevel->page_current;
    s_page_goto (toplevel, page);
  }

  /* Get the real filename and file permissions */
  real_filename = follow_symlinks (page->page_filename, NULL);
  
  if (real_filename == NULL) {
    s_log_message (_("s_page_delete: Can't get the real filename of %s."),
                   page->page_filename);
  }
  else {
    backup_filename = f_get_autosave_filename (real_filename);

    /* Delete the backup file */
    if ( (g_file_test (backup_filename, G_FILE_TEST_EXISTS)) && 
     (!g_file_test(backup_filename, G_FILE_TEST_IS_DIR)) )
    {
      if (unlink(backup_filename) != 0) {
    s_log_message(_("s_page_delete: Unable to delete backup file %s."),
                      backup_filename);
      }
    }
    g_free (backup_filename);
  }
  g_free(real_filename);

  /* Free the selection object */
  g_object_unref( page->selection_list );

  /* then delete objects of page */
  s_page_delete_objects (toplevel, page);

  /* Free the objects in the place list. */
  s_delete_object_glist (toplevel, page->place_list);
  page->place_list = NULL;

#if DEBUG
  printf("Freeing page: %s\n", page->page_filename);
  s_tile_print(toplevel, page);
#endif
  s_tile_free_all (page);

  /* free current page undo structs */
  s_undo_free_all (toplevel, page); 

  /* ouch, deal with parents going away and the children still around */
  page->up = -2;
  g_free (page->page_filename);

  geda_list_remove( toplevel->pages, page );

#if DEBUG
  s_tile_print (toplevel, page);
#endif

  s_weakref_notify (page, page->weak_refs);

  g_free (page);

  /* restore page_current */
  if (tmp != NULL) {
    s_page_goto (toplevel, tmp);
  } else {
    /* page was page_current */
    toplevel->page_current = NULL;
    /* page_current must be updated by calling function */
  }

}


void s_page_delete_list(TOPLEVEL *toplevel)
{
  GList *list_copy, *iter;
  PAGE *page;

  /* s_page_delete removes items from the page list, so make a copy */
  list_copy = g_list_copy (geda_list_get_glist (toplevel->pages));

  for (iter = list_copy; iter != NULL; iter = g_list_next (iter)) {
    page = (PAGE *)iter->data;

    s_page_delete (toplevel, page);
  }

  g_list_free (list_copy);

  /* reset toplevel fields */
  toplevel->page_current = NULL;
}

void
s_page_weak_ref (PAGE *page,
                 void (*notify_func)(void *, void *),
                 void *user_data)
{
  g_return_if_fail (page != NULL);
  page->weak_refs = s_weakref_add (page->weak_refs, notify_func, user_data);
}

void
s_page_weak_unref (PAGE *page,
                   void (*notify_func)(void *, void *),
                   void *user_data)
{
  g_return_if_fail (page != NULL);
  page->weak_refs = s_weakref_remove (page->weak_refs,
                                      notify_func, user_data);
}

void
s_page_add_weak_ptr (PAGE *page,
                     void *weak_pointer_loc)
{
  g_return_if_fail (page != NULL);
  page->weak_refs = s_weakref_add_ptr (page->weak_refs, weak_pointer_loc);
}

void
s_page_remove_weak_ptr (PAGE *page,
                        void *weak_pointer_loc)
{
  g_return_if_fail (page != NULL);
  page->weak_refs = s_weakref_remove_ptr (page->weak_refs,
                                          weak_pointer_loc);
}

void s_page_goto (TOPLEVEL *toplevel, PAGE *p_new) 
{
  gchar *dirname;

  toplevel->page_current = p_new;

  dirname = g_dirname (p_new->page_filename);
  if (chdir (dirname)) {
    /* An error occured with chdir */
#warning FIXME: What do we do?
  }
  g_free (dirname);

}

PAGE *s_page_search (TOPLEVEL *toplevel, const gchar *filename)
{
  const GList *iter;
  PAGE *page;

  for ( iter = geda_list_get_glist( toplevel->pages );
        iter != NULL;
        iter = g_list_next( iter ) ) {

    page = (PAGE *)iter->data;
    if ( g_strcasecmp( page->page_filename, filename ) == 0 )
      return page;
  }
  return NULL;
}

PAGE *s_page_search_by_page_id (GedaPageList *list, int pid)
{
  const GList *iter;

  for ( iter = geda_list_get_glist (list);
        iter != NULL;
        iter = g_list_next (iter) ) {
    PAGE *page = (PAGE *)iter->data;
    if (page->pid == pid) {
      return page;
    }
  }

  return NULL;
}

void s_page_print_all (TOPLEVEL *toplevel)
{
  const GList *iter;
  PAGE *page;

  for ( iter = geda_list_get_glist( toplevel->pages );
        iter != NULL;
        iter = g_list_next( iter ) ) {

    page = (PAGE *)iter->data;
    printf ("FILENAME: %s\n", page->page_filename);
    print_struct_forw (page->_object_list);
  }
}

gint s_page_save_all (TOPLEVEL *toplevel)
{
  const GList *iter;
  PAGE *p_current;
  gint status = 0;

  for ( iter = geda_list_get_glist( toplevel->pages );
        iter != NULL;
        iter = g_list_next( iter ) ) {

    p_current = (PAGE *)iter->data;

    if (f_save (toplevel, p_current,
                p_current->page_filename, NULL)) {
      s_log_message (_("Saved [%s]\n"),
                     p_current->page_filename);
      /* reset the CHANGED flag of p_current */
      p_current->CHANGED = 0;

    } else {
      s_log_message (_("Could NOT save [%s]\n"),
                     p_current->page_filename);
      /* increase the error counter */
      status++;
    }

  }

  return status;
}

gboolean s_page_check_changed (GedaPageList *list)
{
  const GList *iter;
  PAGE *p_current;

  for ( iter = geda_list_get_glist( list );
        iter != NULL;
        iter = g_list_next( iter ) ) {

    p_current = (PAGE *)iter->data;
    if (p_current->CHANGED) {
      return TRUE;
    }
  }

  return FALSE;
}

void s_page_clear_changed (GedaPageList *list)
{
  const GList *iter;
  PAGE *p_current;

  for ( iter = geda_list_get_glist( list );
        iter != NULL;
        iter = g_list_next( iter ) ) {

    p_current = (PAGE *)iter->data;
    p_current->CHANGED = 0;
  }
}

void s_page_autosave_init(TOPLEVEL *toplevel)
{
  if (toplevel->auto_save_interval != 0) {

    /* 1000 converts seconds into milliseconds */
    toplevel->auto_save_timeout = 
      g_timeout_add(toplevel->auto_save_interval*1000,
                    (GSourceFunc) s_page_autosave,
                    toplevel);
  }
}

gint s_page_autosave (TOPLEVEL *toplevel) 
{
  const GList *iter;
  PAGE *p_current;

  if (toplevel == NULL) {
    return 0;
  }

  /* Do nothing if the interval is 0 */
  if (toplevel->auto_save_interval == 0) {
    return toplevel->auto_save_interval;
  }

  /* Should we just disable the autosave timeout returning 0 or
     just wait for more pages to be added? */
  if ( toplevel->pages == NULL)
    return toplevel->auto_save_interval;

  for ( iter = geda_list_get_glist( toplevel->pages );
        iter != NULL;
        iter = g_list_next( iter ) ) {

    p_current = (PAGE *)iter->data;

    if (p_current->ops_since_last_backup != 0) {
      /* Real autosave is done in o_undo_savestate */
      p_current->do_autosave_backup = 1;
    }
  }

  return toplevel->auto_save_interval;
}

void s_page_append (TOPLEVEL *toplevel, PAGE *page, OBJECT *object)
{
  page->_object_list = g_list_append (page->_object_list, object);
  object_added (toplevel, page, object);
}

void s_page_append_list (TOPLEVEL *toplevel, PAGE *page, GList *obj_list)
{
  GList *iter;
  page->_object_list = g_list_concat (page->_object_list, obj_list);
  for (iter = obj_list; iter != NULL; iter = g_list_next (iter)) {
    object_added (toplevel, page, iter->data);
  }
}

void s_page_remove (TOPLEVEL *toplevel, PAGE *page, OBJECT *object)
{
  pre_object_removed (toplevel, page, object);
  page->_object_list = g_list_remove (page->_object_list, object);
}

void
s_page_replace (TOPLEVEL *toplevel, PAGE *page,
                OBJECT *object1, OBJECT *object2)
{
  GList *iter = g_list_find (page->_object_list, object1);

  /* If object1 not found, append object2 */
  if (iter == NULL) {
    s_page_append (toplevel, page, object2);
    return;
  }

  pre_object_removed (toplevel, page, object1);
  iter->data = object2;
  object_added (toplevel, page, object2);
}

void s_page_delete_objects (TOPLEVEL *toplevel, PAGE *page)
{
  GList *objects = page->_object_list;
  GList *iter;
  for (iter = objects; iter != NULL; iter = g_list_next (iter)) {
    pre_object_removed (toplevel, page, iter->data);
  }
  page->_object_list = NULL;
  s_delete_object_glist (toplevel, objects);
}


const GList *s_page_objects (PAGE *page)
{
  return page->_object_list;
}


GList *s_page_objects_in_region (TOPLEVEL *toplevel, PAGE *page,
                                 int min_x, int min_y, int max_x, int max_y)
{
  BOX rect;

  rect.lower_x = min_x;
  rect.lower_y = min_y;
  rect.upper_x = max_x;
  rect.upper_y = max_y;

  return s_page_objects_in_regions (toplevel, page, &rect, 1);
}

GList *s_page_objects_in_regions (TOPLEVEL *toplevel, PAGE *page,
                                  BOX *rects, int n_rects)
{
  GList *iter;
  GList *list = NULL;
  int i;

  for (iter = page->_object_list; iter != NULL; iter = g_list_next (iter)) {
    OBJECT *object = iter->data;
    int left, top, right, bottom;
    int visible;

    visible = world_get_single_object_bounds (toplevel, object,
                                              &left, &top, &right, &bottom);
    if (visible) {
      for (i = 0; i < n_rects; i++) {
        if (right  >= rects[i].lower_x &&
            left   <= rects[i].upper_x &&
            top    <= rects[i].upper_y &&
            bottom >= rects[i].lower_y) {
          list = g_list_prepend (list, object);
          break;
        }
      }
    }
  }

  list = g_list_reverse (list);
  return list;
}