Logo Search packages:      
Sourcecode: fbb version File versions  Download package

xfbbX.c

   /****************************************************************
    Copyright (C) 1986-2000 by

    F6FBB - Jean-Paul ROUBELAT
    6, rue George Sand
    31120 - Roquettes - France
      jpr@f6fbb.org

    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Parts of code have been taken from many other softwares.
    Thanks for the help.
    ****************************************************************/



#define __MAIN__

#include <xfbbX.h>

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <ctype.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/wait.h>

#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/ioctl.h>
#include <netdb.h>

#include <Xm/Protocols.h>

#include <fbb.xbm>

#define TOTVOIES 256

#define SEPARATOR 0
#define BUTTON 1
#define TOGGLE 2
#define RADIO 3
#define TOOLBUTTON 4

static void HelpAct (Widget, XEvent *, String *, Cardinal *);
static void ConsoleAct (Widget, XEvent *, String *, Cardinal *);
static void DisconnAct (Widget, XEvent *, String *, Cardinal *);
static void PendingAct (Widget, XEvent *, String *, Cardinal *);
static void MonitorAct (Widget, XEvent *, String *, Cardinal *);
static void SetCallAct (Widget, XEvent *, String *, Cardinal *);
static void ProgTncAct (Widget, XEvent *, String *, Cardinal *);
static void GatewayAct (Widget, XEvent *, String *, Cardinal *);
static void TalkToAct (Widget, XEvent *, String *, Cardinal *);
static void MsgScanAct (Widget, XEvent *, String *, Cardinal *);
static void EditorAct (Widget, XEvent *, String *, Cardinal *);
static void ListCnxAct (Widget, XEvent *, String *, Cardinal *);
static void SndTextAct (Widget, XEvent *, String *, Cardinal *);
static void ConnectItem (int, char *);
static void makekey (char *, char *, char *);
static void end_wait (void);
static void cursor_wait (void);

static XtActionsRec actionsTable[] =
{
      {"Help", HelpAct},
      {"Console", ConsoleAct},
      {"Disconnect", DisconnAct},
      {"PendingFwd", PendingAct},
      {"Monitor", MonitorAct},
      {"SetCall", SetCallAct},
      {"ProgTnc", ProgTncAct},
      {"Gateway", GatewayAct},
      {"TalkTo", TalkToAct},
      {"MsgScan", MsgScanAct},
      {"Editor", EditorAct},
      {"ListCnx", ListCnxAct},
      {"SndText", SndTextAct}
};

#define NB_PITEM 4
#define NB_ICON 16
#define NB_INIT_B 11

static int print = 0;
static int comm_ok = 1;
static int filter;
static int fbb_sock = -1;
static int first = 1;

static XtInputId InputId = 0;

static Widget MCons;
static Widget MAllc;
static Widget MMon;

static FILE *p_fptr;
static int r_index;

static XtAppContext app_context;

static Pixel df_pixel;
static Pixel rf_pixel;
static Pixel vf_pixel;
static Pixel bf_pixel;
static Pixel no_pixel;
static Pixel rc_pixel;
static Pixel vc_pixel;
static Pixel bc_pixel;

static XmRendition r_rend[10];

static Widget BIcon[NB_ICON];
static Widget form;

static Widget Footer;
static int foothelp;

static Widget ConnectLabel;
static Widget ConnectList;
static Widget MsgsToggle;
static Widget StatusToggle;
static Widget MenuBar;
static Widget ToolBar;
static Widget MenuWindow;
static Widget MenuRemote;
static Widget MenuConfig;
static Widget MenuHelp;
static Widget ListForm;
static Widget StatForm;
static Widget ConnectString;
static Widget StatList;
static Widget MenuFile;

/* Liste des widgets de status */
static Widget TxtUsed;
static Widget TxtGMem;
static Widget TxtDisk1;
static Widget TxtDisk2;
static Widget TxtMsgs;
static Widget TxtResync;
static Widget TxtState;
static Widget TxtHold;
static Widget TxtPriv;

static Widget Used;
static Widget GMem;
static Widget Disk1;
static Widget Disk2;
static Widget Msgs;
static Widget Resync;
static Widget State;
static Widget Hold;
static Widget Priv;
static Widget Popup;
static Widget PItem[NB_PITEM];

void TalkToCB (Widget w, XtPointer client_data, XtPointer call_data);
void OneChanCB (Widget w, XtPointer client_data, XtPointer call_data);
void DisconnectCB (Widget w, XtPointer client_data, XtPointer call_data);

int is_connected (void)
{
      return (fbb_sock > 0);
}

int close_connection (void)
{
      if (fbb_sock > 0)
      {
            HideFbbWindow (ALLCHAN, toplevel);
            HideFbbWindow (CONSOLE, toplevel);
            HideFbbWindow (MONITOR, toplevel);
            close (fbb_sock);
            fbb_sock = -1;
            if (InputId)
                  XtRemoveInput (InputId);
            InputId = 0;
      }
      Caption (1);
      return 1;
}

static int open_connection (char *tcp_addr, int tcp_port, int mask)
{
      int sock;
      struct sockaddr_in sock_addr;
      struct hostent *phe;

      if ((sock = socket (AF_INET, SOCK_STREAM, 0)) < 0)
      {
            perror ("socket_r");
            return (0);
      }

      if ((phe = gethostbyname (tcp_addr)) == NULL)
      {
            perror ("gethostbyname");
            return (-1);
      }

      sock_addr.sin_family = AF_INET;
      sock_addr.sin_port = htons (tcp_port);
      memcpy ((char *) &sock_addr.sin_addr, phe->h_addr, phe->h_length);

      if (connect (sock, (struct sockaddr *) &sock_addr, sizeof (sock_addr)) == -1)
      {
            perror ("connect");
            close_connection ();
            return (-1);
      }

      return (sock);
}

static int do_filter (char *ptr, int len)
{
      char *scan = ptr;
      int lg = 0;

      while (len)
      {
            if ((*ptr == '\n') || isprint (*ptr))
                  scan[lg++] = *ptr;
            ++ptr;
            --len;
      }
      return (lg);
}

void Received (int channel, char *text, int len)
{
      window_write (CONSOLE, text, len, 0, 0);
}

void ReceiveMonitor (int channel, char *text, int len, int color, int header)
{
      if (channel == 255)
            channel = MONITOR;
      else
            channel = ALLCHAN;
      window_write (channel, text, len, color, header);
}

void ReceiveList (int channel, char *text)
{
      ConnectItem (channel, text);
}

void ReceiveNbCh (int nb)
{
      char buffer[80];

      if (nb == 0)
            strcpy (buffer, "No connected station");
      else
            sprintf (buffer, "%d connected station%c", nb, (nb > 1) ? 's' : '\0');
      LabelSetString (ConnectLabel, buffer, NULL);
}

