processdlg.c

Linux 上的socket嗅探器

/*
 *
 * Copyright (C) 2003 Xiangbin Lee <[e-mail]> <[e-mail]>
 *
 * 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.
 */


#include <stdio.h>
#include <string.h>
#include <time.h>

#include <gtk/gtk.h>

#include  "ache.h"
#include  "processdlg.h"


/* add codes here */

/*----------------------------------------------------*/
#define REG_PROCESS_SIGNAL   0x20A0E2B1

enum
{
    PROCESS_ANI_DISABLE=0,
    PROCESS_ANI_RUNNING=1,
    PROCESS_ANI_ENABLE =2
};


typedef struct _ProcessAniIcon
{
   guint regsignal;
   guint nowtype,runtype;
   gdouble limitA, limitB;
   GtkWidget *noteicon;
}ProcessAniIcon;

typedef struct _ProcessDlgData
{
    gdouble AniProcessIcon_Nowstep;
    gint processdlgTimer;
    GtkWidget *processdlg;
    GtkWidget *processbutbar;
    GtkWidget *processdlgprocess;
    WINPRO_ACHE  AniProcessIcon_Circle;
}ProcessDlgData, *LPProcessDlgData;
                      

WINPRO_ACHE  AniProcessDlg_Circle={"PDG:",};

ProcessDlgData *NewAniDefaultProcessDlg(void)
{
    ProcessDlgData *ret=0;
    ret=MallocWinPro(&AniProcessDlg_Circle,DEFAULT_WINPRO_IDENT,sizeof(ProcessDlgData));
    if(ret!=0)
        memset((void*)ret,0,sizeof(ProcessDlgData));
    return ret;
}

int DelProcessDlg(GtkWidget *processdlg)
{
    ProcessDlgData *lpdata=0;
    lpdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdata!=0)
        FreeAllWinPro(&(lpdata->AniProcessIcon_Circle));
    return FreeWinPro(&AniProcessDlg_Circle,(unsigned long)processdlg);
}

ProcessDlgData *FindProcessDlg(GtkWidget *processdlg)
{
    return FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
}


int DeleteAllProcessDlg(void)
{
   int cldcount=0,freei;
   ProcessDlgData *lpdata;
   cldcount=GetWinProCount(&AniProcessDlg_Circle);
   for(freei=0;freei<cldcount;freei++)
   {
       lpdata=(ProcessDlgData *)NextWinPro(&AniProcessDlg_Circle);
       if(lpdata!=0)
           FreeAllWinPro(&(lpdata->AniProcessIcon_Circle));
   }
   return FreeAllWinPro(&AniProcessDlg_Circle);
}


/* dialog icons */

ProcessAniIcon *AddNewAniProcessIcon(GtkWidget *processdlg, GtkWidget *noteicon)
{
    ProcessAniIcon *ret=0;
    ProcessDlgData *lpdata=0;
    lpdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdata!=0)
    {
        ret=MallocWinPro(&(lpdata->AniProcessIcon_Circle),(unsigned long)noteicon,sizeof(ProcessAniIcon));
        if(ret!=0)
            memset( ret,0,sizeof(ProcessAniIcon));
    }
    return ret;
}

int DelAniProcessIcon(GtkWidget *processdlg,GtkWidget *noteicon)
{
    ProcessDlgData *lpdata=0;
    lpdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdata!=0)
        return FreeWinPro(&(lpdata->AniProcessIcon_Circle),(unsigned long)noteicon);
    return 0;
}

ProcessAniIcon *FindAniProcessIcon(GtkWidget *processdlg,GtkWidget *noteicon)
{
    ProcessAniIcon *ret=0;
    ProcessDlgData *lpdata=0;
    lpdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdata!=0)
        ret = FindWinPro(&(lpdata->AniProcessIcon_Circle), (unsigned long)noteicon);

    return ret ;
}


int DeleteAllAniProcessIcon(GtkWidget *processdlg)
{
    int ret=0;
    ProcessDlgData *lpdata=0;
    lpdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdata!=0)
        ret = FreeAllWinPro(&(lpdata->AniProcessIcon_Circle));
   return ret;
}




void destroy_process_dialog(GtkWidget *processdlg)
{
    ProcessDlgData *lpdata=0;
    lpdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdata!=0)
    {
        if(lpdata->processdlgTimer)
            gtk_timeout_remove (lpdata->processdlgTimer);
    }

	  gtk_grab_remove(processdlg);
	  gtk_widget_destroy(processdlg);

    DeleteAllAniProcessIcon(processdlg);
    DelProcessDlg(processdlg);
}

void set_processdlg_step(GtkWidget *processdlg, gdouble steps)
{
    ProcessDlgData *lpdata=0;
    lpdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdata!=0)
    {
        if(steps>1.00)steps=1.00;
        lpdata->AniProcessIcon_Nowstep=steps;
        gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(lpdata->processdlgprocess),steps);
    }
}

