xv_log.c

Go to the documentation of this file.

/*
 
  $Id: xv_log.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS 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 3 of the License, or
  any later version.
 
  PIPS 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 PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
 
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <errno.h>
 
#include <sys/time.h>
#include <sys/resource.h>
#include <xview/xview.h>
#include <xview/panel.h>
#include <xview/text.h>
#include <xview/textsw.h>
#include <xview/notice.h> 
#include <xview/xv_error.h>
 
/* xview/newgen interaction
 */
#if (defined(TEXT))
#undef TEXT
#endif
 
#if (defined(TEXT_TYPE))
#undef TEXT_TYPE
#endif
 
#include "genC.h"
#include "misc.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "database.h"
#include "pipsdbm.h"
#include "top-level.h"
 
#include "properties.h"
 
#include "wpips.h"
 
static Textsw log_textsw;
static Menu_item open_front, clear, close;
 
 
void
prompt_user(string a_printf_format, ...)
{
   Event e;
   va_list some_arguments;
   static char message_buffer[SMALL_BUFFER_LENGTH];
 
   va_start(some_arguments, a_printf_format);
 
   (void) vsprintf(message_buffer, a_printf_format, some_arguments);
 
   if (wpips_emacs_mode) 
      send_prompt_user_to_emacs(message_buffer);
   (void) notice_prompt(xv_find(main_frame, WINDOW, 0), 
                        &e,
                        NOTICE_MESSAGE_STRINGS,
                        message_buffer,
                        0,
                        NOTICE_BUTTON_YES,      "Press Here",
                        0);
}
 
 
static void
insert_something_in_the_wpips_log_window(char * a_message)
{
    int new_length;
    int message_length = strlen(a_message);
    int old_length = (int) xv_get(log_textsw, TEXTSW_LENGTH);
 
   /* Try to insert at the end: */
   xv_set(log_textsw,
          TEXTSW_INSERTION_POINT, old_length,
          NULL);
   textsw_insert(log_textsw, a_message, message_length);
   /* Verify it fitted: */
   new_length = (int) xv_get(log_textsw, TEXTSW_LENGTH);
   if (new_length != old_length + message_length) 
   {
      /* It ran out of space! */
      /* recreate_log_window(); */
      /* Discard the content without keeping the undo buffer: */
      textsw_reset(log_textsw, 0, 0);
      
      xv_set(log_textsw,
             TEXTSW_INSERTION_POINT, 0,
             NULL);
      /* Hope there is no use of recursion... */
      textsw_insert(log_textsw, a_message, message_length);
 
      prompt_user("As you have just clicked, "
                  "you saw the log window was full :-) ...\n"
                  "It is now cut down to 0 byte again...\n\n"
                  "Anyway, you can retrieve all the log content "
                  "in the file \"%s/LOGFILE\"\n",
                  db_get_current_workspace_directory());
   }   
 
   textsw_possibly_normalize(log_textsw, 
                             (Textsw_index) xv_get(log_textsw, TEXTSW_INSERTION_POINT));
 
   XFlush((Display *) xv_get(main_frame, XV_DISPLAY));
   XFlush((Display *) xv_get(log_frame, XV_DISPLAY));
 
   xv_set(clear, MENU_INACTIVE, FALSE, 0);
}
 
 
void
wpips_user_error_message(char error_buffer[])
{
   log_on_file(error_buffer);
 
   if (wpips_emacs_mode) 
      send_user_error_to_emacs(error_buffer);
   else
      insert_something_in_the_wpips_log_window(error_buffer);
 
   show_message(error_buffer);
   if (!wpips_emacs_mode) 
      unhide_window(log_frame);
 
   /* prompt_user("Something went wrong. Check the log window"); */
      
   /* terminate PIPS request */
   if(get_bool_property("ABORT_ON_USER_ERROR"))
      abort();
 
   THROW(user_exception_error);
      
   (void) exit(1);
}
 