void ReceiveNbMsg (int priv, int hold, int nbmess)
{
      static int old_nbmess = -1L;
      static int old_priv = -1L;
      static int old_hold = -1L;
      char texte[80];

      if (!(conf[curconf].mask & FBB_MSGS))
            priv = hold = nbmess = 0;

      if (old_nbmess != nbmess)
      {
            sprintf (texte, ": %d", nbmess);
            LabelSetString (Msgs, texte, NULL);
            old_nbmess = nbmess;
      }

      if (priv != old_priv)
      {
            sprintf (texte, ": %d", priv);
            LabelSetString (TxtPriv, "Priv msgs", (priv > 0) ? "RC" : NULL);
            LabelSetString (Priv, texte, (priv > 0) ? "RC" : NULL);
            old_priv = priv;
      }

      if (hold != old_hold)
      {
            sprintf (texte, ": %d", hold);
            LabelSetString (TxtHold, "Hold msgs", (hold > 0) ? "RC" : NULL);
            LabelSetString (Hold, texte, (hold > 0) ? "RC" : NULL);
            old_hold = hold;
      }
}

void ReceiveStatus (int lmem, int gmem, int disk1, int disk2)
{
      static int old_lmem = -1L;
      static int old_gmem = -1L;
      static int old_disk1 = -1L;
      static int old_disk2 = 0L;
      char texte[80];

      if (!(conf[curconf].mask & FBB_STATUS))
            disk1 = disk2 = 9999;

      if (old_lmem != lmem)
      {
            sprintf (texte, ": %d", lmem);
            LabelSetString (Used, texte, NULL);
            old_lmem = lmem;
      }

      if (old_gmem != gmem)
      {
            sprintf (texte, ": %d K", gmem << 4);
            LabelSetString (GMem, texte, NULL);
            old_gmem = gmem;
      }

      if (disk1 != old_disk1)
      {
            sprintf (texte, ": %d K", disk1);
            LabelSetString (TxtDisk1, "Disk#1 free", (disk1 < 1000) ? "RC" : NULL);
            LabelSetString (Disk1, texte, (disk1 < 1000) ? "RC" : NULL);
            old_disk1 = disk1;
      }

      if (disk2 != old_disk2)
      {
            if (disk2 == -1L)
            {
                  LabelSetString (TxtDisk2, "", NULL);
                  LabelSetString (Disk2, "", NULL);
            }
            else
            {
                  sprintf (texte, ": %d K", disk2);
                  LabelSetString (TxtDisk2, "Disk#2 free", (disk2 < 1000) ? "RC" : NULL);
                  LabelSetString (Disk2, texte, (disk2 < 1000) ? "RC" : NULL);
            }
            old_disk2 = disk2;
      }
}

static int orb_input (Widget w, int *sock, XtInputId * id)
{
      int nb;
      char buffer[4096];
      char save;
      unsigned int service;
      unsigned int len;
      char *scan;
      static int in_input = 0;
      static int pos = 0;

      if (in_input)
            return 0;

      ++in_input;

      nb = read (*sock, buffer + pos, sizeof (buffer) - pos);
      if (nb == -1)
      {
            perror ("read");
            --in_input;
            close_connection ();
            return 0;
      }

      if (nb == 0)
      {
            MessageBox (0, "Connection closed", "End", MB_OK | MB_ICONEXCLAMATION);
            --in_input;
            close_connection ();
            return 0;
      }

      scan = buffer;
      nb += pos;

      while (nb >= 4)
      {
            /* Read header first. Be sure the 4 bytes are read */
            service = (unsigned int) scan[0];
            len = ((unsigned int) scan[3] << 8) + (unsigned int) scan[2];

            if (nb < len + 4)
                  break;

            scan += 4;
            nb -= 4;

            /* Read the data following the header. Be sure all bytes are read */
            save = scan[len];

            /* decodes and displays the services */
            switch (service)
            {
            case FBB_CONSOLE:
                  if (len > 3)
                        Received (scan[0], scan + 3, len - 3);
                  scan[len - 3] = '\0';
                  if (first && len == 30)
                        MessageBox (0, scan + 3, "status", MB_OK | MB_ICONEXCLAMATION);
                  first = 0;
                  break;
            case FBB_MONITOR:
                  if (len > 3)
                  {
                        int n = len;

                        if (filter)
                              n = do_filter (scan + 3, len - 3) + 3;
                        ReceiveMonitor (scan[0], scan + 3, n - 3, scan[1], scan[2]);
                  }
                  break;
            case FBB_CHANNEL:
                  if (len > 3)
                        ReceiveMonitor (scan[0], scan + 3, len - 3, scan[1], scan[2]);
                  break;
            case FBB_MSGS:
                  {
                        int nbPriv, nbHeld, nbTotal;

                        scan[len] = '\0';
                        sscanf (scan, "%d %d %d",
                                    &nbPriv, &nbHeld, &nbTotal);
                        ReceiveNbMsg (nbPriv, nbHeld, nbTotal);
                  }
                  break;
            case FBB_STATUS:
                  {
                        int MemUsed, MemAvail, Disk1, Disk2;

                        scan[len] = '\0';
                        sscanf (scan, "%d %d %d %d",
                                    &MemUsed, &MemAvail, &Disk1, &Disk2);
                        ReceiveStatus (MemUsed, MemAvail, Disk1, Disk2);
                  }
                  break;
            case FBB_NBCNX:
                  scan[len] = '\0';
                  ReceiveNbCh (atoi (scan));
                  break;
            case FBB_LISTCNX:
                  scan[len] = '\0';
                  ReceiveList (atoi (scan + 1), scan);
                  break;
            case FBB_XFBBX:
                  switch (scan[0])
                  {
                  case 0:
                        /* Deconnecte */
                        HideFbbWindow (CONSOLE, toplevel);
                        conf[curconf].mask &= ~FBB_CONSOLE;
                        break;
                  case 1:
                        /* Connecte */
                        conf[curconf].mask |= FBB_CONSOLE;
                        ShowFbbWindow (CONSOLE, toplevel);
                        break;
                  case 2:
                        /* Console busy */
                        conf[curconf].mask &= ~FBB_CONSOLE;
                        MessageBox (0,
                                          "Remote console is already connected", "Connect",
                                          MB_OK | MB_ICONEXCLAMATION);
                        break;
                  }
                  end_wait ();
                  break;
            }

            scan[len] = save;

            scan += len;
            nb -= len;
      }

      if (nb > 0)
      {
            int i;

            /* All data was not received. */
            /* Copy the rest to the beginning of the buffer */
            for (i = 0; i < nb; i++)
                  buffer[i] = scan[i];
      }

      pos = nb;

      --in_input;

      return 0;
}

