home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 5 / CD_Magazyn_EXEC_nr_5.iso / Programy / Internet / Poczta / YAM22src.lha / YAM_DI.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-11-04  |  11.2 KB  |  307 lines
  1. /***************************************************************************
  2.  
  3.  YAM - Yet Another Mailer
  4.  Copyright (C) 2000  Marcel Beck <mbeck@yam.ch>
  5.  
  6.  This program is free software; you can redistribute it and/or modify
  7.  it under the terms of the GNU General Public License as published by
  8.  the Free Software Foundation; either version 2 of the License, or
  9.  (at your option) any later version.
  10.  
  11.  This program is distributed in the hope that it will be useful,
  12.  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  GNU General Public License for more details.
  15.  
  16.  You should have received a copy of the GNU General Public License
  17.  along with this program; if not, write to the Free Software
  18.  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  
  20.  YAM Official Support Site :  http://www.yam.ch
  21.  YAM OpenSource project    :  http://sourceforge.net/projects/yamos/
  22.  
  23. ***************************************************************************/
  24.  
  25. #include "YAM.h"
  26.  
  27. /***************************************************************************
  28.  Module: Glossary
  29. ***************************************************************************/
  30.  
  31. /// DI_FinishEdit
  32. //  Adds/updates changed glossary entry
  33. void DI_FinishEdit(void)
  34. {
  35.    struct DI_GUIData *gui = &G->DI->GUI;
  36.    int modified;
  37.    get(gui->TE_EDIT, MUIA_TextEditor_HasChanged, &modified);
  38.    if (modified && G->DI->OldEntry)
  39.    {
  40.       char *edtext = (char *)DoMethod((Object *)gui->TE_EDIT, MUIM_TextEditor_ExportText);
  41.       if (*edtext)
  42.       {
  43.          struct Dict new;
  44.          new.Text = StrBufCpy(NULL, edtext);
  45.          GetMUIString(new.Alias, gui->ST_ALIAS);
  46.          if (!*new.Alias) strcpy(new.Alias, GetStr(MSG_NewEntry));
  47.          FreeStrBuf(G->DI->OldEntry->Text);
  48.          *(G->DI->OldEntry) = new;
  49.          DoMethod(gui->LV_ENTRIES, MUIM_List_Redraw, MUIV_List_Redraw_All);
  50.       }
  51.       G->DI->Modified = TRUE;
  52.       FreeVec(edtext);
  53.    }
  54.    set(gui->TE_EDIT, MUIA_TextEditor_HasChanged, FALSE);
  55. }
  56. ///
  57. /// DI_Save
  58. //  Saves glossary to disk
  59. void DI_Save(void)
  60. {
  61.    FILE *fh;
  62.    struct Dict *entry;
  63.    int i;
  64.  
  65.    if (fh = fopen(G->DI_Filename, "w"))
  66.    {
  67.       Busy(GetStr(MSG_BusySavingDI), "", 0, 0);
  68.       fputs("YDI1 - YAM Dictionary\n", fh);
  69.       for (i = 0; ; i++)
  70.       {
  71.          DoMethod(G->DI->GUI.LV_ENTRIES, MUIM_List_GetEntry, i, &entry);
  72.          if (!entry) break;
  73.          fprintf(fh, "@ENTRY %s\n%s@ENDENTRY\n", entry->Alias, entry->Text);
  74.       }
  75.       fclose(fh);
  76.       G->DI->Modified = FALSE;
  77.       BusyEnd;
  78.    }
  79.    else ER_NewError(GetStr(MSG_ER_CantCreateFile), G->DI_Filename, NULL);
  80. }
  81. ///
  82. /// DI_Load
  83. //  Load glossary from disk
  84. int DI_Load(void)
  85. {
  86.    int entries = 0;
  87.    FILE *fh;
  88.    char buffer[SIZE_LARGE], *p;
  89.    struct Dict entry;
  90.  
  91.    if (fh = fopen(G->DI_Filename, "r"))
  92.    {
  93.       Busy(GetStr(MSG_BusyLoadingDI), "", 0, 0);
  94.       GetLine(fh, buffer, SIZE_LARGE);
  95.       if (!strncmp(buffer,"YDI",3))
  96.       {
  97.          set(G->DI->GUI.LV_ENTRIES, MUIA_List_Quiet, TRUE);
  98.          while (GetLine(fh, buffer, SIZE_LARGE))
  99.          {
  100.             clear(&entry, sizeof(struct Dict));
  101.             if (!strncmp(buffer, "@ENTRY", 6))
  102.             {
  103.                stccpy(entry.Alias, Trim(&buffer[7]), SIZE_NAME);
  104.                entry.Text = AllocStrBuf(80);
  105.                while (fgets(buffer, SIZE_LARGE, fh))
  106.                   if (p = strstr(buffer, "@ENDENTRY\n")) { *p = 0; entry.Text = StrBufCat(entry.Text, buffer); break; }
  107.                   else entry.Text = StrBufCat(entry.Text, buffer);
  108.                DoMethod(G->DI->GUI.LV_ENTRIES, MUIM_List_InsertSingle, &entry, MUIV_List_Insert_Bottom);
  109.                entries++;
  110.             }
  111.          }
  112.          set(G->DI->GUI.LV_ENTRIES, MUIA_List_Quiet, FALSE);
  113.       }
  114.       fclose(fh);
  115.       BusyEnd;
  116.    }
  117.    return entries;
  118. }
  119. ///
  120. /// DI_CloseFunc
  121. //  Closes glossary window
  122. SAVEDS void DI_CloseFunc(void)
  123. {
  124.    DI_FinishEdit();
  125.    if (G->DI->Modified) DI_Save();
  126.    G->Weights[4] = GetMUI(G->DI->GUI.GR_LIST, MUIA_HorizWeight);
  127.    G->Weights[5] = GetMUI(G->DI->GUI.GR_TEXT, MUIA_HorizWeight);
  128.    DisposeModulePush(&G->DI);
  129. }
  130. MakeHook(DI_CloseHook, DI_CloseFunc);
  131. ///
  132. /// DI_PasteFunc
  133. //  Pastes text of selected glossary entry into the internal editors
  134. SAVEDS void DI_PasteFunc(void)
  135. {
  136.    struct Dict *entry;
  137.    DI_FinishEdit();
  138.    DoMethod(G->DI->GUI.LV_ENTRIES, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &entry);
  139.    DoMethod(G->WR[G->DI->WrWin]->GUI.TE_EDIT, MUIM_TextEditor_InsertText, entry->Text);
  140.    DI_CloseFunc();
  141. }
  142. MakeHook(DI_PasteHook, DI_PasteFunc);
  143. ///
  144. /// DI_DeleteFunc
  145. //  Removes selected entry from the glossary
  146. SAVEDS void DI_DeleteFunc(void)
  147. {
  148.     G->DI->Modified = TRUE;
  149.     G->DI->OldEntry = NULL;
  150.     DoMethod(G->DI->GUI.LV_ENTRIES, MUIM_List_Remove, MUIV_List_Remove_Active);
  151. }
  152. MakeHook(DI_DeleteHook, DI_DeleteFunc);
  153. ///
  154. /// DI_DisplayFunc
  155. //  Displays selected glossary entry
  156. SAVEDS void DI_DisplayFunc(void)
  157. {
  158.    struct DI_GUIData *gui = &G->DI->GUI;
  159.    struct Dict *entry;
  160.  
  161.    DI_FinishEdit();
  162.    DoMethod(gui->LV_ENTRIES, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &entry);
  163.    DoMethod(G->App, MUIM_MultiSet, MUIA_Disabled, !entry, gui->ST_ALIAS, gui->SL_EDIT, gui->TE_EDIT, gui->BT_DELETE, gui->BT_PASTE, NULL);
  164.    nnset(gui->ST_ALIAS, MUIA_String_Contents, entry ? entry->Alias : "");
  165.    nnset(gui->TE_EDIT, MUIA_TextEditor_Contents, entry ? entry->Text : "");
  166.    G->DI->OldEntry = entry;
  167. }
  168. MakeHook(DI_DisplayHook, DI_DisplayFunc);
  169. ///
  170. /// DI_ModifyFunc
  171. //  Saves changed glossary item
  172. SAVEDS ASM void DI_ModifyFunc(REG(a1) int *arg)
  173. {
  174.    struct Dict new;
  175.  
  176.    DI_FinishEdit();
  177.    strcpy(new.Alias, GetStr(MSG_NewEntry));
  178.    new.Text = AllocStrBuf(80);
  179.    DoMethod(G->DI->GUI.LV_ENTRIES, MUIM_List_InsertSingle, &new, MUIV_List_Insert_Bottom);
  180.    nnset(G->DI->GUI.LV_ENTRIES, MUIA_List_Active, MUIV_List_Active_Bottom);
  181.    DI_DisplayFunc();
  182.    if (*arg == 1)
  183.    {
  184.       DoMethod(G->WR[G->DI->WrWin]->GUI.TE_EDIT, MUIM_TextEditor_ARexxCmd, "Copy");
  185.       DoMethod(G->DI->GUI.TE_EDIT, MUIM_TextEditor_ARexxCmd, "Paste");
  186.    }
  187.    set(G->DI->GUI.WI, MUIA_Window_ActiveObject, G->DI->GUI.ST_ALIAS);
  188. }
  189. MakeHook(DI_ModifyHook, DI_ModifyFunc);
  190. ///
  191. /// DI_OpenFunc
  192. //  Opens glossary window
  193. SAVEDS ASM void DI_OpenFunc(REG(a1) int *arg)
  194. {
  195.    if (!G->DI)
  196.    {
  197.       if (!(G->DI = DI_New())) return;
  198.       G->DI->WrWin = *arg;
  199.       if (!SafeOpenWindow(G->DI->GUI.WI)) DisposeModulePush(&G->DI);
  200.       else if (DI_Load()) set(G->DI->GUI.LV_ENTRIES, MUIA_List_Active, 0);
  201.    }
  202. }
  203. MakeHook(DI_OpenHook, DI_OpenFunc);
  204. ///
  205.  
  206. /*** GUI ***/
  207. /// DI_LV_ConFunc
  208. //  Glossary listview construction hook
  209. SAVEDS ASM struct Dict *DI_LV_ConFunc(REG(a1) struct Dict *dict)
  210. {
  211.    struct Dict *entry = malloc(sizeof(struct Dict));
  212.    memcpy(entry, dict, sizeof(struct Dict));
  213.    return entry;
  214. }
  215. MakeHook(DI_LV_ConFuncHook, DI_LV_ConFunc);
  216. ///
  217. /// DI_LV_DesFunc
  218. //  Glossary listview destruction hook
  219. SAVEDS ASM long DI_LV_DesFunc(REG(a1) struct Dict *entry)
  220. {
  221.    if (entry->Text) FreeStrBuf(entry->Text);
  222.    free(entry);
  223.    return 0;
  224. }
  225. MakeHook(DI_LV_DesFuncHook, DI_LV_DesFunc);
  226. ///
  227. /// DI_New
  228. //  Creates glossary window
  229. struct DI_ClassData *DI_New(void)
  230. {
  231.    struct DI_ClassData *data;
  232.  
  233.    if (data = calloc(1, sizeof(struct DI_ClassData)))
  234.    {
  235.       data->GUI.SL_EDIT = ScrollbarObject, End;
  236.       data->GUI.WI = WindowObject,
  237.          MUIA_Window_Title, GetStr(MSG_WR_Dictionary),
  238.          MUIA_HelpNode, "DI_W",
  239.          MUIA_Window_ID, MAKE_ID('D','I','C','T'),
  240.          WindowContents, VGroup,
  241.             Child, HGroup,
  242.                Child, data->GUI.GR_LIST = ListviewObject,
  243.                   MUIA_HorizWeight, G->Weights[4],
  244.                   MUIA_Listview_DragType, MUIV_Listview_DragType_Immediate,
  245.                   MUIA_Listview_Input, TRUE,
  246.                   MUIA_Listview_DoubleClick, TRUE,
  247.                   MUIA_CycleChain, 1,
  248.                   MUIA_Listview_List, data->GUI.LV_ENTRIES = ListObject,
  249.                     InputListFrame,
  250.                     MUIA_List_ConstructHook, &DI_LV_ConFuncHook,
  251.                     MUIA_List_DestructHook , &DI_LV_DesFuncHook,
  252.                     MUIA_List_DragSortable, TRUE,
  253.                   End,
  254.                End,
  255.                Child, BalanceObject, End,
  256.                Child, data->GUI.GR_TEXT = VGroup,
  257.                   MUIA_HorizWeight, G->Weights[5],
  258.                   Child, HGroup,
  259.                      Child, Label2(GetStr(MSG_DI_Alias)),
  260.                      Child, data->GUI.ST_ALIAS = MakeString(SIZE_NAME, GetStr(MSG_DI_Alias)),
  261.                   End,
  262.                   Child, HGroup,
  263.                      MUIA_Group_Spacing, 0,
  264.                      Child, data->GUI.TE_EDIT = NewObject(CL_TextEditor->mcc_Class, NULL,
  265.                         InputListFrame,
  266.                         MUIA_CycleChain, TRUE,
  267.                         MUIA_TextEditor_Slider, data->GUI.SL_EDIT,
  268.                      End,
  269.                      Child, data->GUI.SL_EDIT,
  270.                   End,
  271.                End,
  272.             End,
  273.             Child, ColGroup(4),
  274.                Child, data->GUI.BT_NEW       = MakeButton(GetStr(MSG_DI_New)),
  275.                Child, data->GUI.BT_ADDSELECT = MakeButton(GetStr(MSG_DI_AddSelect)),
  276.                Child, data->GUI.BT_DELETE    = MakeButton(GetStr(MSG_DI_Delete)),
  277.                Child, data->GUI.BT_PASTE     = MakeButton(GetStr(MSG_DI_Paste)),
  278.             End,
  279.          End,
  280.       End;
  281.       if (data->GUI.WI)
  282.       {
  283.          DoMethod(G->App, OM_ADDMEMBER, data->GUI.WI);
  284.          DoMethod(G->App, MUIM_MultiSet, MUIA_Disabled, TRUE, data->GUI.ST_ALIAS, data->GUI.SL_EDIT, data->GUI.TE_EDIT, data->GUI.BT_DELETE, data->GUI.BT_PASTE, NULL);
  285.          set(data->GUI.WI, MUIA_Window_ActiveObject, data->GUI.GR_LIST);
  286.          SetHelp(data->GUI.LV_ENTRIES,   MSG_HELP_DI_LV_ENTRIES);
  287.          SetHelp(data->GUI.ST_ALIAS,     MSG_HELP_DI_ST_ALIAS);
  288.          SetHelp(data->GUI.BT_NEW,       MSG_HELP_DI_BT_NEW);
  289.          SetHelp(data->GUI.BT_ADDSELECT, MSG_HELP_DI_BT_ADDSELECT);
  290.          SetHelp(data->GUI.BT_DELETE,    MSG_HELP_DI_BT_DELETE);
  291.          SetHelp(data->GUI.BT_PASTE,     MSG_HELP_DI_BT_PASTE);
  292.          DoMethod(data->GUI.ST_ALIAS    ,MUIM_Notify,MUIA_String_Contents     ,MUIV_EveryTime,data->GUI.TE_EDIT      ,3,MUIM_Set,MUIA_TextEditor_HasChanged,TRUE);
  293.          DoMethod(data->GUI.BT_NEW      ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,3,MUIM_CallHook,&DI_ModifyHook,0);
  294.          DoMethod(data->GUI.BT_ADDSELECT,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,3,MUIM_CallHook,&DI_ModifyHook,1);
  295.          DoMethod(data->GUI.BT_DELETE   ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,3,MUIM_CallHook,&DI_DeleteHook,0);
  296.          DoMethod(data->GUI.BT_PASTE    ,MUIM_Notify,MUIA_Pressed             ,FALSE         ,MUIV_Notify_Application,3,MUIM_CallHook,&DI_PasteHook,0);
  297.          DoMethod(data->GUI.LV_ENTRIES  ,MUIM_Notify,MUIA_Listview_DoubleClick,TRUE          ,MUIV_Notify_Application,3,MUIM_CallHook,&DI_PasteHook,0);
  298.          DoMethod(data->GUI.LV_ENTRIES  ,MUIM_Notify,MUIA_List_Active         ,MUIV_EveryTime,MUIV_Notify_Application,3,MUIM_CallHook,&DI_DisplayHook,0);
  299.          DoMethod(data->GUI.WI          ,MUIM_Notify,MUIA_Window_CloseRequest ,TRUE          ,MUIV_Notify_Application,3,MUIM_CallHook,&DI_CloseHook,0);
  300.          return data;
  301.       }
  302.       free(data);
  303.    }
  304.    return NULL;
  305. }
  306. ///
  307.