void 
wpips_user_warning_message(char warning_buffer[])
{
   log_on_file(warning_buffer);
 
   if (wpips_emacs_mode) 
      send_user_warning_to_emacs(warning_buffer);
   else {
      insert_something_in_the_wpips_log_window(warning_buffer);
      /* Franc,ois said a warning is not important enough...
         unhide_window(log_frame);
         */
   }
   
   show_message(warning_buffer);
}
 
 
#define MAXARGS     100
 
void
wpips_user_log(string fmt, va_list args)
{
   static char log_buffer[SMALL_BUFFER_LENGTH];
 
   (void) vsprintf(log_buffer, fmt, args);
 
   log_on_file(log_buffer);
 
   if(get_bool_property("USER_LOG_P")==FALSE)
      return;
 
   if (wpips_emacs_mode) 
      send_user_log_to_emacs(log_buffer);
   else
      insert_something_in_the_wpips_log_window(log_buffer);
   /* Display the "Message:" line in the main window also in the emacs
      mode: */
   show_message(log_buffer);
}
 
 
void open_log_subwindow(menu, menu_item)
Menu menu;
Menu_item menu_item;
{
    xv_set(open_front, MENU_STRING, "Front", 0);
    xv_set(close, MENU_INACTIVE, FALSE, 0);
    unhide_window(log_frame);
}
 
 
void clear_log_subwindow(menu, menu_item)
Menu menu;
Menu_item menu_item;
{
    int l = (int) xv_get(log_textsw, TEXTSW_LENGTH);
    textsw_delete(log_textsw, 0, l);
    xv_set(clear, MENU_INACTIVE, TRUE, 0);
}
 
 
 
void close_log_subwindow(menu, menu_item)
Menu menu;
Menu_item menu_item;
{
    xv_set(open_front, MENU_STRING, "Open", 0); /*MENU_INACTIVE, FALSE, 0);*/
    xv_set(close, MENU_INACTIVE, TRUE, 0);
    hide_window(log_frame);
}
 
 
void create_log_menu()
{
    Menu menu;
    Panel_item log_button;
 
    open_front = xv_create(NULL, MENUITEM, 
                     MENU_STRING, "Open",
                     MENU_NOTIFY_PROC, open_log_subwindow,
                     MENU_RELEASE,
                     NULL);
 
    clear = xv_create(NULL, MENUITEM, 
                      MENU_STRING, "Clear",
                      MENU_NOTIFY_PROC, clear_log_subwindow,
                      MENU_INACTIVE, TRUE,
                      MENU_RELEASE,
                      NULL);
 
    close = xv_create(NULL, MENUITEM, 
                      MENU_STRING, "Close",
                      MENU_NOTIFY_PROC, close_log_subwindow,
                      MENU_INACTIVE, TRUE,
                      MENU_RELEASE,
                      NULL);
 
    menu = xv_create(XV_NULL, MENU_COMMAND_MENU, 
                     MENU_APPEND_ITEM, open_front,
                     MENU_APPEND_ITEM, clear,
                     MENU_APPEND_ITEM, close,
                     NULL);
 
    log_button = xv_create(main_panel, PANEL_BUTTON,
                     PANEL_LABEL_STRING, "Log  ",
                     PANEL_ITEM_MENU, menu,
                     0);
 
    if (wpips_emacs_mode)
       /* In fact, create it but disabled to keep the same frame
          layout in the Emacs mode: */
       xv_set(log_button, PANEL_INACTIVE, TRUE,
              NULL);
}
 
 
/* This works but it is cleaner to use textsw_reset() instead...
void
recreate_log_window()
{
   xv_destroy(log_textsw);
   log_textsw = (Xv_Window) xv_create(log_frame, TEXTSW, 0);
}
*/
 
 
void create_log_window()
{
    /* Xv_Window window; */
 
 
    log_textsw = (Xv_Window) xv_create(log_frame, TEXTSW, 0);
/* recuperation d'event ne fonctionne pas -> installer TEXTSW_NOTIFY_PROC, */
/* autre suggestion: mettre un masque X */
 
/*    window = (Xv_Window) xv_find(log_frame, WINDOW, 0);
 
    xv_set(window, 
           WIN_CONSUME_X_EVENT_MASK, EnterWindowMask, 
           WIN_EVENT_PROC, default_win_interpose, 
           NULL);
*/
}