int init_orb (char *msg)
{
      char buffer[300];
      int sock;
      int console;
      int channel;
      int nb;
      char key[256];

      XmListDeleteAllItems (ConnectList);
      cursor_wait ();

      /* End the current connection */
      close_connection ();

      console = 0;
      channel = 0;
      filter = 0;

      sock = open_connection (conf[curconf].host, conf[curconf].port, conf[curconf].mask);

      if (sock == -1)
      {
            sprintf (msg, "Cannot connect xfbbd at %s:%d", conf[curconf].host, conf[curconf].port);
            Caption (1);
            end_wait ();
            return 0;
      }

      sprintf (buffer, "%d %d %s\n", conf[curconf].mask, channel, conf[curconf].mycall);
      write (sock, buffer, strlen (buffer));

      nb = read (sock, buffer, 20);
      if (nb <= 0)
      {
            sprintf (msg, "Connection closed");
            close (sock);
            Caption (1);
            end_wait ();
            return (0);
      }

      buffer[nb] = '\0';
      sscanf (buffer, "%s", key);

      makekey (key, conf[curconf].pass, buffer);
      strcat (buffer, "\n");
      write (sock, buffer, strlen (buffer));

      InputId = XtAppAddInput (app_context, sock, (XtPointer) XtInputReadMask, (XtInputCallbackProc) orb_input, NULL);

      fbb_sock = sock;
      first = 1;

      XmToggleButtonSetState (MsgsToggle, ((conf[curconf].mask & FBB_MSGS) != 0), True);
      XmToggleButtonSetState (StatusToggle, ((conf[curconf].mask & FBB_STATUS) != 0), True);
      Caption (1);

      /* Open windows depending of the mask */
      if (conf[curconf].mask & FBB_MONITOR)
            ShowFbbWindow (MONITOR, toplevel);
      else
            HideFbbWindow (MONITOR, toplevel);
      if (conf[curconf].mask & FBB_CHANNEL)
            ShowFbbWindow (ALLCHAN, toplevel);
      else
            HideFbbWindow (ALLCHAN, toplevel);

      end_wait ();

      return (1);
}

int console_input (char *buffer, int len)
{
      int i;

      for (i = 0; i < len; i++)
            if (buffer[i] == '\r')
                  buffer[i] = '\n';
      write (fbb_sock, buffer, len);
      return (1);
}

#include <X11/cursorfont.h>
void cursor_wait (void)
{
      static Cursor lcursor = 0;

      if (lcursor == 0)
      {
            lcursor = XCreateFontCursor (XtDisplay (toplevel), XC_watch);
      }

      XDefineCursor (XtDisplay (toplevel), XtWindow (toplevel), lcursor);
      XFlush (XtDisplay (toplevel));
}

void end_wait (void)
{
      XUndefineCursor (XtDisplay (toplevel), XtWindow (toplevel));
}

void DialogHelpCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      *((int *) client_data) = 2;
}

void DialogOkCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      *((int *) client_data) = 1;
}

void DialogCancelCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      *((int *) client_data) = 0;
}

void RaiseEV (Widget w, XtPointer client_data, XEvent * event)
{
      if (event->type != VisibilityNotify)
            return;
      XRaiseWindow (XtDisplay (w), XtWindow (XtParent (w)));
}

int MessageBox (int sec, char *texte, char *titre, int flags)
{
      Arg args[20];
      Cardinal n;
      Widget dialog;
      XEvent event;
      XmString string;
      int type;
      time_t temps;

      int retour = -1;

      n = 0;
      XtSetArg (args[n], XmNautoUnmanage, FALSE);
      n++;
      XtSetArg (args[n], XmNtitle, titre);
      n++;
      dialog = XmCreateMessageDialog (toplevel, "Warning", args, n);
      XtAddCallback (dialog, XmNokCallback, DialogOkCB, (XtPointer) & retour);
      XtAddCallback (dialog, XmNcancelCallback, DialogCancelCB, (XtPointer) & retour);
      XtAddCallback (dialog, XmNhelpCallback, DialogHelpCB, (XtPointer) & retour);
      XtAddEventHandler (dialog, VisibilityChangeMask, FALSE,
                                 (XtEventHandler) RaiseEV, NULL);

      switch (flags & 0xf0)
      {
      case 0x10:
            type = XmDIALOG_ERROR;
            break;
      case 0x20:
            type = XmDIALOG_QUESTION;
            break;
      case 0x30:
            type = XmDIALOG_WARNING;
            break;
      case 0x40:
            type = XmDIALOG_INFORMATION;
            break;
      default:
            type = XmDIALOG_MESSAGE;
            break;
      }

      string = XmStringCreateSimple ("No");

      n = 0;
      XtSetArg (args[n], XmNdialogType, type);
      n++;
      XtSetArg (args[n], XmNhelpLabelString, string);
      n++;
      XtSetValues (dialog, args, n);

      XmStringFree (string);

      flags &= 0xf;
      if (flags == MB_OK)
      {
            XtUnmanageChild (XmMessageBoxGetChild (dialog, XmDIALOG_CANCEL_BUTTON));
            XtUnmanageChild (XmMessageBoxGetChild (dialog, XmDIALOG_HELP_BUTTON));
      }
      else if (flags == MB_OKCANCEL)
      {
            XtUnmanageChild (XmMessageBoxGetChild (dialog, XmDIALOG_HELP_BUTTON));
      }
      else
      {
            /* YESNO et YESNOCANCEL */
            string = XmStringCreateSimple ("Yes");
            n = 0;
            XtSetArg (args[n], XmNokLabelString, string);
            n++;
            XtSetValues (dialog, args, n);
            XmStringFree (string);
            if (flags == MB_YESNO)
            {
                  XtUnmanageChild (XmMessageBoxGetChild (dialog, XmDIALOG_CANCEL_BUTTON));
            }
      }

      string = XmStringCreateSimple (texte);
      n = 0;
      XtSetArg (args[n], XmNmessageString, string);
      n++;
      XtSetValues (dialog, args, n);
      XmStringFree (string);

      XtManageChild (dialog);

      XtAddGrab (dialog, TRUE, TRUE);

      if (sec > 0)
      {
            temps = time (NULL) + (time_t) sec;
      }
      else
      {
            temps = 0;
      }

      while (retour == -1)
      {
            if (XtAppPending (app_context))
            {
                  XtAppNextEvent (app_context, &event);
                  XtDispatchEvent (&event);
            }
            else
                  usleep (100000);

            if ((temps) && (temps < time (NULL)))
            {
                  retour = 1;
                  break;
            }
      }

      XtRemoveGrab (dialog);
      XtUnmanageChild (dialog);
      XtDestroyWidget (XtParent (dialog));

      return (retour);
}