gdouble get_processdlg_step(GtkWidget *processdlg)
{
    gdouble ret=0.0;
    ProcessDlgData *lpdata=0;
    lpdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdata!=0)
    {
       return  lpdata->AniProcessIcon_Nowstep;
    }
    return ret ;
}

void set_poocessdlg_text(GtkWidget *processdlg, gchar *lpstr)
{
    ProcessDlgData *lpdata=0;
    lpdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdata!=0)
    {
       if(lpdata->processdlgprocess!=0)
           gtk_progress_bar_set_text(GTK_PROGRESS_BAR(lpdata->processdlgprocess),(gchar*)lpstr);
    }
}

gint AniProcessTimer(gpointer lpdata)
{
     ProcessAniIcon *lpanicon=0;
     ProcessDlgData *lpdlgdata=0;
     GtkWidget *processdlg = (GtkWidget *)lpdata;
     lpdlgdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
     if(lpdlgdata!=0)
     {
         if(GetWinProCount(&(lpdlgdata->AniProcessIcon_Circle))>0)
         {
             lpanicon=(ProcessAniIcon *)NextWinPro(&(lpdlgdata->AniProcessIcon_Circle));
             if(lpanicon!=0)
             {
                if(lpanicon->regsignal==REG_PROCESS_SIGNAL)
                {
                    switch(lpanicon->nowtype)
                    {
                        case PROCESS_ANI_ENABLE:
                        {
                            if(lpdlgdata->AniProcessIcon_Nowstep<lpanicon->limitA)
                            {
                               lpanicon->nowtype= PROCESS_ANI_DISABLE;
                              if(lpanicon->runtype!=PROCESS_ANI_DISABLE)
                               {
                                  gtk_notebook_set_current_page(GTK_NOTEBOOK(lpanicon->noteicon),0);
                                  lpanicon->runtype=PROCESS_ANI_DISABLE;
                               }

                            }
                            else if(lpdlgdata->AniProcessIcon_Nowstep<lpanicon->limitB)
                               lpanicon->nowtype= PROCESS_ANI_RUNNING;
                            else if(lpanicon->runtype!=PROCESS_ANI_ENABLE)
                            {
                                gtk_notebook_set_current_page(GTK_NOTEBOOK(lpanicon->noteicon),1);
                                lpanicon->runtype=PROCESS_ANI_ENABLE;
                            }
                        }break;
                        case PROCESS_ANI_RUNNING:
                        {
                            if(lpdlgdata->AniProcessIcon_Nowstep<lpanicon->limitA)
                            {
                               lpanicon->nowtype= PROCESS_ANI_DISABLE;
                               if(lpanicon->runtype!=PROCESS_ANI_DISABLE)
                               {
                                  gtk_notebook_set_current_page(GTK_NOTEBOOK(lpanicon->noteicon),0);
                                  lpanicon->runtype=PROCESS_ANI_DISABLE;
                               }
                            }
                            else if(lpdlgdata->AniProcessIcon_Nowstep>lpanicon->limitB)
                            {
                               lpanicon->nowtype= PROCESS_ANI_ENABLE;
                               if(lpanicon->runtype!=PROCESS_ANI_ENABLE)
                               {
                                  gtk_notebook_set_current_page(GTK_NOTEBOOK(lpanicon->noteicon),1);
                                  lpanicon->runtype=PROCESS_ANI_ENABLE;
                               }
                            }
                            else
                            {
                               if(lpanicon->runtype!=PROCESS_ANI_ENABLE)
                               {
                                   gtk_notebook_set_current_page(GTK_NOTEBOOK(lpanicon->noteicon),1);
                                   lpanicon->runtype=PROCESS_ANI_ENABLE;
                               }
                               else
                               {
                                   gtk_notebook_set_current_page(GTK_NOTEBOOK(lpanicon->noteicon),0);
                                   lpanicon->runtype=PROCESS_ANI_DISABLE;
                               }
                            }
                        }break;
                        case PROCESS_ANI_DISABLE:
                        {
                            if(lpdlgdata->AniProcessIcon_Nowstep>=lpanicon->limitB)
                            {
                              lpanicon->nowtype= PROCESS_ANI_ENABLE;
                            }
                            else if(lpdlgdata->AniProcessIcon_Nowstep>=lpanicon->limitA)
                            {
                              lpanicon->nowtype= PROCESS_ANI_RUNNING ;
                            }
                        };
                    };/* switch */
                }/* IF REG_PROCESS_SIGNAL */
             } /* GetCurCircleAche != 0 */
         };/* if*/         

         if(lpdlgdata->AniProcessIcon_Nowstep>=1.00)
         {
            if(processdlg!=0)
               destroy_process_dialog(processdlg);
         }      
         return TRUE ;   
     }// lpdlgdata!=0
     
     return FALSE;
}

