home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / XAP / XFILEMAN / XFILEMAN.TAR / xfilemanager / folder.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-22  |  10.1 KB  |  415 lines
  1. /*
  2.  * Copyright 1993 by Ove Kalkan, Cremlingen, Germany
  3.  *
  4.  * Permission to use, copy, modify, distribute and sell this software and it's
  5.  * documentation for any purpose is hereby granted without fee, rpovided that
  6.  * the above copyright notice and this permission appear in supporting
  7.  * documentation, and that the name of Ove Kalkan not to be used in
  8.  * advertising or publicity pertaining to distributiopn of the software without
  9.  * specific, written prior permission. Ove Kalkan makes no representations
  10.  * about the suitability of this software for any purpose. It is provided
  11.  * as is without express or implied warranty.
  12.  *
  13.  * OVE KALKAN DISPLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  14.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABLILITY AND FITNESS, IN NO
  15.  * EVENT SHALL OVE KALKAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  16.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  17.  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  18.  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  19.  * PERFORMANCE OF THIS SOFTWARE.
  20.  *
  21.  * $Header: filename,v 1.0 yyyy/mm/dd hh:mm:ss loginname Exp $
  22.  */
  23.  
  24. #include "global.h"
  25.  
  26. /*
  27.  * Globale Variablen
  28.  */
  29.  
  30. static    XtTranslations    folder_trans = NULL;
  31.  
  32.  
  33. /*********************************************************
  34.  * name:    newFolder
  35.  * description:    Bei MultiWindow ein neues Folderfenster
  36.  *        erzeugen
  37.  * input:    Dir_Glyph *dir    - Das zugehoerige Dir
  38.  * output:    erweitert die Folderstruktur
  39.  * author:    Ove Kalkan
  40.  * date:    16.6.93
  41.  *********************************************************/
  42. void    newFolder (Dir_Glyph *dir)
  43. {
  44.     Folder_Glyph    *nf;
  45.     Widget        shell;
  46.     Dimension    i;
  47.     unsigned char    type;
  48.  
  49.     if (folder_count + 1 == MAX_FOLDERS) {
  50.         WARNING("Cannot open another folder. Close one before trying again.");
  51.         return;
  52.     }
  53.  
  54.     /*
  55.      * Feststellen, um welche Art Feilsystem es sich handelt
  56.      */
  57.     if (strrstr(dir->name,".tar.z\0") || strrstr(dir->name,".tar.gz\0")
  58.          || strrstr(dir->name,".tar.Z\0") || strrstr(dir->name,".taz\0")
  59.          || strrstr(dir->name,".tpz\0") || strrstr(dir->name,".tgz\0")) {
  60.         type = FS_CTAR;
  61.     }
  62.     else if (strrstr(dir->name,".tar\0")) {
  63.         type = FS_TAR;
  64.     }
  65.     else {
  66.         type = FS_NORMAL;    /* Es handelt sich um ein normales Filesystem */
  67.     }
  68.  
  69.     /*
  70.      * Nachsehen ob nicht bereits ein Folder mit den Directory
  71.      * besteht
  72.      */
  73.     i = 0;
  74.     while (i < folder_count) {
  75.         char    *got1, *got2;
  76.  
  77.         got1 = getPath(folders[i]->dir);
  78.         got2 = getPath(dir);
  79.         if (!strcmp(got1,got2)) {
  80.             free(got1);
  81.             free(got2);
  82.             break;
  83.         }
  84.         free(got1);
  85.         free(got2);
  86.         i++;
  87.     }
  88.  
  89.     if (i == folder_count) {
  90.         /*
  91.          * Folders erweitern
  92.          */
  93.         if (!(nf = (Folder_Glyph *) malloc (sizeof(Folder_Glyph))))
  94.             FATAL_ERROR ("newwFolder: Cannot allocate new Folder\n");
  95.  
  96.         /*
  97.          * neuen folder fuellen
  98.          */
  99.         shell = XtCreatePopupShell ("folder_window", topLevelShellWidgetClass,
  100.                         toplevel, NULL,0);
  101.         nf->fs_type = type;
  102.  
  103.         makeFolderWindow(shell,nf,folder_count);
  104.  
  105.         nf->dir = dir;
  106.         nf->file_count = 0;
  107.         nf->file = NULL;
  108.         nf->filter = NULL;
  109.     }
  110.     else {
  111.         nf = folders[i];
  112.         nf->fs_type = type;
  113.         XRaiseWindow (XtDisplay(nf->shell),XtWindow(nf->shell));
  114.         FILE_CHANGED = TRUE;
  115.     }
  116.  
  117.     /*
  118.      * Feststellen, um welche Art Feilsystem es sich handelt
  119.      */
  120.     if (type == FS_CTAR)
  121.         fillCTar (nf);
  122.     else if (type == FS_TAR)
  123.         fillTar (nf);
  124.     else
  125.         fillFolder (nf);
  126.  
  127.     if (i == folder_count) {
  128.         char    *s = getPath(nf->dir);
  129.         Arg    args[2];
  130.         int    sizex,sizey;
  131.  
  132.         XtManageChild(nf->window);
  133.         XtManageChild(nf->shell);
  134.  
  135.         XStoreName(XtDisplay(nf->shell),XtWindow(nf->shell),
  136.                  (*s == '\0' ? "/" : s));
  137.  
  138.         XSetIconName(XtDisplay(nf->shell),XtWindow(nf->shell),
  139.                  (*s == '\0' ? "/" : s));
  140.         folders[folder_count++] = nf;
  141.  
  142.         sizey = DIR_Y_STEP*(4+nf->file_count) > 748 ? 748 :
  143.                         DIR_Y_STEP*(6+nf->file_count);
  144.         sizex = nf->max_length + 60 < 400 ? 400 :
  145.                         nf->max_length + 60;
  146.         XtSetArg(args[0],XtNheight,sizey);
  147.         XtSetArg(args[1],XtNwidth,sizex);
  148.         XtSetValues(nf->shell,args,1);
  149.     }
  150.  
  151.     XDefineCursor (XtDisplay(nf->window), XtWindow(nf->window), def_cursor);
  152.  
  153.     refresh_files (nf->window,NULL,NULL,NULL);
  154. }
  155.  
  156.  
  157.  
  158.  
  159.  
  160. /*********************************************************
  161.  * name:    makeFolderWindow
  162.  * description:    erzeugt ein Fenster mit einem Folder
  163.  * input:    Widget    parent    - Shellfenster oder pane,
  164.  *                  in dem der Folerder erzeugt
  165.  *                  werden soll
  166.  *        Folder_Glyph    *folder    - Der Folder fuer
  167.  *                      das Fenster
  168.  * output:    Fuellt die angegebene Folder-struktur
  169.  * author:    Ove Kalkan
  170.  * date:    16.6.93
  171.  *********************************************************/
  172. void    makeFolderWindow (Widget parent, Folder_Glyph *folder,Dimension id)
  173. {
  174.     Widget    dummy;
  175.     Arg    args[12];
  176.  
  177.     folder->shell = parent;
  178.     /*
  179.      * Den Bereich fuer das Folder-Fenster
  180.      */
  181.     XtSetArg(args[0],XtNdefaultDistance,0);
  182.     dummy = XtCreateManagedWidget("folder_pane", formWidgetClass,
  183.                       parent, args,1);
  184.  
  185.     XtSetArg(args[0],XtNleft, XawChainLeft);
  186.     XtSetArg(args[1],XtNright, XawChainRight);
  187.     XtSetArg(args[2],XtNtop, XawChainTop);
  188.     XtSetArg(args[3],XtNbottom, XawChainTop);
  189.     XtSetArg(args[4],XtNborderWidth, 0);
  190.     XtSetArg(args[5],XtNwidth, 400);
  191.  
  192.     if (!defaults.multi_window) {
  193.         /*
  194.          * darauf den File_label erzeugen
  195.          */
  196.         folder->label = XtCreateManagedWidget("file_label", 
  197.                               labelWidgetClass,
  198.                               dummy, args,6);
  199.     }
  200.     else {
  201.         Widget    f,b;
  202.  
  203.         /*
  204.          * Eine Form fuer den Hide-Button erzeugen
  205.          */
  206.         f = XtCreateManagedWidget ("folder_form", formWidgetClass,
  207.                        dummy, args, 6);
  208.         folder->label = f;
  209.  
  210.         /*
  211.          * Den Hide-Button erzeugen
  212.          */
  213.         makeIconBar(folder,f,NULL,TRUE,folder->fs_type == FS_NORMAL ? TRUE : FALSE);
  214.     }
  215.     /*
  216.      * Auf dieses field_pane jetzt den Viewport setzen, der das
  217.      * Simple-Widget fuer den Directory-Tree enthalten soll
  218.      */    
  219.     XtSetArg(args[3],XtNbottom, XawChainBottom);
  220.     XtSetArg(args[4],XtNwidth, 400);
  221.     XtSetArg(args[5],XtNheight,400);
  222.     XtSetArg(args[6],XtNallowHoriz, TRUE);
  223.     XtSetArg(args[7],XtNallowVert, TRUE);
  224.     XtSetArg(args[8],XtNforceBars, TRUE);
  225.     XtSetArg(args[9],XtNuseBottom, TRUE);
  226.     XtSetArg(args[10],XtNuseRight, TRUE);
  227.     XtSetArg(args[11],XtNfromVert, folder->label);
  228.     folder->vp = XtCreateManagedWidget("viewport", viewportWidgetClass,
  229.                        dummy, args,12);
  230.  
  231.     /*
  232.      * Auf das Viewport kommt jetzt das Simple-Widget fuer den
  233.      * Directory Tree
  234.      */
  235.     folder->window = XtCreateWidget("file_simple", simpleWidgetClass,
  236.                     folder->vp, args, 2);
  237.     if (!folder_trans) {
  238.         folder_trans = XtParseTranslationTable(
  239.                     "<Leave>: leave-window()\n\
  240.                     <Enter>: enter-window()\n\
  241.                         <Expose>: refresh-files() refresh-multi()\n\
  242.                     <Btn3Down>: start-popup()\n\
  243.                     <Btn1Down>: clear-multi() start-single()\n\
  244.                     <Btn1Motion>: follow-single()\n\
  245.                     <Btn1Up>: end-single()\n\
  246.                     <Btn2Down>: clear-single() start-multi() \n\
  247.                     <Btn2Motion>: follow-multi() \n\
  248.                     <Btn2Up>: end-multi()");
  249.     }
  250.     XtOverrideTranslations(folder->window, folder_trans);
  251.  
  252.     /*
  253.      * Count field
  254.      */
  255.     XtSetArg(args[2],XtNtop, XawChainBottom);
  256.     XtSetArg(args[4],XtNwidth, 400);
  257.     XtSetArg(args[6],XtNfromVert, folder->vp);
  258.     XtSetArg(args[5],XtNborderWidth, 0);
  259.     XtSetArg(args[7],XtNjustify, XtJustifyLeft);
  260.     folder->info = XtCreateManagedWidget("folder_info",labelWidgetClass,dummy,
  261.                         args, 8);
  262.  
  263. }
  264.  
  265.  
  266. /*********************************************************
  267.  * name:    hideFolder
  268.  * description:    loeschen eine Folders vom Bildschirm
  269.  * input:    in client befindet sich ein Zeiger
  270.  *        auf den Folder
  271.  * author:    Ove Kalkan
  272.  * date:    17.6.93
  273.  *********************************************************/
  274. void    hideFolder (Widget w, XtPointer client, XtPointer call)
  275. {
  276.     Folder_Glyph    *fo = (Folder_Glyph *) client;
  277.     Dimension    i = 0;
  278.  
  279. #ifdef DEBUG
  280.     debug("folder.c: Hide Folder\n");
  281. #endif
  282.     /*
  283.      * Id in der Folderliste finden und andere Folder aufruecken lassen
  284.      */
  285.     while (folders[i] != fo)
  286.         i++;
  287.  
  288.     while (i < folder_count - 1) {
  289.         folders[i] = folders[i+1];
  290.         i++;
  291.     }
  292.     folder_count--;
  293.  
  294.     /*
  295.      * Erst einmal das Fenster loeschen
  296.      */
  297.     if (fo == selc_fo) {
  298.         selc_fo = NULL;
  299.         selc_f = 16000;
  300.     }
  301.     if (fo == multi_fo) {
  302.         multi_fo = NULL;
  303.         multi_vs = 16000;
  304.         multi_ve = 16000;
  305.         MULTI = FALSE;
  306.     }
  307.     if (fo == folder)
  308.         folder = NULL;
  309.     XtDestroyWidget (fo->shell);
  310.  
  311. #ifdef DEBUG
  312.     debug("list shruken %d,%s\n",fo->file_count,fo->dir->name);
  313. #endif
  314.     /*
  315.      * die Folder-Struktur loeschen
  316.      */
  317.     for (i = 0; i < fo->file_count; i++) {
  318.         if (fo->file[i]) {
  319.             if (fo->file[i]->name) {
  320. #ifdef DEBUG
  321.                 debug ("%d: (%s)\n",i+1,fo->file[i]->name);
  322. #endif
  323.                 free(fo->file[i]->name);
  324.             }
  325.             free(fo->file[i]);
  326.         }
  327.     }
  328.  
  329.     if (fo->fs_type != FS_NORMAL)
  330.         free(fo->dir);    /* Wenn Tar files, dann kann Directory auch weg */
  331.     free(fo);
  332.  
  333. #ifdef DEBUG
  334.     debug("Folder hidden\n");
  335. #endif
  336. }
  337.  
  338.  
  339. /*
  340.  * name:    refreshFolderByPathname
  341.  * description:    Sucht nach einem Folder in dem das in path angegebene
  342.  *        Directoy dargestellt ist und erneuert diesen.
  343.  * input:    char *path    - Pfad des Directories, das erneuert werden soll.
  344.  * output:    none
  345.  * author:    Ove Kalkan
  346.  * date:    27.6.1993
  347.  */
  348. void    refreshFolderByPathname (char *path)
  349. {
  350.     int    i = 0;
  351.     Boolean    NOTENDE = TRUE;
  352.     char    *path2;
  353.     char    *a;
  354.  
  355.     if (!(path2 = (char *) malloc (strlen(path)+1)))
  356.         FATAL_ERROR ("refreshFolderByPathname: Memoryalloc failed");
  357.     strncpy(path2,path,strlen(path));
  358.     path2[strlen(path)] = '\0';
  359.     a = strrchr(path2,'/');
  360.     if (a)
  361.         *a = '\0';
  362.  
  363.     /*
  364.      * Nachsehen, ob es einen Folder fuer das Directory gibt
  365.      */
  366.     while (i < folder_count) {
  367.         char    *got;
  368.  
  369.         got = getPath(folders[i]->dir);
  370.         if (strcmp(got,path) && strcmp(got,path2))
  371.             i++;
  372.         else {
  373.             if (folders[i] == selc_fo) {
  374.                 selc_fo = NULL;
  375.                 selc_f = 16000;
  376.             }
  377.             else if (folders[i] == multi_fo) {
  378.                 multi_fo = NULL;
  379.                 multi_vs = 16000;
  380.                 multi_ve = 16000;
  381.                 MULTI = FALSE;
  382.             }
  383.             updateFolder(folders[i]);
  384.             i++;
  385.         }
  386.         free(got);
  387.     }
  388.     free(path2);
  389. }
  390.  
  391.  
  392.  
  393. /*********************************************************
  394.  * name:    updateFolder
  395.  * description:    Directory eines Folders neu laden und darstellen
  396.  * input:    Folder_Glyph *folder - Folder der geupdated
  397.  *        werden soll.
  398.  * output:    none
  399.  * author:    Ove Kalkan
  400.  * date:    29.6.93
  401.  *********************************************************/
  402. void    updateFolder    (Folder_Glyph *folder)
  403. {
  404.     if (folder->fs_type == FS_NORMAL)
  405.         fillFolder(folder);
  406.     else if (folder->fs_type == FS_TAR)
  407.         fillTar(folder);
  408.     else
  409.         fillCTar(folder);
  410.  
  411.     FILE_CHANGED = TRUE;
  412.     refresh_files(folder->window,NULL,NULL,NULL);
  413. }
  414.  
  415.