static void sig_fct (int sig)
{
      int pid, pstatus;

      sig &= 0xff;
      printf ("Signal received = %d\n", sig);
      pid = wait (&pstatus);
      signal (sig, sig_fct);

      switch (sig)
      {
      case SIGHUP:
            /* reload system files */
            break;
      case SIGTERM:
            /* end of session */
            exit (0);
            break;
      case SIGBUS:
            /* end of session */
            fprintf (stderr, "xfbbd : Bus error\n");
            exit (5);
            break;
      case SIGSEGV:
            /* end of session */
            fprintf (stderr, "xfbb : Segmentation violation\n");
            exit (5);
            break;
      }
}

int SetChList (int clean)
{
      return 1;
}

int GetChList (void)
{
      return 1;
}

static int cherche_pos (int ch, int *items)
{
      int i;

      for (i = 1; i < TOTVOIES + 1; i++)
      {
            if (items[i] == ch)
                  return (i);
      }
      return (0);
}

static int insere_pos (int ch, int *items)
{
      int i;
      int pos = 0;

      for (i = 1; i < TOTVOIES + 1; i++)
      {
            if ((items[i] > ch) || (items[i] == 0))
            {
                  pos = i;
                  break;
            }
      }

      for (i = TOTVOIES; i > pos; i--)
      {
            items[i] = items[i - 1];
      }

      items[pos] = ch;

      return (pos);
}

static void delete_pos (int position, int *items)
{
      int i;

      for (i = position; i < TOTVOIES + 1; i++)
      {
            items[i] = items[i + 1];
      }
}

void ConnectItem (int ch, char *texte)
{
      static int items[TOTVOIES + 1];
      int pos;
      XmString str;

      if (ch <= 0)
            return;

      if (*texte == '<')
            str = XmStringGenerate (texte + 1, NULL, XmCHARSET_TEXT, "RC");
      else if (*texte == '>')
            str = XmStringGenerate (texte + 1, NULL, XmCHARSET_TEXT, "BC");
      else
            str = XmStringGenerate (texte + 1, NULL, XmCHARSET_TEXT, "NO");

      pos = cherche_pos (ch, items);

      if (texte[3])
      {
            if (pos)
            {
                  /* Mise a jour */
                  XmListReplaceItemsPos (ConnectList, &str, 1, pos);
            }
            else
            {
                  /* Creation */
                  pos = insere_pos (ch, items);
                  XmListAddItemUnselected (ConnectList, str, pos);
            }
      }
      else if (pos)
      {
            /* supression */
            XmListDeletePos (ConnectList, pos);
            delete_pos (pos, items);
      }

      XmStringFree (str);

}

static Pixel CreeCouleur (Widget w, int couleur)
{
      XColor tcolor;

      tcolor.pixel = 0;
      tcolor.red = ((couleur >> 16) & 0xff) << 8;
      tcolor.green = ((couleur >> 8) & 0xff) << 8;
      tcolor.blue = (couleur & 0xff) << 8;
      tcolor.flags = DoRed | DoGreen | DoBlue;
      if (XAllocColor (XtDisplay(w), DefaultColormapOfScreen(XtScreen(w)), &tcolor))
            return (tcolor.pixel);
      return couleur;
}

static XmRendition CreeCouleurRendition (Widget w, Pixel couleur, char *nom)
{
      Arg args[10];
      Cardinal n;

      n = 0;
      XtSetArg (args[n], XmNrenditionForeground, couleur);
      n++;
      return XmRenditionCreate (w, nom, args, n);
}

void CreateRendition (Widget w)
{
      r_index = 0;

      XtVaGetValues (form, XmNbackground, &df_pixel, NULL);

      rc_pixel = CreeCouleur (w, 0xff0000);
      r_rend[r_index++] = CreeCouleurRendition (w, rc_pixel, "RC");
      vc_pixel = CreeCouleur (w, 0x00ff00);
      r_rend[r_index++] = CreeCouleurRendition (w, vc_pixel, "VC");
      bc_pixel = CreeCouleur (w, 0x0000ff);
      r_rend[r_index++] = CreeCouleurRendition (w, bc_pixel, "BC");
      no_pixel = CreeCouleur (w, 0x000000);
      r_rend[r_index++] = CreeCouleurRendition (w, no_pixel, "NO");
      rf_pixel = CreeCouleur (w, 0x800000);
      r_rend[r_index++] = CreeCouleurRendition (w, rf_pixel, "RF");
      vf_pixel = CreeCouleur (w, 0x008000);
      r_rend[r_index++] = CreeCouleurRendition (w, vf_pixel, "VF");
      bf_pixel = CreeCouleur (w, 0x000080);
      r_rend[r_index++] = CreeCouleurRendition (w, bf_pixel, "BF");
}

void ToolIcons (void)
{
      int i;
      int connected = is_connected ();
      static int OldIconState[NB_ICON];
      int IconState[NB_ICON];

      static int conn = 0;
      static int first = 1;
      static Pixel TopShadow;
      static Pixel BottomShadow;

      if (!comm_ok)
            return;

      if (first)
      {
            XtVaGetValues (BIcon[0],
                                 XmNtopShadowColor, &TopShadow,
                                 XmNbottomShadowColor, &BottomShadow,
                                 NULL);
            XtSetSensitive (BIcon[15], TRUE);
            first = 0;
      }

      if (connected != conn)
      {
            conn = connected;
            XtSetSensitive (BIcon[0], connected);
            XtSetSensitive (BIcon[2], connected);
            XtSetSensitive (BIcon[3], connected);

            XtSetSensitive (MCons, connected);
            XtSetSensitive (MMon, connected);
            XtSetSensitive (MAllc, connected);
      }

      for (i = 0; i < NB_ICON; i++)
            IconState[i] = FALSE;

      IconState[0] = fenetre[CONSOLE];
      IconState[2] = fenetre[MONITOR];
      IconState[3] = fenetre[ALLCHAN];
      IconState[15] = TRUE;

      for (i = 0; i < NB_ICON; i++)
      {
            if (BIcon[i] == NULL)
                  continue;

            if (OldIconState[i] != IconState[i])
            {
                  if (i < 4)
                  {
                        if (IconState[i])
                        {
                              XtVaSetValues (BIcon[i],
                                                   XmNtopShadowColor, BottomShadow,
                                                   XmNbottomShadowColor, TopShadow,
                                                   NULL);
                        }
                        else
                        {
                              XtVaSetValues (BIcon[i],
                                                   XmNtopShadowColor, TopShadow,
                                                   XmNbottomShadowColor, BottomShadow,
                                                   NULL);
                        }
                  }

                  OldIconState[i] = IconState[i];
            }
      }
}