GtkWidget *add_processdlg_icon(
     GtkWidget *processdlg,
     gdouble lower, gdouble uper,
     gchar *fenico, gchar *fdisico)
{
    ProcessDlgData *lpdlgdata=0;
    lpdlgdata=FindWinPro(&AniProcessDlg_Circle, (unsigned long)processdlg);
    if(lpdlgdata!=0)
    {
        ProcessAniIcon *lpAnico=0;
        GtkWidget *lpicon, *label, *notebook;
        if(lpdlgdata->processdlg==0||lpdlgdata->processbutbar==0||lpdlgdata->processdlgprocess==0)
            return 0;

        notebook=gtk_notebook_new();
        lpAnico=AddNewAniProcessIcon(processdlg,notebook);
        lpAnico->regsignal=REG_PROCESS_SIGNAL;
        lpAnico->nowtype=PROCESS_ANI_DISABLE;
        lpAnico->runtype=PROCESS_ANI_DISABLE;
        lpAnico->limitA=lower;
        lpAnico->limitB=uper;

        lpAnico->noteicon = notebook;
        gtk_notebook_set_tab_pos(GTK_NOTEBOOK(lpAnico->noteicon),GTK_POS_BOTTOM);
        gtk_notebook_set_show_tabs(GTK_NOTEBOOK (lpAnico->noteicon),FALSE );
        gtk_notebook_set_show_border(GTK_NOTEBOOK(lpAnico->noteicon),FALSE );

        lpicon = gtk_image_new_from_file(fdisico);
        label = gtk_label_new ("dis_icon");
	      gtk_notebook_append_page (GTK_NOTEBOOK(lpAnico->noteicon), lpicon, label);

        lpicon = gtk_image_new_from_file(fenico);
        label = gtk_label_new ("en_icon");
	      gtk_notebook_append_page (GTK_NOTEBOOK(lpAnico->noteicon), lpicon, label);

        gtk_notebook_set_current_page(GTK_NOTEBOOK(lpAnico->noteicon),0);
	      gtk_box_pack_start(GTK_BOX(lpdlgdata->processbutbar), lpAnico->noteicon, FALSE, FALSE, 0);

        return lpAnico->noteicon;
    }
    return 0;
}

GtkWidget *get_process_dialog(gchar *backmap)
{
    ProcessDlgData *lpdlgdata=NewAniDefaultProcessDlg();
    if(lpdlgdata!=0)
    {
        GtkWidget *area, *main_vbox, *hpaned;
	      lpdlgdata->processdlg = gtk_window_new(GTK_WINDOW_POPUP);
        ResetWinProIdent(&AniProcessDlg_Circle,DEFAULT_WINPRO_IDENT,(unsigned long)lpdlgdata->processdlg);
        
        gtk_window_set_position(GTK_WINDOW(lpdlgdata->processdlg),GTK_WIN_POS_CENTER);
	      g_signal_connect(GTK_OBJECT(lpdlgdata->processdlg),
		        "delete_event",
		        GTK_SIGNAL_FUNC(destroy_process_dialog),
		        GTK_OBJECT(lpdlgdata->processdlg));
	      gtk_grab_add(lpdlgdata->processdlg);
        /* create area of main picture */
        area=gtk_image_new_from_file(backmap);
        /* create toolbar of the button. */
        lpdlgdata->processbutbar = gtk_hbox_new(FALSE, 2);

        /* create process of the window. */
        lpdlgdata->processdlgprocess= gtk_progress_bar_new();
        gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(lpdlgdata->processdlgprocess),0.000);
        gtk_progress_bar_set_orientation(GTK_PROGRESS_BAR(lpdlgdata->processdlgprocess),GTK_PROGRESS_LEFT_TO_RIGHT);
        gtk_progress_bar_set_text(GTK_PROGRESS_BAR(lpdlgdata->processdlgprocess),"0.0 %%");
        lpdlgdata->AniProcessIcon_Nowstep=0.0;
        /* create window */

        /*  here add dialog to this area info */
        hpaned = gtk_hpaned_new ();
        gtk_paned_add1 (GTK_PANED (hpaned), lpdlgdata->processbutbar);
        gtk_paned_add2 (GTK_PANED (hpaned), lpdlgdata->processdlgprocess);

  	    main_vbox = gtk_vbox_new(FALSE, 2);
	      gtk_box_pack_start(GTK_BOX(main_vbox), area, TRUE, TRUE, 0);
	      gtk_box_pack_start(GTK_BOX(main_vbox), hpaned, FALSE, FALSE, 0);
	      gtk_container_add(GTK_CONTAINER(lpdlgdata->processdlg),main_vbox);

        /* Add a timer callback to update the value of the progress bar */
        lpdlgdata->processdlgTimer =gtk_timeout_add (100, AniProcessTimer, lpdlgdata->processdlg);

        return  lpdlgdata->processdlg;
    }
    return 0;
}