source: tags/arb_5.1/PGT/import_dialog.cxx

Last change on this file was 5725, checked in by westram, 15 years ago
  • removed useless macros:
    • GB_STRDUP (easily taken for GB_strdup)
    • GB_MEMCPY + GB_MEMSET + GB_FREE
    • GB_DELETE (replaced by freeset(xx,NULL))
  • added macros:
    • freeset (= free + assign)
    • freedup (= free + assign strdup'ed)
    • reassign (= free + assign + clear source var)
    • nulldup (=strdup accepting NULL; replacement for GB_strdup in C++ code)
  • use these macros where applicable
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 45.3 KB
Line 
1// Copyright (c) 2004 - 2005 Kai Bader <baderk@in.tum.de>
2//
3// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
4// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
5// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
6// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
7// AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
8// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
9
10// CVS REVISION TAG  --  $Revision: 5725 $
11
12
13#include "import_dialog.hxx"
14#include "selection_dialog.hxx"
15#include "entry_sel_dialog.hxx"
16#include "arb_interface.hxx"
17
18
19// CALLBACK WRAPPER FUNCTIONS (STATIC)
20void staticGetFilenameCallback(Widget, XtPointer, XtPointer);
21void staticFileDialogCloseCallback(Widget parent, XtPointer, XtPointer);
22void staticFileDialogCallback(Widget parent, XtPointer, XtPointer call_data);
23void staticARBdestinationCallback(Widget, XtPointer, XtPointer);
24void staticSpeciesChangedCallback(Widget, XtPointer, XtPointer);
25void staticExperimentChangedCallback(Widget, XtPointer, XtPointer);
26void staticProteomeChangedCallback(Widget, XtPointer, XtPointer);
27void staticClearEntriesButtonCallback(Widget, XtPointer, XtPointer);
28void staticOpenFileButtonCallback(Widget, XtPointer, XtPointer);
29void staticColumnDownCallback(Widget, XtPointer, XtPointer);
30void staticColumnUpCallback(Widget, XtPointer, XtPointer);
31void staticHeaderChangedCallback(Widget, XtPointer, XtPointer);
32void staticResetHeaderButtonCallback(Widget, XtPointer, XtPointer);
33void staticImportDataCallback(Widget, XtPointer, XtPointer);
34void staticChangedDatatypeCallback(Widget, XtPointer, XtPointer);
35void staticSampleListEntryCallback(Widget, XtPointer, XtPointer);
36void staticExternHeaderSelectionCallback(Widget, XtPointer, XtPointer);
37void staticExternHeaderChangedCallback(Widget, XtPointer, XtPointer);
38
39
40/****************************************************************************
41*  MAIN DIALOG - CONSTRUCTOR
42****************************************************************************/
43importDialog::importDialog(MDialog *d)
44    : MDialog(d)
45{
46    // PRESET CLASS VARIABLES
47    m_species= get_species_AWAR();
48    m_experiment= get_experiment_AWAR();
49    m_proteome= get_proteom_AWAR();
50    //
51    m_table= NULL;
52    m_xslt= NULL;
53
54    m_hasFileDialog= false;
55    m_hasSelectionDialog= false;
56    m_hasTableData = false;
57
58    // CREATE TYPE STRINGS
59    m_str_int=    CreateDlgString("INT");
60    m_str_float=  CreateDlgString("FLOAT");
61    m_str_string= CreateDlgString("STRING");
62
63    // SHOW DIALOG
64    createShell("");
65
66    // CALL CREATE WINDOW FUNCTION
67    createWindow();
68
69    // SET WINDOW WIDTH
70    XtVaSetValues(m_shell,
71        XmNwidth, 600,
72        NULL);
73
74    // REALIZE WINDOW
75    realizeShell();
76
77    // SET WINDOW LABEL
78    setDialogTitle("PGT - Proteome Data Importer");
79}
80
81
82/****************************************************************************
83*  MAIN DIALOG - DESTRUCTOR
84****************************************************************************/
85importDialog::~importDialog()
86{
87    // FREE ENTRIES
88    if(m_species) free(m_species);
89    if(m_experiment) free(m_experiment);
90    if(m_proteome) free(m_proteome);
91    if(m_table) free(m_table);
92    if(m_xslt) free(m_xslt);
93}
94
95
96/****************************************************************************
97*  MAIN DIALOG - CREATE WINDOW
98****************************************************************************/
99void importDialog::createWindow()
100{
101    // CREATE TOP LEVEL WIDGET
102    m_top= XtVaCreateManagedWidget("top",
103        xmRowColumnWidgetClass, m_shell,
104        XmNorientation, XmVERTICAL,
105        XmNmarginHeight, 0,
106        XmNmarginWidth, 0,
107        NULL);
108
109    // CREATE SELECTION AREA
110    createSelectionArea();
111
112    // CREATE HORIZONTAL SEPARATOR WIDGET
113    XtVaCreateManagedWidget("separator",
114        xmSeparatorWidgetClass, m_top,
115        XmNorientation, XmHORIZONTAL,
116        NULL);
117
118    // CREATE IMPORT AREA
119    createImportArea();
120
121    // FILL THE IMPORT TYPE COMBOBOX
122    fillImportTypeCombobox();
123
124    // UPDATE ARB ENTRY FIELD
125    updateARBText();
126}
127
128
129/****************************************************************************
130*  MAIN DIALOG - CREATE WINDOW
131****************************************************************************/
132void importDialog::createSelectionArea()
133{
134    // CREATE STRINGS
135    XmString str_01= CreateDlgString("...");
136    XmString str_02= CreateDlgString("Source File:");
137    XmString str_03= CreateDlgString("ARB Destination:");
138    XmString str_04= CreateDlgString("Import Filter:");
139    XmString str_05= CreateDlgString("Clear Entries");
140    XmString str_06= CreateDlgString("Open File");
141
142    // CREATE LOCAL MANAGER WIDGET
143    Widget manager= XtVaCreateManagedWidget("mainarea",
144        xmFormWidgetClass, m_top,
145        // XmNmarginHeight, 0,
146        // XmNmarginWidth, 0,
147        NULL);
148
149    // CREATE FILENAME SELECTION BUTTON
150    Widget fileButtonWidget= XtVaCreateManagedWidget("fileselectbutton",
151        xmPushButtonWidgetClass, manager,
152        XmNlabelString, str_01,
153        XmNwidth, 40,
154        XmNheight, 30,
155        XmNtopAttachment, XmATTACH_FORM,
156        XmNrightAttachment, XmATTACH_FORM,
157        NULL);
158    XtAddCallback(fileButtonWidget, XmNactivateCallback, staticGetFilenameCallback, this);
159
160    // CREATE DATASET SELECTION BUTTON
161    Widget datasetButtonWidget= XtVaCreateManagedWidget("datasetbuttonwidget",
162        xmPushButtonWidgetClass, manager,
163        XmNlabelString, str_01,
164        XmNwidth, 40,
165        XmNheight, 30,
166        XmNtopAttachment, XmATTACH_WIDGET,
167        XmNtopWidget, fileButtonWidget,
168        XmNrightAttachment, XmATTACH_FORM,
169        NULL);
170    XtAddCallback(datasetButtonWidget, XmNactivateCallback, staticARBdestinationCallback, this);
171
172    // CREATE FIRST ROW LABEL
173    Widget upperLabel= XtVaCreateManagedWidget("label",
174        xmLabelWidgetClass, manager,
175        XmNlabelString, str_02,
176        XmNwidth, 110,
177        XmNheight, 30,
178        XmNalignment, XmALIGNMENT_BEGINNING,
179        XmNtopAttachment, XmATTACH_FORM,
180        XmNleftAttachment, XmATTACH_FORM,
181        NULL);
182
183    // CREATE SECOND ROW LABEL
184    Widget lowerLabel= XtVaCreateManagedWidget("label",
185        xmLabelWidgetClass, manager,
186        XmNlabelString, str_03,
187        XmNwidth, 110,
188        XmNheight, 30,
189        XmNalignment, XmALIGNMENT_BEGINNING,
190        XmNtopAttachment, XmATTACH_WIDGET,
191        XmNtopWidget, upperLabel,
192        XmNleftAttachment, XmATTACH_FORM,
193        NULL);
194
195    // CREATE THIRD ROW LABEL
196    Widget typeLabel= XtVaCreateManagedWidget("label",
197        xmLabelWidgetClass, manager,
198        XmNlabelString, str_04,
199        XmNwidth, 110,
200        XmNheight, 30,
201        XmNalignment, XmALIGNMENT_BEGINNING,
202        XmNtopAttachment, XmATTACH_WIDGET,
203        XmNtopWidget, lowerLabel,
204        XmNleftAttachment, XmATTACH_FORM,
205        NULL);
206
207    // CREATE FILENAME TEXT FIELD
208    m_filenameWidget= XtVaCreateManagedWidget("filenamewidget",
209        xmTextWidgetClass, manager,
210        XmNheight, 30,
211        XmNtopAttachment, XmATTACH_FORM,
212        XmNrightAttachment, XmATTACH_WIDGET,
213        XmNrightWidget, fileButtonWidget,
214        XmNleftAttachment, XmATTACH_WIDGET,
215        XmNleftWidget, upperLabel,
216        NULL);
217
218    // CREATE ARB DATASET TEXT FIELD
219    m_datasetWidget= XtVaCreateManagedWidget("arbdatasetwidget",
220        xmTextWidgetClass, manager,
221        XmNeditable, false,
222        XmNheight, 30,
223        XmNtopAttachment, XmATTACH_WIDGET,
224        XmNtopWidget, m_filenameWidget,
225        XmNrightAttachment, XmATTACH_WIDGET,
226        XmNrightWidget, datasetButtonWidget,
227        XmNleftAttachment, XmATTACH_WIDGET,
228        XmNleftWidget, lowerLabel,
229        NULL);
230
231    // CREATE COMBOBOX FOR FILE TYPE SELECTION
232    m_fileTypeWidget= XtVaCreateManagedWidget("filetypecombobox",
233        xmComboBoxWidgetClass, manager,
234        XmNcomboBoxType, XmDROP_DOWN_COMBO_BOX,
235        XmNmarginWidth, 1,
236        XmNmarginHeight, 1,
237        // XmNheight, 30,
238        XmNtopAttachment, XmATTACH_WIDGET,
239        XmNtopWidget, m_datasetWidget,
240        XmNleftAttachment, XmATTACH_WIDGET,
241        XmNleftWidget, typeLabel,
242        NULL);
243
244    // CREATE RESET BUTTON
245    Widget resetButtonWidget= XtVaCreateManagedWidget("resetbutton",
246        xmPushButtonWidgetClass, manager,
247        XmNlabelString, str_05,
248        XmNtopAttachment, XmATTACH_WIDGET,
249        XmNtopWidget, datasetButtonWidget,
250        // XmNbottomAttachment, XmATTACH_FORM,
251        XmNrightAttachment, XmATTACH_FORM,
252//         XmNbottomAttachment, XmATTACH_FORM,
253//         XmNrightAttachment, XmATTACH_WIDGET,
254//         XmNrightWidget, openButtonWidget,
255        XmNwidth, 100,
256        XmNheight, 30,
257        NULL);
258    XtAddCallback(resetButtonWidget, XmNactivateCallback, staticClearEntriesButtonCallback, this);
259
260    // CREATE IMPORT BUTTON
261    Widget openButtonWidget= XtVaCreateManagedWidget("openbutton",
262            xmPushButtonWidgetClass, manager,
263            XmNlabelString, str_06,
264            XmNtopAttachment, XmATTACH_WIDGET,
265            XmNtopWidget, resetButtonWidget,
266            XmNbottomAttachment, XmATTACH_FORM,
267            XmNrightAttachment, XmATTACH_FORM,
268//             XmNbottomAttachment, XmATTACH_FORM,
269//             XmNrightAttachment, XmATTACH_WIDGET,
270//             XmNrightWidget, openButtonWidget,
271            XmNwidth, 100,
272            XmNheight, 30,
273            NULL);
274    XtAddCallback(openButtonWidget, XmNactivateCallback, staticOpenFileButtonCallback, this);
275}
276
277
278/****************************************************************************
279*  MAIN DIALOG - CREATE IMPORT AREA
280****************************************************************************/
281void importDialog::createImportArea()
282{
283    // CREATE STRINGS
284    XmString str_01= CreateDlgString("Select Data Column:");
285    XmString str_02= CreateDlgString("New ARB Container Type:");
286    XmString str_03= CreateDlgString("Original Column Header:");
287    XmString str_04= CreateDlgString("New ARB Container Name:");
288    XmString str_05= CreateDlgString("ARB entry IDs");
289    XmString str_06= CreateDlgString("Import -> ARB");
290    XmString str_07= CreateDlgString("New Proteome Content:");
291    XmString str_08= CreateDlgString("Reset Names");
292
293    // CREATE LOCAL MANAGER WIDGET
294    Widget manager= XtVaCreateManagedWidget("importarea",
295        xmFormWidgetClass, m_top,
296        // XmNmarginHeight, 0,
297        // XmNmarginWidth, 0,
298        NULL);
299
300    // CREATE LABEL
301    Widget typeLabel= XtVaCreateManagedWidget("label",
302        xmLabelWidgetClass, manager,
303        XmNlabelString, str_01,
304        XmNalignment, XmALIGNMENT_BEGINNING,
305        XmNleftAttachment, XmATTACH_FORM,
306        XmNtopAttachment, XmATTACH_FORM,
307        XmNwidth, 150,
308        XmNheight, 30,
309        NULL);
310
311    // CREATE LABEL
312    Widget columnTypeLabel= XtVaCreateManagedWidget("label",
313        xmLabelWidgetClass, manager,
314        XmNlabelString, str_02,
315        XmNwidth, 150,
316        XmNheight, 30,
317        XmNalignment, XmALIGNMENT_BEGINNING,
318        XmNleftAttachment, XmATTACH_FORM,
319        XmNtopAttachment, XmATTACH_WIDGET,
320        XmNtopWidget, typeLabel,
321        NULL);
322
323    // CREATE LABEL
324    Widget columnLabel= XtVaCreateManagedWidget("label",
325        xmLabelWidgetClass, manager,
326        XmNlabelString, str_03,
327        XmNwidth, 150,
328        XmNheight, 30,
329        XmNalignment, XmALIGNMENT_BEGINNING,
330        XmNleftAttachment, XmATTACH_FORM,
331        XmNtopAttachment, XmATTACH_WIDGET,
332        XmNtopWidget, columnTypeLabel,
333        NULL);
334
335    // CREATE LABEL
336    Widget containerLabel= XtVaCreateManagedWidget("label",
337        xmLabelWidgetClass, manager,
338        XmNlabelString, str_04,
339        XmNwidth, 150,
340        XmNheight, 30,
341        XmNalignment, XmALIGNMENT_BEGINNING,
342        XmNleftAttachment, XmATTACH_FORM,
343        XmNtopAttachment, XmATTACH_WIDGET,
344        XmNtopWidget, columnLabel,
345        NULL);
346
347    // CREATE LEFT ARROW WIDGET
348    Widget selector_l= XtVaCreateManagedWidget("arrowleft",
349        xmArrowButtonGadgetClass, manager,
350        XmNarrowDirection, XmARROW_LEFT,
351        XmNtopAttachment, XmATTACH_FORM,
352        XmNleftAttachment, XmATTACH_WIDGET,
353        XmNleftWidget, typeLabel,
354        XmNwidth, 24,
355        XmNheight, 30,
356        NULL);
357    XtAddCallback(selector_l, XmNactivateCallback, staticColumnDownCallback, this);
358
359    // CREATE RIGHT ARROW WIDGET
360    Widget selector_r= XtVaCreateManagedWidget("arrowright",
361        xmArrowButtonGadgetClass, manager,
362        XmNarrowDirection, XmARROW_RIGHT,
363        XmNtopAttachment, XmATTACH_FORM,
364        XmNrightAttachment, XmATTACH_FORM,
365        XmNwidth, 24,
366        XmNheight, 30,
367        NULL);
368    XtAddCallback(selector_r, XmNactivateCallback, staticColumnUpCallback, this);
369
370    // CREATE COLUMN SELECTOR TEXT FIELD
371    m_selectorText= XtVaCreateManagedWidget("selectortext",
372        xmTextWidgetClass, manager,
373        XmNeditable, false,
374        XmNtopAttachment, XmATTACH_FORM,
375        XmNleftAttachment, XmATTACH_WIDGET,
376        XmNleftWidget, selector_l,
377        XmNrightAttachment, XmATTACH_WIDGET,
378        XmNrightWidget, selector_r,
379        XmNheight, 30,
380        NULL);
381
382    // CREATE COLUMN TYPE COMBOBOX WIDGET
383    m_fieldTypeWidget= XtVaCreateManagedWidget("fieldtypecombobox",
384        xmComboBoxWidgetClass, manager,
385        XmNcomboBoxType, XmDROP_DOWN_COMBO_BOX,
386        XmNmarginWidth, 1,
387        XmNmarginHeight, 1,
388        XmNleftAttachment, XmATTACH_WIDGET,
389        XmNleftWidget, columnTypeLabel,
390        XmNtopAttachment, XmATTACH_WIDGET,
391        XmNtopWidget, m_selectorText,
392        NULL);
393    XtAddCallback(m_fieldTypeWidget, XmNselectionCallback, staticChangedDatatypeCallback, this);
394
395    // FILL THE COLUMN TYPE COMBOBOX
396    fillARBTypeCombobox();
397
398    // CREATE COLUMN HEADER TEXT FIELD
399    m_columnHeaderWidget= XtVaCreateManagedWidget("columnHeaderText",
400        xmTextWidgetClass, manager,
401        XmNeditable, false,
402        XmNheight, 30,
403        XmNleftAttachment, XmATTACH_WIDGET,
404        XmNleftWidget, columnLabel,
405        XmNrightAttachment, XmATTACH_FORM,
406        XmNtopAttachment, XmATTACH_WIDGET,
407        XmNtopWidget, m_fieldTypeWidget,
408        NULL);
409
410    // CREATE COLUMN HEADER TEXT FIELD
411    m_containerHeaderWidget= XtVaCreateManagedWidget("containerHeaderText",
412        xmTextWidgetClass, manager,
413        XmNheight, 30,
414        XmNleftAttachment, XmATTACH_WIDGET,
415        XmNleftWidget, containerLabel,
416        XmNrightAttachment, XmATTACH_FORM,
417        XmNtopAttachment, XmATTACH_WIDGET,
418        XmNtopWidget, m_columnHeaderWidget,
419        NULL);
420    XtAddCallback(m_containerHeaderWidget, XmNactivateCallback, staticHeaderChangedCallback, this);
421
422    // CREATE RESET NAMES BUTTON
423    Widget namesButtonWidget= XtVaCreateManagedWidget("namesbutton",
424        xmPushButtonWidgetClass, manager,
425        XmNlabelString, str_08,
426        XmNtopAttachment, XmATTACH_WIDGET,
427        XmNtopWidget, m_containerHeaderWidget,
428        XmNrightAttachment, XmATTACH_FORM,
429        XmNwidth, 100,
430        XmNheight, 30,
431        NULL);
432    XtAddCallback(namesButtonWidget, XmNactivateCallback, staticResetHeaderButtonCallback, this);
433
434    // CREATE ARB NAMES BUTTON
435    Widget ARBnamesButtonWidget= XtVaCreateManagedWidget("ARBnamesButton",
436            xmPushButtonWidgetClass, manager,
437            XmNlabelString, str_05,
438            XmNtopAttachment, XmATTACH_WIDGET,
439            XmNtopWidget, m_containerHeaderWidget,
440            XmNrightAttachment, XmATTACH_WIDGET,
441            XmNrightWidget, namesButtonWidget,
442            XmNwidth, 100,
443            XmNheight, 30,
444            NULL);
445    XtAddCallback(ARBnamesButtonWidget, XmNactivateCallback, staticExternHeaderSelectionCallback, this);
446
447    // CREATE IMPORT BUTTON
448    Widget importButtonWidget= XtVaCreateManagedWidget("importbutton",
449            xmPushButtonWidgetClass, manager,
450            XmNlabelString, str_06,
451            XmNtopAttachment, XmATTACH_WIDGET,
452            XmNtopWidget, namesButtonWidget,
453            XmNrightAttachment, XmATTACH_FORM,
454            XmNwidth, 100,
455            XmNheight, 30,
456            NULL);
457    XtAddCallback(importButtonWidget, XmNactivateCallback, staticImportDataCallback, this);
458
459    // CREATE LABEL
460    XtVaCreateManagedWidget("label",
461        xmLabelWidgetClass, m_top,
462        XmNlabelString, str_07,
463        // XmNwidth, 160,
464        // XmNheight, 30,
465        NULL);
466
467    // SAMPLE ARB CONTAINER ENTRIES LIST
468    m_sampleList= XmCreateScrolledList(m_top, const_cast<char*>("sampleList"), NULL, 0);
469    XtVaSetValues(m_sampleList,
470        XmNmarginWidth, 1,
471        XmNmarginHeight, 1,
472        // XmNallowResize, true,
473        XmNvisibleItemCount, 10,
474        // XmNselectionPolicy, XmSINGLE_SELECT,
475        NULL);
476    XtManageChild(m_sampleList);
477    XtAddCallback(m_sampleList, XmNbrowseSelectionCallback, staticSampleListEntryCallback, this);
478
479//     // SAMPLE SCALE (FOR SELECTING THE SAMPLE ENTRY
480//     m_sampleScale= XtVaCreateManagedWidget("sampleScale",
481//         xmScaleWidgetClass, m_top,
482//         XmNtitleString,   CreateDlgString("Entry"),
483//         XmNorientation,    XmHORIZONTAL,
484//         XmNmaximum,       10,
485//         XmNdecimalPoints, 0,
486//         XmNshowValue,     True,
487//         // XmNwidth,         200,
488//         // XmNheight,        100,
489//         NULL);
490}
491
492
493/****************************************************************************
494*  MAIN DIALOG - SET SPECIES NAME
495****************************************************************************/
496void importDialog::setSpecies(char *species)
497{
498    m_species= (char *)malloc((strlen(species) +1)*sizeof(char));
499    strcpy(m_species, species);
500
501    // set_species_AWAR(m_species);
502}
503
504
505/****************************************************************************
506*  MAIN DIALOG - SET EXPERIMENT NAME
507****************************************************************************/
508void importDialog::setExperiment(char *experiment)
509{
510    m_experiment= (char *)malloc((strlen(experiment) +1)*sizeof(char));
511    strcpy(m_experiment, experiment);
512
513    // set_experiment_AWAR(m_experiment);
514}
515
516
517/****************************************************************************
518*  MAIN DIALOG - SET PROTEOME NAME
519****************************************************************************/
520void importDialog::setProteome(char *proteome)
521{
522    m_proteome= (char *)malloc((strlen(proteome) +1)*sizeof(char));
523    strcpy(m_proteome, proteome);
524
525    // set_proteom_AWAR(m_proteome);
526}
527
528
529/****************************************************************************
530*  MAIN DIALOG - GET FILENAME CALLBACK
531****************************************************************************/
532void importDialog::getFilenameCallback(Widget, XtPointer)
533{
534    if (!m_hasFileDialog)
535    {
536        m_fileDialog= XmCreateFileSelectionDialog(m_shell, const_cast<char*>("importDialog"), NULL, 0);
537        XtAddCallback(m_fileDialog, XmNokCallback, staticFileDialogCallback, this);
538        XtAddCallback(m_fileDialog, XmNcancelCallback, staticFileDialogCloseCallback, this);
539        XtAddCallback(m_fileDialog, XmNnoMatchCallback, staticFileDialogCloseCallback, this);
540        XtSetSensitive(XmFileSelectionBoxGetChild(m_fileDialog, XmDIALOG_HELP_BUTTON), False);
541
542        XmString str_open= CreateDlgString("Open proteome data file...");
543        XtVaSetValues(m_fileDialog, XmNdialogTitle, str_open, NULL);
544
545        m_hasFileDialog= true;
546    }
547
548    XtManageChild(m_fileDialog);
549    XtPopup(XtParent(m_fileDialog), XtGrabNone);
550}
551
552
553/****************************************************************************
554*  MAIN DIALOG - CET FILENAME CALLBACK
555*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
556****************************************************************************/
557void staticGetFilenameCallback(Widget widget, XtPointer clientData, XtPointer callData)
558{
559    // GET POINTER OF THE ORIGINAL CALLER
560    importDialog *iD= (importDialog *)clientData;
561
562    // CALL CLASS MEMBER FUNCTION
563    iD->getFilenameCallback(widget, callData);
564}
565
566
567/****************************************************************************
568*  CALLBACK - IMPORT FILE DIALOG VALUE
569*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
570****************************************************************************/
571void staticFileDialogCloseCallback(Widget parent, XtPointer, XtPointer)
572{
573    // CLOSE FILE OPEN DIALOG
574    XtUnmanageChild(parent);
575}
576
577
578/****************************************************************************
579*  CALLBACK - IMPORT FILE DIALOG VALUE
580*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
581****************************************************************************/
582void staticFileDialogCallback(Widget widget, XtPointer clientData, XtPointer callData)
583{
584    // GET POINTER OF THE ORIGINAL CALLER
585    importDialog *iD= (importDialog *)clientData;
586
587    // CALL CLASS MEMBER FUNCTION
588    iD->fileDialogCallback(widget, callData);
589}
590
591
592/****************************************************************************
593*  CALLBACK - IMPORT FILE DIALOG VALUE
594****************************************************************************/
595void importDialog::fileDialogCallback(Widget widget, XtPointer callData)
596{
597    // FETCH SELECTED FILENAME
598    XmFileSelectionBoxCallbackStruct *cbs;
599    cbs= (XmFileSelectionBoxCallbackStruct *)callData;
600
601    // CONVERT XMSTRING TO CHAR*
602    char *str;
603    XmStringGetLtoR(cbs->value, XmFONTLIST_DEFAULT_TAG, &str);
604
605    // CLOSE FILE OPEN DIALOG
606    XtUnmanageChild(widget);
607
608    // WRITE STRING TO TEXT FIELD
609    XtVaSetValues(m_filenameWidget, XmNvalue, str, NULL);
610}
611
612
613/****************************************************************************
614*  CALLBACK - SELECT ARB DESTINATION
615*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
616****************************************************************************/
617void staticARBdestinationCallback(Widget widget, XtPointer clientData, XtPointer callData)
618{
619    // GET POINTER OF THE ORIGINAL CALLER
620    importDialog *iD= (importDialog *)clientData;
621
622    // CALL CLASS MEMBER FUNCTION
623    iD->ARBdestinationCallback(widget, callData);
624}
625
626
627/****************************************************************************
628*  CALLBACK - SELECT ARB DESTINATION
629****************************************************************************/
630void importDialog::ARBdestinationCallback(Widget, XtPointer)
631{
632    selectionDialog *sD= new selectionDialog(this, SELECTION_DIALOG_WRITE);
633
634    // SET SPECIES CALLBACK
635    sD->setSpeciesCallback(staticSpeciesChangedCallback);
636
637    // SET EXPERIMENT CALLBACK
638    sD->setExperimentCallback(staticExperimentChangedCallback);
639
640    // SET PROTEOME CALLBACK
641    sD->setProteomeCallback(staticProteomeChangedCallback);
642
643
644    //     new selectionDialog(m_shell, &m_species, &m_experiment,
645    //         &m_proteome, staticDataChangedCallback);
646}
647
648
649/****************************************************************************
650*  CALLBACK - DATA CHANGED CALLBACK
651*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
652****************************************************************************/
653void staticSpeciesChangedCallback(Widget, XtPointer clientData, XtPointer callData)
654{
655    // GET POINTER OF THE ORIGINAL CALLER
656    importDialog *iD= (importDialog *)clientData;
657
658    // GET SPECIES NAME FROM CALLDATA
659    char *name= *((char **)callData);
660
661    // SET NEW NAMES
662    iD->setSpecies(name);
663    iD->setExperiment(const_cast<char*>(""));
664    iD->setProteome(const_cast<char*>(""));
665
666    // UPDATE OUTPUT
667    iD->updateARBText();
668}
669
670
671/****************************************************************************
672*  CALLBACK - DATA CHANGED CALLBACK
673*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
674****************************************************************************/
675void staticExperimentChangedCallback(Widget, XtPointer clientData, XtPointer callData)
676{
677    // GET POINTER OF THE ORIGINAL CALLER
678    importDialog *iD= (importDialog *)clientData;
679
680    // GET EXPERIMENT NAME FROM CALLDATA
681    char *name= *((char **)callData);
682
683    // SET NEW NAMES
684    iD->setExperiment(name);
685    iD->setProteome(const_cast<char*>(""));
686
687    // UPDATE OUTPUT
688    iD->updateARBText();
689}
690
691
692/****************************************************************************
693*  CALLBACK - DATA CHANGED CALLBACK
694*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
695****************************************************************************/
696void staticProteomeChangedCallback(Widget, XtPointer clientData, XtPointer callData)
697{
698    // GET POINTER OF THE ORIGINAL CALLER
699    importDialog *iD= (importDialog *)clientData;
700
701    // GET PROTEOME NAME FROM CALLDATA
702    char *name= *((char **)callData);
703
704    // SET NEW NAMES
705    iD->setProteome(name);
706
707    // UPDATE OUTPUT
708    iD->updateARBText();
709}
710
711
712/****************************************************************************
713*  IMPORT DIALOG - UPDATE THE ARB TEXT FIELD ENTRY
714*  (SHOW SELECTED SPECIES/EXPERIMENT/PROTEOME)
715****************************************************************************/
716void importDialog::updateARBText()
717{
718    // CREATE BUFFER
719    char *buf= (char *)malloc(1024 * sizeof(char));
720    char *sp=   const_cast<char*>("no species");
721    char *exp=  const_cast<char*>("no experiment");
722    char *prot= const_cast<char*>("no proteome");
723
724    // USE REAL STRINGS IF AVAILABLE
725    if(m_species && (strlen(m_species))) sp= m_species;
726    if(m_experiment && (strlen(m_experiment))) exp= m_experiment;
727    if(m_proteome && (strlen(m_proteome))) prot= m_proteome;
728
729    // FILL BUFFER STRING
730    sprintf(buf, "[%s] -> [%s] -> [%s]", sp, exp, prot);
731
732    // COPY STRING TO TEXT FIELD
733    XtVaSetValues(m_datasetWidget, XmNvalue, buf, NULL);
734
735    // FREE BUFFER
736    free(buf);
737}
738
739
740/****************************************************************************
741*  IMPORT DIALOG - FILL THE IMPORT FILTER COMBOBOX
742****************************************************************************/
743void importDialog::fillImportTypeCombobox()
744{
745    // NUMBER OF ENTRIES COUNTER
746    int pos= 0;
747
748    // ADD CSV ENTRY TO THE COMBOBOX
749    XmString str_csv= CreateDlgString("CSV");
750    XmComboBoxAddItem(m_fileTypeWidget, str_csv, pos, true); pos++;
751
752    // ADD XSLT IMPORT FILTER (FOR XML FILES)
753    m_xslt= findXSLTFiles(const_cast<char*>("xslt"));
754
755    if(m_xslt)
756    {
757        for(int i= 0; i < m_xslt->number; i++)
758        {
759            XmString str_import= CreateDlgString(m_xslt->importer[i]);
760            XmComboBoxAddItem(m_fileTypeWidget, str_import, pos, true); pos++;
761        }
762    }
763
764    // SET COMBOBOX LIST LENGTH TO <= 5
765    int visible= 5;
766    if(pos < visible) visible= pos;
767    XtVaSetValues(m_fileTypeWidget,
768        XmNselectedPosition, (pos - 1),
769        XmNvisibleItemCount, visible,
770        NULL);
771}
772
773
774/****************************************************************************
775*  IMPORT DIALOG - FILL THE ARB ENTRY TYPE COMBOBOX
776****************************************************************************/
777void importDialog::fillARBTypeCombobox()
778{
779    // ADD ITEMS
780    int pos= 0;
781    XmComboBoxAddItem(m_fieldTypeWidget, m_str_int, pos, true); pos++;
782    XmComboBoxAddItem(m_fieldTypeWidget, m_str_float, pos, true); pos++;
783    XmComboBoxAddItem(m_fieldTypeWidget, m_str_string, pos, true); pos++;
784
785    // SET COMBOBOX LIST LENGTH TO <= 5
786    int visible= 5;
787    if(pos < visible) visible= pos;
788    XtVaSetValues(m_fieldTypeWidget,
789        XmNselectedPosition, (pos - 1),
790        XmNvisibleItemCount, visible,
791        NULL);
792}
793
794
795/****************************************************************************
796*  IMPORT DIALOG - CLEAR ENTRIES BUTTON
797****************************************************************************/
798void importDialog::clearEntriesButtonCallback(Widget, XtPointer)
799{
800    // RESET FILE NAME
801    XtVaSetValues(m_filenameWidget, XmNvalue, "", NULL);
802
803    // RESET SPECIES ENTRIES
804    m_species= NULL;
805    m_experiment= NULL;
806    m_proteome= NULL;
807    updateARBText();
808}
809
810
811/****************************************************************************
812*  IMPORT DIALOG - CLEAR ENTRIES BUTTON
813*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
814****************************************************************************/
815void staticClearEntriesButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
816{
817    // GET POINTER OF THE ORIGINAL CALLER
818    importDialog *iD= (importDialog *)clientData;
819
820    // CALL CLASS MEMBER FUNCTION
821    iD->clearEntriesButtonCallback(widget, callData);
822}
823
824
825/****************************************************************************
826*  IMPORT DIALOG - OPEN FILE BUTTON
827****************************************************************************/
828void importDialog::openFileButtonCallback(Widget, XtPointer)
829{
830    // LOCAL VARIABLES
831    char *filename;
832    char *filetype;
833    XmString *items;
834    int item_pos;
835
836    // GET SELECTED FILE TYPE (AS STRING)
837    XtVaGetValues(m_fileTypeWidget,
838        XmNitems, &items,
839        XmNselectedPosition, &item_pos,
840        NULL);
841    XmStringGetLtoR(items[item_pos], XmFONTLIST_DEFAULT_TAG, &filetype);
842
843    // GET SELECTED FILENAME
844    filename= XmTextGetString(m_filenameWidget);
845
846    // IMPORT DATA DEPENDING ON THE FILETYPE
847    if(!strcmp(filetype, "CSV")) // TYPE == CSV
848    {
849        // IMPORT CSV DATA
850        m_table= fileopenCSV(filename, ';');
851
852        if(!m_table) return; // THROW ERROR OR WARNING HERE !?!?!
853    }
854
855    // COPY FIRST COLUMN ENTRY TO COLUMN HEADER
856    copyHeaderEntries();
857
858    // INIT ACTIVE HEADER (COLUMN COUNTER BEGINS WITH 0)
859    m_activeHeader= 0;
860    m_hasTableData= true;
861
862    // UPDATE THE ENTRIES
863    updateHeaderEntries();
864}
865
866
867/****************************************************************************
868*  IMPORT DIALOG - OPEN FILE BUTTON
869*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
870****************************************************************************/
871void staticOpenFileButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
872{
873    // GET POINTER OF THE ORIGINAL CALLER
874    importDialog *iD= (importDialog *)clientData;
875
876    // CALL CLASS MEMBER FUNCTION
877    iD->openFileButtonCallback(widget, callData);
878}
879
880
881/****************************************************************************
882*  IMPORT DIALOG - UPDATE HEADER ENTRIES
883****************************************************************************/
884void importDialog::updateHeaderEntries()
885{
886    // RETURN, IF NO TABLE DATA IS AVAILABLE
887    if(!m_hasTableData) return;
888
889    // LOCAL VARIABLES
890    char *buf= (char *)malloc(1024 * sizeof(char));
891
892    // SET ACTUAL COUNTER LABEL
893    sprintf(buf, "Column %d of %d", m_activeHeader + 1, m_table->columns);
894    XtVaSetValues(m_selectorText, XmNvalue, buf, NULL);
895
896    // UPDATE THE SAMPLE LIST DATA
897    updateSampleList();
898
899    // HEADER NAMES
900    XtVaSetValues(m_columnHeaderWidget, XmNvalue, m_table->cell[m_activeHeader], NULL);
901    XtVaSetValues(m_containerHeaderWidget, XmNvalue, m_table->header[m_activeHeader], NULL);
902
903    // SET THE COLUMN TYPE COMBOBOX
904    switch(m_table->columnType[m_activeHeader])
905    {
906        case DATATYPE_INT:
907            XmComboBoxSelectItem(m_fieldTypeWidget, m_str_int);
908            break;
909        case DATATYPE_FLOAT:
910            XmComboBoxSelectItem(m_fieldTypeWidget, m_str_float);
911            break;
912        case DATATYPE_STRING:
913            XmComboBoxSelectItem(m_fieldTypeWidget, m_str_string);
914            break;
915    }
916
917    // CLEAR BUFFER
918    free(buf);
919}
920
921
922/****************************************************************************
923*  IMPORT DIALOG - FILL SAMPLE LIST
924****************************************************************************/
925void importDialog::updateSampleList()
926{
927    // RETURN, IF NO TABLE DATA IS AVAILABLE
928    if(!m_hasTableData) return;
929
930    // HARDCODED - FOR NOW
931    int m_samplePosition= 1;
932
933    // FETCH TABLE VARIABLES
934    int columns= m_table->columns;
935    char **header= m_table->header;
936
937    // CREATE BUFFERS
938    char *buf1= (char *)malloc(1025 * sizeof(char));
939    buf1[1024]= 0;
940    char *buf2= (char *)malloc(1025 * sizeof(char));
941    buf2[1024]= 0;
942
943    // CLEAR SAMPLE DATA
944    XmListDeleteAllItems(m_sampleList);
945
946    // SET HEADER NAME
947    char headerBuffer[33];
948    headerBuffer[32]= 0;
949
950    // ADD TITLE LINE TO SAMPLE LIST
951    char *title= const_cast<char*>("                  CONTAINER NAME | # | CONTENT...");
952    // char *title= "CONTAINER NAME                   | # | CONTENT...";
953    XmListAddItem(m_sampleList, CreateDlgString(title), 0);
954
955    //FETCH ALL COLUMN ENTRIES
956    for(int i= 0; i < columns; i++)
957    {
958        strncpy(headerBuffer, header[i], 32);
959
960        // SET FIELD TYPE
961        char *type;
962        switch(m_table->columnType[i])
963        {
964            case DATATYPE_INT:
965                type= const_cast<char*>("I");
966                break;
967            case DATATYPE_FLOAT:
968                type= const_cast<char*>("F");
969                break;
970            default:
971                type= const_cast<char*>("S");
972                break;
973        }
974
975        // SET FIELD TEXT (NUMBER OF BYTES: 1024 - THE OTHER ENTRIES LENGTH)
976        strncpy(buf1, m_table->cell[(m_samplePosition * columns) + i], (1024 - 32 - 1 - 6));
977
978        // CREATE FORMATED OUTPUT STRING
979        sprintf(buf2, "%32s | %s | %s", headerBuffer, type, buf1);
980
981        // ADD STRING TO SAMPLE LIST
982        XmListAddItem(m_sampleList, CreateDlgString(buf2), 0);
983    }
984
985    // SELECT THE ACTIVE ENTRY
986    XmListSelectPos(m_sampleList, m_activeHeader + 2, false);
987
988    // MAKE LIST SCROLL TO THE CORRECT POSITION
989    int topItem, visibleItems;
990    XtVaGetValues(m_sampleList,
991        XmNtopItemPosition, &topItem,
992        XmNvisibleItemCount, &visibleItems,
993        NULL);
994
995    if((m_activeHeader + 2) < topItem)
996        XtVaSetValues(m_sampleList,
997            XmNtopItemPosition, m_activeHeader + 2,
998            NULL);
999    else if((m_activeHeader + 3) > (topItem + visibleItems))
1000        XtVaSetValues(m_sampleList,
1001            XmNtopItemPosition, m_activeHeader - visibleItems + 3,
1002            NULL);
1003
1004    // FREE BUFFER
1005    free(buf1);
1006    free(buf2);
1007}
1008
1009
1010/****************************************************************************
1011*  IMPORT DIALOG - COLUMN DOWN COUNTER
1012*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1013****************************************************************************/
1014void staticColumnDownCallback(Widget widget, XtPointer clientData, XtPointer callData)
1015{
1016    // GET POINTER OF THE ORIGINAL CALLER
1017    importDialog *iD= (importDialog *)clientData;
1018
1019    // CALL CLASS MEMBER FUNCTION
1020    iD->columnDownCallback(widget, callData);
1021}
1022
1023
1024/****************************************************************************
1025*  IMPORT DIALOG - COLUMN DOWN COUNTER
1026****************************************************************************/
1027void importDialog::columnDownCallback(Widget, XtPointer)
1028{
1029    // RETURN, IF NO TABLE DATA IS AVAILABLE
1030    if(!m_hasTableData) return;
1031
1032    int columns= m_table->columns;
1033
1034    // UPDATE HEADER COUNTER
1035    m_activeHeader--;
1036
1037    // IF COUNTER IS BEYOND UPPER LIMIT, DECREASE IT
1038    if(m_activeHeader < 0)
1039        m_activeHeader = m_activeHeader + columns;
1040
1041    // UPDATE DATA
1042    updateHeaderEntries();
1043}
1044
1045
1046/****************************************************************************
1047*  IMPORT DIALOG - COLUMN UP COUNTER
1048*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1049****************************************************************************/
1050void staticColumnUpCallback(Widget widget, XtPointer clientData, XtPointer callData)
1051{
1052    // GET POINTER OF THE ORIGINAL CALLER
1053    importDialog *iD= (importDialog *)clientData;
1054
1055    // CALL CLASS MEMBER FUNCTION
1056    iD->columnUpCallback(widget, callData);
1057}
1058
1059
1060/****************************************************************************
1061*  IMPORT DIALOG - COLUMN UP COUNTER
1062****************************************************************************/
1063void importDialog::columnUpCallback(Widget, XtPointer)
1064{
1065    // RETURN, IF NO TABLE DATA IS AVAILABLE
1066    if(!m_hasTableData) return;
1067
1068    int columns= m_table->columns;
1069
1070    // UPDATE HEADER COUNTER
1071    m_activeHeader++;
1072
1073    // IF COUNTER IS BEYOND UPPER LIMIT, DECREASE IT
1074    if(m_activeHeader >= columns)
1075        m_activeHeader= m_activeHeader - columns;
1076
1077    // UPDATE DATA
1078    updateHeaderEntries();
1079}
1080
1081
1082/****************************************************************************
1083*  IMPORT DIALOG - COPY COLUMN HEADER TO ARB HEADER
1084****************************************************************************/
1085void importDialog::copyHeaderEntries()
1086{
1087    int columns= m_table->columns;
1088    char **header= m_table->header;
1089    char **cell= m_table->cell;
1090    // char *entry;
1091
1092    for(int i= 0; i < columns; i++)
1093    {
1094        // CLEAR OLD HEADER, IF AVAILABLE
1095        // CLEAN STRING FOR USAGE AS ARB KEY
1096        freeset(header[i], GBS_string_2_key(cell[i]));
1097    }
1098
1099    m_table->hasHeader= true;
1100}
1101
1102
1103/****************************************************************************
1104*  IMPORT DIALOG - RESET THE ARB HEADER ENTRIES
1105*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1106****************************************************************************/
1107void staticResetHeaderButtonCallback(Widget, XtPointer clientData, XtPointer)
1108{
1109    // GET POINTER OF THE ORIGINAL CALLER
1110    importDialog *iD= (importDialog *)clientData;
1111
1112    // CALL CLASS MEMBER FUNCTION
1113    iD->copyHeaderEntries();
1114    iD->updateHeaderEntries();
1115}
1116
1117
1118/****************************************************************************
1119*  IMPORT DIALOG - TABLE HEADER CHANGED CALLBACK
1120*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1121****************************************************************************/
1122void staticHeaderChangedCallback(Widget widget, XtPointer clientData, XtPointer callData)
1123{
1124    // GET POINTER OF THE ORIGINAL CALLER
1125    importDialog *iD= (importDialog *)clientData;
1126
1127    // CALL CLASS MEMBER FUNCTION
1128    iD->headerChangedCallback(widget, callData);
1129}
1130
1131
1132/****************************************************************************
1133*  IMPORT DIALOG - TABLE HEADER CHANGED CALLBACK
1134****************************************************************************/
1135void importDialog::headerChangedCallback(Widget, XtPointer)
1136{
1137    // RETURN, IF NO TABLE DATA IS AVAILABLE
1138    if(!m_hasTableData) return;
1139
1140    char **header= m_table->header;
1141
1142    // GET CHANGED HEADER STRING
1143    char *str= XmTextGetString(m_containerHeaderWidget);
1144
1145    // CLEAN STRING FOR USAGE IN ARB
1146    str= GBS_string_2_key(str);
1147
1148    // FREE OLD ENTRY IF AVAILABLE
1149    if(header[m_activeHeader]) free(header[m_activeHeader]);
1150
1151    // CREATE NEW ENTRY
1152    char *entry= (char *)malloc((strlen(str) + 1) * sizeof(char));
1153    strcpy(entry, str);
1154
1155    header[m_activeHeader]= entry;
1156
1157    // RETURN THE STRING AS IT MAY HAVE CHANGED...
1158    XtVaSetValues(m_containerHeaderWidget, XmNvalue, m_table->header[m_activeHeader], NULL);
1159
1160    // UPDATE THE SAMPLE LIST DATA
1161    updateSampleList();
1162}
1163
1164
1165/****************************************************************************
1166*  IMPORT DIALOG - IMPORT DATA INTO ARB
1167*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1168****************************************************************************/
1169void staticImportDataCallback(Widget widget, XtPointer clientData, XtPointer callData)
1170{
1171    // GET POINTER OF THE ORIGINAL CALLER
1172    importDialog *iD= (importDialog *)clientData;
1173
1174    // CALL CLASS MEMBER FUNCTION
1175    iD->importDataCallback(widget, callData);
1176}
1177
1178
1179/****************************************************************************
1180*  IMPORT DIALOG - IMPORT DATA INTO ARB
1181****************************************************************************/
1182void importDialog::importDataCallback(Widget, XtPointer)
1183{
1184    // CREATE IMPORT DATA ENTRY
1185    importData data;
1186
1187    // INITIALIZE DATA ENTRIES
1188    data.species= m_species;
1189    data.experiment= m_experiment;
1190    data.proteome= m_proteome;
1191
1192    // IMPORT CSV DATA INTO ARB
1193    importCSV(m_table, &data);
1194}
1195
1196
1197/****************************************************************************
1198*  IMPORT DIALOG - ARB DATATYPE CHANGED CALLBACK
1199****************************************************************************/
1200void importDialog::changedDatatypeCallback(Widget, XtPointer callData)
1201{
1202    // RETURN, IF NO TABLE DATA IS AVAILABLE
1203    if(!m_hasTableData) return;
1204
1205    // GET COMBOBOX SELECTION STRUCT
1206    XmComboBoxCallbackStruct *cb= (XmComboBoxCallbackStruct *)callData;
1207
1208    // FETCH SELECTED ENTRY (STRING) FROM STRUCT
1209    char *type= (char *)XmStringUnparse(cb->item_or_text,
1210    XmFONTLIST_DEFAULT_TAG,
1211    XmCHARSET_TEXT, XmCHARSET_TEXT,
1212    NULL, 0, XmOUTPUT_ALL);
1213
1214    // IF AN EVENT OCCURED...
1215    if(cb->event)
1216    {
1217        // DEPENDING ON THE SELECTED STRING, SET THE NEW COLUMN DATATYPE
1218        if(!strcmp(type, "INT"))
1219            m_table->columnType[m_activeHeader]= DATATYPE_INT;
1220        else if(!strcmp(type, "FLOAT"))
1221            m_table->columnType[m_activeHeader]= DATATYPE_FLOAT;
1222        else
1223            m_table->columnType[m_activeHeader]= DATATYPE_STRING;
1224    }
1225
1226    // UPDATE THE SAMPLE LIST DATA
1227    updateSampleList();
1228
1229    // FREE ENTRY STRING
1230    XtFree(type);
1231}
1232
1233
1234/****************************************************************************
1235*  IMPORT DIALOG - ARB DATATYPE CHANGED CALLBACK
1236*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1237****************************************************************************/
1238void staticChangedDatatypeCallback(Widget widget, XtPointer clientData, XtPointer callData)
1239{
1240    // GET POINTER OF THE ORIGINAL CALLER
1241    importDialog *iD= (importDialog *)clientData;
1242
1243    // CALL CLASS MEMBER FUNCTION
1244    iD->changedDatatypeCallback(widget, callData);
1245}
1246
1247
1248/****************************************************************************
1249*  IMPORT DIALOG - ANOTHER SAMPLE LIST ENTRY WAS SELECTED
1250****************************************************************************/
1251void importDialog::sampleListEntryCallback(Widget, XtPointer callData)
1252{
1253    // RETURN, IF NO TABLE DATA IS AVAILABLE
1254    if(!m_hasTableData) return;
1255
1256    // GET LIST CALLBACK STRUCT (SELECTED ITEM ETC.)
1257    XmListCallbackStruct *cb= (XmListCallbackStruct *)callData;
1258
1259    // GET & SET NEW POSITION
1260    if(cb->item_position > 1) m_activeHeader= cb->item_position - 2;
1261
1262    // JUST TO AVOID COMPLICATIONS
1263    if(m_activeHeader < 0) m_activeHeader= 0;
1264    else if(m_activeHeader >= m_table->columns) m_activeHeader= m_table->columns - 1;
1265
1266    // UPDATE THE HEADER ENTRIES...
1267    updateHeaderEntries();
1268}
1269
1270
1271/****************************************************************************
1272*  IMPORT DIALOG - ANOTHER SAMPLE LIST ENTRY WAS SELECTED
1273*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1274****************************************************************************/
1275void staticSampleListEntryCallback(Widget widget, XtPointer clientData, XtPointer callData)
1276{
1277    // GET POINTER OF THE ORIGINAL CALLER
1278    importDialog *iD= (importDialog *)clientData;
1279
1280    // CALL CLASS MEMBER FUNCTION
1281    iD->sampleListEntryCallback(widget, callData);
1282}
1283
1284
1285/****************************************************************************
1286*  IMPORT DIALOG - OPEN AN EXTERNAL DIALOG FOR HEADER NAME SELECTION
1287****************************************************************************/
1288void importDialog::externHeaderSelectionCallback(Widget, XtPointer)
1289{
1290    // RETURN, IF NO TABLE DATA IS AVAILABLE
1291    if(!m_hasTableData) return;
1292
1293
1294    static entrySelectionDialog *esD;
1295
1296//     if(!esD)
1297//     {
1298        // CREATE NEW SELECTION DIALOG
1299        esD= new entrySelectionDialog(this);
1300
1301        // ADD ENTRY CHANGED CALLBACK
1302        esD->setListCallback(staticExternHeaderChangedCallback);
1303//     }
1304//     else
1305//     {
1306//         esD->show();
1307//     }
1308
1309
1310
1311//     // GET LIST CALLBACK STRUCT (SELECTED ITEM ETC.)
1312//     XmListCallbackStruct *cb= (XmListCallbackStruct *)callData;
1313//
1314//     // GET & SET NEW POSITION
1315//     if(cb->item_position > 1) m_activeHeader= cb->item_position - 2;
1316//
1317//     // JUST TO AVOID COMPLICATIONS
1318//     if(m_activeHeader < 0) m_activeHeader= 0;
1319//     else if(m_activeHeader >= m_table->columns) m_activeHeader= m_table->columns - 1;
1320//
1321//     // DEBUG DEBUG DEBUG
1322//     printf("DEBUG: ITEM= %d, ACTIVE= %d\n", cb->item_position, m_activeHeader);
1323//     // DEBUG DEBUG DEBUG
1324//
1325//     // UPDATE THE HEADER ENTRIES...
1326//     updateHeaderEntries();
1327}
1328
1329
1330/****************************************************************************
1331*  IMPORT DIALOG - OPEN AN EXTERNAL DIALOG FOR HEADER NAME SELECTION
1332*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1333****************************************************************************/
1334void staticExternHeaderSelectionCallback(Widget widget, XtPointer clientData, XtPointer callData)
1335{
1336    // GET POINTER OF THE ORIGINAL CALLER
1337    importDialog *iD= (importDialog *)clientData;
1338
1339    // CALL CLASS MEMBER FUNCTION
1340    iD->externHeaderSelectionCallback(widget, callData);
1341}
1342
1343
1344/****************************************************************************
1345*  CALLBACK - HEADER NAME CHANGED EXTERNALLY CALLBACK
1346*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1347****************************************************************************/
1348void staticExternHeaderChangedCallback(Widget, XtPointer clientData, XtPointer callData)
1349{
1350    // GET POINTER OF THE ORIGINAL CALLER
1351    importDialog *iD= (importDialog *)clientData;
1352
1353    // GET SPECIES NAME FROM CALLDATA
1354    char *name= *((char **)callData);
1355
1356    // SET NEW HEADER NAME
1357    iD->setHeaderName(name);
1358
1359    // UPDATE OUTPUT
1360    // iD->updateARBText();
1361}
1362
1363
1364/****************************************************************************
1365*  MAIN DIALOG - SET SPECIES NAME
1366****************************************************************************/
1367void importDialog::setHeaderName(char *name)
1368{
1369    // RETURN, IF NO TABLE DATA IS AVAILABLE
1370    if(!m_hasTableData) return;
1371
1372    char **header= m_table->header;
1373
1374    // FREE OLD ENTRY IF AVAILABLE
1375    if(header[m_activeHeader]) free(header[m_activeHeader]);
1376
1377    // CREATE NEW ENTRY
1378    char *entry= (char *)malloc((strlen(name) + 1) * sizeof(char));
1379    strcpy(entry, name);
1380
1381    header[m_activeHeader]= entry;
1382
1383    // RETURN THE STRING AS IT MAY HAVE CHANGED...
1384    XtVaSetValues(m_containerHeaderWidget, XmNvalue, m_table->header[m_activeHeader], NULL);
1385
1386    // UPDATE THE SAMPLE LIST DATA
1387    updateSampleList();
1388}
1389
1390
Note: See TracBrowser for help on using the repository browser.