void Caption (int update)
{
      time_t temps;
      struct tm tmg;
      struct tm tml;
      char buf[80];
      char conn[80];
      static int lmin = -1;

      if (update)
            lmin = -1;

      temps = time (NULL);
      tmg = *(gmtime (&temps));
      tml = *(localtime (&temps));
      if (tmg.tm_min != lmin)
      {
            if (is_connected ())
                  sprintf (conn, "%s (%s:%d)", conf[curconf].name, conf[curconf].host, conf[curconf].port);
            else
                  sprintf (conn, "%s : not connected", conf[curconf].name);
            lmin = tmg.tm_min;
            sprintf (buf, "XFBB - %s - %s - %02d:%02d UTC",
                         conf[curconf].mycall, conn,
                         tmg.tm_hour, tmg.tm_min);
            XtVaSetValues (toplevel, XmNtitle, buf, NULL);
      }
}


void ItemCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void ActiveListCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      CurrentSelection = GetChList ();
}

void SelectListCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      CurrentSelection = GetChList ();
      if (CurrentSelection != -1)
      {
            /* Selection d'un canal */
            /* ShowFbbWindow(CurrentSelection, toplevel); */
      }
}

void ConsoleCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      char buffer[3];

      /* Connexion en console */
      cursor_wait ();

      /* Demande de connexion */
      if (conf[curconf].mask & FBB_CONSOLE)
            conf[curconf].mask &= ~FBB_CONSOLE;
      else
            conf[curconf].mask |= FBB_CONSOLE;
      buffer[0] = 0;
      buffer[1] = 0;
      buffer[2] = (char) conf[curconf].mask;
      write (fbb_sock, buffer, 3);
}

void GatewayCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      /* ShowFbbWindow(CONSOLE, toplevel); */
}

void AllChanCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      char buffer[3];

      if (!fenetre[ALLCHAN])
      {
            conf[curconf].mask |= FBB_CHANNEL;
            ShowFbbWindow (ALLCHAN, toplevel);
      }
      else
      {
            conf[curconf].mask &= ~FBB_CHANNEL;
            HideFbbWindow (ALLCHAN, toplevel);
      }
      buffer[0] = 0;
      buffer[1] = 0;
      buffer[2] = (char) conf[curconf].mask;
      write (fbb_sock, buffer, 3);
}

void OneChanCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void DisconnectCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void DisconnectConsole (void)
{
      HideFbbWindow (CONSOLE, toplevel);
}

void MonitorCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      char buffer[3];

      if (!fenetre[MONITOR])
      {
            conf[curconf].mask |= FBB_MONITOR;
            ShowFbbWindow (MONITOR, toplevel);
      }
      else
      {
            conf[curconf].mask &= ~FBB_MONITOR;
            HideFbbWindow (MONITOR, toplevel);
      }
      buffer[0] = 0;
      buffer[1] = 0;
      buffer[2] = (char) conf[curconf].mask;
      write (fbb_sock, buffer, 3);
}

void ScanSysCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      cursor_wait ();
      end_wait ();
}

void ScanMsgCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      printf ("ScanMsg = %d\n",
                  ((XmToggleButtonCallbackStruct *) call_data)->set);
}

void EditFileCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void ListCnxCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void EditUsrCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void EditMsgCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void PendingCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void StatMemCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      /* Infos status */
      int flag = (((XmToggleButtonCallbackStruct *) call_data)->set != 0);
      char buffer[4];

      if (flag)
      {
            conf[curconf].mask |= FBB_STATUS;
            XtMapWidget (TxtUsed);
            XtMapWidget (TxtGMem);
            XtMapWidget (TxtDisk1);
            XtMapWidget (TxtDisk2);
            XtMapWidget (Used);
            XtMapWidget (GMem);
            XtMapWidget (Disk1);
            XtMapWidget (Disk2);
      }
      else
      {
            conf[curconf].mask &= ~FBB_STATUS;
            XtUnmapWidget (TxtUsed);
            XtUnmapWidget (TxtGMem);
            XtUnmapWidget (TxtDisk1);
            XtUnmapWidget (TxtDisk2);
            XtUnmapWidget (Used);
            XtUnmapWidget (GMem);
            XtUnmapWidget (Disk1);
            XtUnmapWidget (Disk2);
      }
      buffer[0] = 0;
      buffer[1] = 0;
      buffer[2] = (char) conf[curconf].mask;
      write (fbb_sock, buffer, 3);

      ReceiveStatus (0, 0, 0, 0);
      PutConfig ();
}

void StatMsgCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      /* Infos Messages */
      int flag = (((XmToggleButtonCallbackStruct *) call_data)->set != 0);
      char buffer[4];

      if (flag)
      {
            conf[curconf].mask |= FBB_MSGS;

            XtMapWidget (TxtMsgs);
            XtMapWidget (TxtHold);
            XtMapWidget (TxtPriv);
            XtMapWidget (Msgs);
            XtMapWidget (Hold);
            XtMapWidget (Priv);
      }
      else
      {
            conf[curconf].mask &= ~FBB_MSGS;

            XtUnmapWidget (TxtMsgs);
            XtUnmapWidget (TxtHold);
            XtUnmapWidget (TxtPriv);
            XtUnmapWidget (Msgs);
            XtUnmapWidget (Hold);
            XtUnmapWidget (Priv);
      }
      buffer[0] = 0;
      buffer[1] = 0;
      buffer[2] = (char) conf[curconf].mask;
      write (fbb_sock, buffer, 3);

      ReceiveNbMsg (0, 0, 0);
      PutConfig ();
}

void InfoDialog (Widget w, XtPointer client_data, XtPointer call_data)
{
}


void RemoteCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      char msg[256];
      int val = (int) client_data;
      int flag = (((XmToggleButtonCallbackStruct *) call_data)->set != 0);

      if (val == curconf)
            return;

      if (flag == 0)
            return;

      curconf = (int) client_data;
      PutConfig ();
      init_orb (msg);
}

void TalkToCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void MaintCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void RerunCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void ExitCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      exit (0);
}

void StopCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void ConnectCB (Widget w, XtPointer client_data, XtPointer call_data)
{
}

void PrintCB (Widget w, XtPointer client_data, XtPointer call_data)
{
      print = !print;

      printf ("print = %d\n", print);
}

void LabelSetString (Widget label, char *text, char *attr)
{
      Arg args[10];
      Cardinal n = 0;
      XmString string;

      if (text == NULL)
            return;

      if (attr)
            string = XmStringGenerate (text, NULL, XmCHARSET_TEXT, attr);
      else
            string = XmStringCreateSimple (text);
      n = 0;
      XtSetArg (args[n], XmNlabelString, string);
      n++;
      XtSetValues (label, args, n);
      XmStringFree (string);
}

void FHelpCB (Widget w, XtPointer client_data, XEvent * event)
{
      static XmString prev = NULL;

      if (client_data)
      {
            XmString string;

            if (prev)
                  XmStringFree (prev);
            XtVaGetValues (Footer, XmNlabelString, &prev, NULL);

            string = XmStringCreateSimple ((char *) client_data);
            XtVaSetValues (Footer, XmNlabelString, string, NULL);
            XmStringFree (string);
            foothelp = TRUE;
      }
      else
      {
            if (prev)
                  XtVaSetValues (Footer, XmNlabelString, prev, NULL);
            foothelp = FALSE;
      }
}

Widget add_item (int type, Widget menu_pane, char *nom,
                         XtCallbackProc callback, XtPointer data,
                         char *help, XtEventHandler HelpCB)
{
      Arg args[10];
      Cardinal n = 0;
      Widget bouton = NULL;

      if ((callback == NULL) && (type != SEPARATOR) && (type != TOOLBUTTON))
      {
            XtSetArg (args[n], XmNsensitive, False);
            n++;
      }

      switch (type)
      {
      case SEPARATOR:
            bouton = XmCreateSeparator (menu_pane, nom, args, n);
            break;
      case BUTTON:
            bouton = XmCreatePushButton (menu_pane, nom, args, n);
            if (callback)
                  XtAddCallback (bouton, XmNactivateCallback, callback, data);
            break;
      case TOGGLE:
            XtSetArg (args[n], XmNvisibleWhenOff, True);
            n++;
            bouton = XmCreateToggleButton (menu_pane, nom, args, n);
            if (callback)
                  XtAddCallback (bouton, XmNvalueChangedCallback, callback, data);
            break;
      case RADIO:
            XtSetArg (args[n], XmNvisibleWhenOff, False);
            n++;
            bouton = XmCreateToggleButton (menu_pane, nom, args, n);
            if (callback)
                  XtAddCallback (bouton, XmNvalueChangedCallback, callback, data);
            break;
      case TOOLBUTTON:
            if (nom[0] != ' ')
            {
                  XtSetArg (args[n], XmNlabelType, XmPIXMAP);
                  n++;
            }
            XtSetArg (args[n], XmNhighlightThickness, 0);
            n++;
            XtSetArg (args[n], XmNsensitive, FALSE);
            n++;
            bouton = XmCreatePushButton (menu_pane, nom, args, n);
            if (callback)
                  XtAddCallback (bouton, XmNactivateCallback, callback, data);
            break;
      }

      if (help)
      {
            XtAddEventHandler (bouton, EnterWindowMask, FALSE,
                                       HelpCB, (XtPointer) help);
            XtAddEventHandler (bouton, LeaveWindowMask, FALSE,
                                       HelpCB, NULL);
      }
      XtManageChild (bouton);
      return (bouton);
}

void AddRT (Widget w)
{
      XmRenderTable rt;

      XtVaGetValues (w, XmNrenderTable, &rt, NULL, NULL);

      /* Make a copy so that setvalues will work correctly */
      rt = XmRenderTableCopy (rt, NULL, 0);
      rt = XmRenderTableAddRenditions (rt, r_rend, r_index, XmMERGE_NEW);
      XtVaSetValues (w, XmNrenderTable, rt, NULL, NULL);
      XmRenderTableFree (rt);
}

/* Translations */
static void HelpAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
      AboutDialog (w, NULL, NULL);
}

static void ConsoleAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
      ConsoleCB (w, NULL, NULL);
}

static void DisconnAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
      DisconnectCB (w, NULL, NULL);
}

static void PendingAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
}

static void MonitorAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
      MonitorCB (w, NULL, NULL);
}

static void SetCallAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
      CallsignDialog (w, NULL, NULL);
}

static void ProgTncAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
}

static void GatewayAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
      GatewayCB (w, NULL, NULL);
}

static void TalkToAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
      TalkToCB (w, NULL, NULL);
}

static void MsgScanAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
      TalkToCB (w, NULL, NULL);
}

static void EditorAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
}

static void ListCnxAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
}

static void SndTextAct (Widget w, XEvent * event, String * parms, Cardinal * num)
{
      printf ("SndText <%s>\n", parms[0]);
}

Boolean KernelWorkProc (XtPointer data)
{
      ToolIcons ();
      Caption (0);
      usleep (10);
      return (FALSE);
}

int main (int ac, char **av)
{
      Pixmap pixmap;
      Widget bouton;
      Arg args[20];
      Cardinal n;
      XmString string;
      int i;
      Atom DelWindow;
      Widget FormRC;
      char msg[256];
      int res;

      CurrentSelection = -1;
      p_fptr = NULL;

      for (i = 1; i < NSIG; i++)
      {
            signal (i, sig_fct);
      }


      XtToolkitInitialize ();

      app_context = XtCreateApplicationContext ();

      display = XtOpenDisplay (app_context, NULL, av[0], "xfbbX",
                                           NULL, 0, &ac, av);
      if (display == NULL)
      {
            XtWarning ("xfbb : cannot open display, exiting...");
            exit (0);
      }

      XtAppAddActions (app_context, actionsTable, XtNumber (actionsTable));

      toplevel = XtAppCreateShell (av[0], "xfbbX",
                                                 applicationShellWidgetClass,
                                                 display, NULL, 0);

      fenetre[CONSOLE] = fenetre[MONITOR] = fenetre[ALLCHAN] = 0;

      n = 0;
      XtSetArg (args[n], XmNallowShellResize, True);
      n++;
      XtSetArg (args[n], XmNdeleteResponse, XmDO_NOTHING);
      ++n;
      XtSetValues (toplevel, args, n);

      DelWindow = XInternAtom (XtDisplay (toplevel), "WM_DELETE_WINDOW", FALSE);
      XmAddWMProtocolCallback (toplevel, DelWindow, ExitCB, NULL);

      n = 0;
      XtSetArg (args[n], XmNmarginHeight, 5);
      n++;
      XtSetArg (args[n], XmNmarginWidth, 5);
      n++;
      form = XmCreateForm (toplevel, "form", args, n);

      CreateRendition (toplevel);

      n = 0;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);
      n++;
      MenuBar = XmCreateMenuBar (form, "menu_bar", args, n);
      XtManageChild (MenuBar);

      n = 0;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNtopWidget, MenuBar);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNorientation, XmHORIZONTAL);
      n++;

      ToolBar = XmCreateRowColumn (form, "tool_bar", args, n);

      /* Initialisation des boutons du menubar */
      bouton = 0;

      n = 0;
      XtSetArg (args[0], XmNradioBehavior, True);
      MenuFile = XmCreatePulldownMenu (MenuBar, "file", args, 0);
      MenuWindow = XmCreatePulldownMenu (MenuBar, "window", args, 0);
      MenuRemote = XmCreatePulldownMenu (MenuBar, "remote", args, 1);
      MenuConfig = XmCreatePulldownMenu (MenuBar, "config", args, 0);
      MenuHelp = XmCreatePulldownMenu (MenuBar, "help", args, 0);

      XtSetArg (args[0], XmNsubMenuId, MenuFile);
      bouton = XmCreateCascadeButton (MenuBar, "file", args, 1);
      XtManageChild (bouton);

      XtSetArg (args[0], XmNsubMenuId, MenuWindow);
      bouton = XmCreateCascadeButton (MenuBar, "window", args, 1);
      XtManageChild (bouton);

      XtSetArg (args[0], XmNsubMenuId, MenuRemote);
      bouton = XmCreateCascadeButton (MenuBar, "remote", args, 1);
      XtManageChild (bouton);

      XtSetArg (args[0], XmNsubMenuId, MenuConfig);
      bouton = XmCreateCascadeButton (MenuBar, "config", args, 1);
      XtManageChild (bouton);

      XtSetArg (args[0], XmNsubMenuId, MenuHelp);
      bouton = XmCreateCascadeButton (MenuBar, "help", args, 1);
      XtManageChild (bouton);

      /* Bouton help a droite */
      XtVaSetValues (MenuBar, XmNmenuHelpWidget, bouton, NULL);

      XtManageChild (MenuFile);
      XtManageChild (MenuWindow);
      XtManageChild (MenuRemote);
      XtManageChild (MenuConfig);

      add_item (BUTTON, MenuFile, "exit", ExitCB, NULL,
                    "End of the session", (XtEventHandler) FHelpCB);
      MCons = add_item (BUTTON, MenuWindow, "console", ConsoleCB, NULL,
                                "Console connection", (XtEventHandler) FHelpCB);
      MMon = add_item (BUTTON, MenuWindow, "monitoring", MonitorCB, NULL,
                               "Shows monitoring", (XtEventHandler) FHelpCB);
      MAllc = add_item (BUTTON, MenuWindow, "all_channels", AllChanCB, NULL,
                        "Shows the traffic of all users", (XtEventHandler) FHelpCB);
      for (i = 0; i < MAX_CONF; i++)
      {
            char name[20];

            sprintf (name, "xfbb %d", i + 1);
            Rmt[i] = add_item (RADIO, MenuRemote, name,
                                       RemoteCB, (XtPointer) i,
                                    "Select remote xfbb BBS", (XtEventHandler) FHelpCB);
      }

      add_item (BUTTON, MenuConfig, "main_parameters", SetupDialog, NULL,
                  "Main configuration of the software", (XtEventHandler) FHelpCB);
      add_item (BUTTON, MenuHelp, "copyright", CopyDialog, NULL,
                    "Displays copyright informations", (XtEventHandler) FHelpCB);
      add_item (SEPARATOR, MenuHelp, "", NULL, NULL, NULL, NULL);
      add_item (BUTTON, MenuHelp, "about", AboutDialog, NULL,
                    "Informations on WinFBB software", (XtEventHandler) FHelpCB);

      BIcon[0] = add_item (TOOLBUTTON, ToolBar, "B1", ConsoleCB, NULL,
                                     "Console connection", (XtEventHandler) FHelpCB);
      BIcon[2] = add_item (TOOLBUTTON, ToolBar, "B3", MonitorCB, NULL,
                                     "Monitoring window", (XtEventHandler) FHelpCB);
      BIcon[3] = add_item (TOOLBUTTON, ToolBar, "B4", AllChanCB, NULL,
                        "Shows the traffic of all users", (XtEventHandler) FHelpCB);
      add_item (TOOLBUTTON, ToolBar, "                                                    ", NULL, NULL, 
                        " ", NULL);
      BIcon[15] = add_item (TOOLBUTTON, ToolBar, "B16", AboutDialog, NULL,
                                      "On-line help", (XtEventHandler) FHelpCB);

      XtVaSetValues (ToolBar, XmNmenuHelpWidget, BIcon[15], NULL);

      string = XmStringCreateSimple ("  ");
      n = 0;
      XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNlabelString, string);
      n++;
      Footer = XmCreateLabel (form, "footer", args, n);
      XtManageChild (Footer);
      XmStringFree (string);

      n = 0;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNtopWidget, ToolBar);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      ConnectLabel = XmCreateLabel (form, "list_label", args, n);
      AddRT (ConnectLabel);
      XtManageChild (ConnectLabel);

      n = 0;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNtopWidget, ConnectLabel);
      n++;
      XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNbottomAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNbottomWidget, Footer);
      n++;
      StatForm = XmCreateForm (form, "stat_form", args, n);
      XtManageChild (StatForm);

      n = 0;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNtopWidget, ConnectLabel);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNrightAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNrightWidget, StatForm);
      n++;
      XtSetArg (args[n], XmNbottomAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNbottomWidget, Footer);
      n++;
      ListForm = XmCreateForm (form, "list_form", args, n);
      XtManageChild (ListForm);

      string = XmStringCreateSimple ("Ch Callsign  Start Time  Rt Buf C/Fwd");
      n = 0;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNlabelString, string);
      n++;
      ConnectString = XmCreateLabel (ListForm, "list_label", args, n);
      XmStringFree (string);

      n = 0;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNtopWidget, ConnectString);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNhighlightThickness, 0);
      n++;
      XtSetArg (args[n], XmNscrollBarDisplayPolicy, XmSTATIC);
      n++;
      ConnectList = XmCreateScrolledList (ListForm, "connect_list", args, n);
      XtAddCallback (ConnectList, XmNdefaultActionCallback, SelectListCB, NULL);
      XtAddCallback (ConnectList, XmNbrowseSelectionCallback, ActiveListCB, NULL);
      AddRT (ConnectList);

      XtManageChild (ConnectLabel);
      XtManageChild (ConnectString);
      XtManageChild (ConnectList);

      Popup = XmCreatePopupMenu (ConnectList, "popup", NULL, 0);

      PItem[0] = XmCreatePushButtonGadget (Popup, "Talk", NULL, 0);
      PItem[1] = XmCreatePushButtonGadget (Popup, "Show", NULL, 0);
      PItem[2] = XmCreatePushButtonGadget (Popup, "Infos", NULL, 0);
      PItem[3] = XmCreatePushButtonGadget (Popup, "Disconnect", NULL, 0);
      for (i = 0; i < NB_PITEM; i++)
            XtAddCallback (PItem[i], XmNactivateCallback, ItemCB, (XtPointer) i);
      XtManageChildren (PItem, NB_PITEM);

      n = 0;
      XtSetArg (args[n], XmNborderWidth, 0);
      n++;
      XtSetArg (args[n], XmNshadowThickness, 0);
      n++;
      XtSetArg (args[n], XmNhighlightThickness, 0);
      n++;
      XtSetArg (args[n], XmNmarginHeight, 1);
      n++;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNindicatorOn, XmINDICATOR_CHECK_BOX);
      n++;
      XtSetArg (args[n], XmNvisibleWhenOff, True);
      n++;
      StatusToggle = XmCreateToggleButton (StatForm, "status_toggle", args, n);
      XtAddCallback (StatusToggle, XmNvalueChangedCallback, StatMemCB, NULL);
      XtManageChild (StatusToggle);

      n = 0;
      XtSetArg (args[n], XmNborderWidth, 0);
      n++;
      XtSetArg (args[n], XmNshadowThickness, 0);
      n++;
      XtSetArg (args[n], XmNhighlightThickness, 0);
      n++;
      XtSetArg (args[n], XmNmarginHeight, 1);
      n++;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNleftWidget, StatusToggle);
      n++;
      XtSetArg (args[n], XmNindicatorOn, XmINDICATOR_CHECK_BOX);
      n++;
      XtSetArg (args[n], XmNvisibleWhenOff, True);
      n++;
      MsgsToggle = XmCreateToggleButton (StatForm, "message_toggle", args, n);
      XtAddCallback (MsgsToggle, XmNvalueChangedCallback, StatMsgCB, NULL);
      XtManageChild (MsgsToggle);

      n = 0;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_WIDGET);
      n++;
      XtSetArg (args[n], XmNtopWidget, StatusToggle);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNleftOffset, 2);
      n++;
      XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNrightOffset, 2);
      n++;
      XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNshadowThickness, 1);
      n++;
      XtSetArg (args[n], XmNshadowType, XmSHADOW_IN);
      n++;
      FormRC = XmCreateForm (StatForm, "stat_Flist", args, n);
      XtManageChild (FormRC);

      n = 0;
      XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNleftAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNrightAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNbottomAttachment, XmATTACH_FORM);
      n++;
      XtSetArg (args[n], XmNpacking, XmPACK_COLUMN);
      n++;
      XtSetArg (args[n], XmNnumColumns, 2);
      n++;
      StatList = XmCreateRowColumn (FormRC, "stat_list", args, n);
      XtManageChild (StatList);

      n = 0;
      XtSetArg (args[n], XmNmarginHeight, 1);
      n++;
      XtSetArg (args[n], XmNmappedWhenManaged, 0);
      n++;

      TxtUsed = XmCreateLabel (StatList, "txt_used", args, n);
      AddRT (TxtUsed);
      XtManageChild (TxtUsed);

      TxtGMem = XmCreateLabel (StatList, "txt_gmem", args, n);
      AddRT (TxtGMem);
      XtManageChild (TxtGMem);

      TxtDisk1 = XmCreateLabel (StatList, "txt_disk1", args, n);
      AddRT (TxtDisk1);
      XtManageChild (TxtDisk1);

      TxtDisk2 = XmCreateLabel (StatList, "txt_disk2", args, n);
      AddRT (TxtDisk2);
      XtManageChild (TxtDisk2);

      TxtResync = XmCreateLabel (StatList, "", args, n);
      AddRT (TxtResync);
      XtManageChild (TxtResync);

      TxtState = XmCreateLabel (StatList, "", args, n);
      AddRT (TxtState);
      XtManageChild (TxtState);

      TxtMsgs = XmCreateLabel (StatList, "txt_msgs", args, n);
      AddRT (TxtMsgs);
      XtManageChild (TxtMsgs);

      TxtHold = XmCreateLabel (StatList, "txt_hold", args, n);
      AddRT (TxtHold);
      XtManageChild (TxtHold);

      TxtPriv = XmCreateLabel (StatList, "txt_priv", args, n);
      AddRT (TxtPriv);
      XtManageChild (TxtPriv);

      Used = XmCreateLabel (StatList, "used", args, n);
      AddRT (Used);
      XtManageChild (Used);

      GMem = XmCreateLabel (StatList, "gmem", args, n);
      AddRT (GMem);
      XtManageChild (GMem);

      Disk1 = XmCreateLabel (StatList, "disk1", args, n);
      AddRT (Disk1);
      XtManageChild (Disk1);

      Disk2 = XmCreateLabel (StatList, "disk2", args, n);
      AddRT (Disk2);
      XtManageChild (Disk2);

      Resync = XmCreateLabel (StatList, "", args, n);
      AddRT (Resync);
      XtManageChild (Resync);

      State = XmCreateLabel (StatList, "", args, n);
      AddRT (State);
      XtManageChild (State);

      Msgs = XmCreateLabel (StatList, "msgs", args, n);
      AddRT (Msgs);
      XtManageChild (Msgs);

      Hold = XmCreateLabel (StatList, "hold", args, n);
      AddRT (Hold);
      XtManageChild (Hold);

      Priv = XmCreateLabel (StatList, "private", args, n);
      AddRT (Priv);
      XtManageChild (Priv);

      XtManageChild (ToolBar);
      XtManageChild (form);

      /* Icone de la fenetre */
      pixmap = XCreateBitmapFromData (XtDisplay (toplevel), XtScreen (toplevel)->root,
                                                      fbb_bits, fbb_width, fbb_height);
      XtVaSetValues (toplevel, XmNiconPixmap, pixmap, NULL);

      XtRealizeWidget (toplevel);

      XtSetSensitive (MCons, FALSE);
      XtSetSensitive (MMon, FALSE);
      XtSetSensitive (MAllc, FALSE);

      window_init ();
      set_win_colors ();

      curconf = 0;
      if (!GetConfig ())
            SetupDialog (NULL, NULL, NULL);

      else
      {
            res = init_orb (msg);
            if (res == 0)
            {
                  MessageBox (0, msg, "Client connection",
                                    MB_OK | MB_ICONEXCLAMATION);
                  comm_ok = 0;
                  /* return (res); */
            }
      }

      /* Initialisation sequences */
      XtAppAddWorkProc (app_context, KernelWorkProc, NULL);

      /* Main Loop */
      XtAppMainLoop (app_context);

      /* Never reached */
      return 0;
}

char *itoa (int val, char *buffer, int base)
{
      sprintf (buffer, "%d", val);
      return buffer;
}

char *ltoa (long lval, char *buffer, int base)
{
      sprintf (buffer, "%ld", lval);
      return buffer;
}


#define PROTOTYPES 1
#include "global.h"
#include "md5.h"

static void MD5String (unsigned char *dest, unsigned char *source)
{
      int i;
      MD5_CTX context;
      unsigned char digest[16];
      unsigned int len = strlen (source);

      MD5Init (&context);
      MD5Update (&context, source, len);
      MD5Final (digest, &context);

      *dest = '\0';

      for (i = 0; i < 16; i++)
      {
            char tmp[5];

            sprintf (tmp, "%02X", digest[i]);
            strcat (dest, tmp);
      }
}

static void makekey (char *cle, char *pass, char *buffer)
{
      char source[1024];

      strcpy (source, cle);
      strcat (source, pass);
      MD5String (buffer, source);
}

Generated by  Doxygen 1.6.0   Back to index