source: branches/port5/PGT/image_dialog.cxx

Last change on this file was 5825, checked in by westram, 16 years ago
  • replaced GB_entry/GB_create/GB_search+GB_read_XXX by GBT_read_XXX
  • improved error handling in many functions
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 83.1 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: 5825 $
11
12
13#include "image_dialog.hxx"
14#include "selection_dialog.hxx"
15#include "config_dialog.hxx"
16#include "help_dialog.hxx"
17#include "math.h"
18#include <X11/cursorfont.h>
19
20#define ai_assert(cond) arb_assert(cond)
21
22#define LEFT_MOUSE_BUTTON   1
23#define MIDDLE_MOUSE_BUTTON 2
24#define RIGHT_MOUSE_BUTTON  3
25
26#define PROTEIN_MARK   1
27#define PROTEIN_UNMARK 2
28#define PROTEIN_INVERT 3
29
30// MAXIMUM DISTANCE BETWEEN SPOT CENTER AND
31// MOUSE CLICK DURING SELECTION
32#define MAX_SELECTION_DISTANCE 20
33
34// LOWER LIMIT FOR A GENERATED IMAGE
35#define MIN_IMAGE_SIZE 50
36
37
38// CALLBACK WRAPPER FUNCTIONS (STATIC)
39static void staticARBdataButtonCallback(Widget, XtPointer, XtPointer);
40static void staticTIFFnameButtonCallback(Widget, XtPointer, XtPointer);
41static void staticImageSpeciesCallback(Widget, XtPointer, XtPointer);
42static void staticImageExperimentCallback(Widget, XtPointer, XtPointer);
43static void staticImageProteomeCallback(Widget, XtPointer, XtPointer);
44static void staticImageFileDialogCloseCallback(Widget, XtPointer, XtPointer);
45static void staticImageFileDialogCallback(Widget, XtPointer, XtPointer);
46static void staticImageRedrawCallback(Widget, XtPointer, XtPointer);
47static void staticCrosshairButtonCallback(Widget, XtPointer, XtPointer);
48static void staticTextButtonCallback(Widget, XtPointer, XtPointer);
49static void staticTextOnlyButtonCallback(Widget, XtPointer, XtPointer);
50static void staticCircleButtonCallback(Widget, XtPointer, XtPointer);
51static void staticMarkedOnlyButtonCallback(Widget, XtPointer, XtPointer);
52static void staticMarkAllButtonCallback(Widget, XtPointer, XtPointer);
53static void staticMarkInvertButtonCallback(Widget, XtPointer, XtPointer);
54static void staticMarkNoneButtonCallback(Widget, XtPointer, XtPointer);
55static void staticImageEventCallback(Widget, XtPointer, XtPointer);
56static void staticLockToggleButtonCallback(Widget, XtPointer, XtPointer);
57static void static_ARB_protein_callback(GBDATA *, imageDialog *id, GB_CB_TYPE);
58static void static_ARB_gene_callback(GBDATA *, imageDialog *id, GB_CB_TYPE);
59static void static_PGT_config_callback(GBDATA *, imageDialog *id, GB_CB_TYPE);
60static void staticUpdateGeneButtonCallback(Widget, XtPointer, XtPointer);
61static void staticSpots2GenesButtonCallback(Widget, XtPointer, XtPointer);
62static void staticGenes2SpotsButtonCallback(Widget, XtPointer, XtPointer);
63static void staticHelpDialogCallback(Widget, XtPointer, XtPointer);
64static void staticMarkWithInfoButtonCallback(Widget, XtPointer, XtPointer);
65
66
67/****************************************************************************
68 *  IMAGE DIALOG - CONSTRUCTOR
69 ****************************************************************************/
70imageDialog::imageDialog(MDialog *d) : MDialog(d)
71{
72    // PREDEFINE VARIABLES
73    m_hasFileDialog= false;
74    m_hasTIFFdata= false;
75    m_hasImagedata= false;
76    m_hasARBdata= false;
77    m_lockVisualization= false;
78    m_updateGene= false;
79    m_filename= NULL;
80    m_ximage= NULL;
81    m_image= NULL;
82    m_width= 0;
83    m_height= 0;
84    m_numSpots= 0;
85    m_numMarkedSpots= 0;
86    m_numSelectedSpots= 0;
87    m_selectedSpotName= NULL;
88
89    // CHECK THE PGT AWARS (SET DEFAULT IF NEEDED)
90    checkCreateAWARS();
91
92    m_species= get_species_AWAR();
93    m_experiment= get_experiment_AWAR();
94    m_proteome= get_proteom_AWAR();
95
96    // DEBUG -- PRESET -- DEBUG -- PRESET
97    m_x_container= "x_coordinate";
98    m_y_container= "y_coordinate";
99    m_id_container= "name";
100    m_vol_container= "volume";
101    m_area_container= "area";
102    m_avg_container= "avg";
103    // DEBUG -- PRESET -- DEBUG -- PRESET
104
105    m_crosshairFlag= false;
106    m_circleFlag= false;
107    m_labelFlag= false;
108    m_linkedOnlyFlag= false;
109    m_textOnlyFlag= false;
110    m_markedOnlyFlag= false;
111
112    // CREATE WINDOW SHELL
113    createShell("");
114
115    // CREATE MAIN WINDOW WIDGETS
116    createWindow();
117
118    // SET WINDOW WIDTH
119    XtVaSetValues(m_shell,
120        XmNwidth, 800,
121        XmNheight, 600,
122        NULL);
123
124    // REALIZE SHELL & WIDGETS
125    realizeShell();
126
127    // SET WINDOW LABEL
128    setDialogTitle("PGT - Image View");
129
130    // UPDATE ARB SELECTION ENTRIES
131    updateARBText();
132
133    // CROSSHAIR CURSOR FOR DRAWING AREA
134    Cursor crosshair_cursor;
135    crosshair_cursor= XCreateFontCursor(XtDisplay(m_drawingArea), XC_crosshair);
136    XDefineCursor(XtDisplay(m_drawingArea), XtWindow(m_drawingArea), crosshair_cursor);
137
138    // GET GLOBAL SETTINGS (SAVED IN THE ARB DATABASE)
139    getSettings();
140
141    // ADD ARB AWAR CALLBACKS
142
143    add_imageDialog_callback(AWAR_PROTEIN_NAME,   static_ARB_protein_callback, this);
144    add_imageDialog_callback(AWAR_GENE_NAME,      static_ARB_gene_callback,    this);
145    add_imageDialog_callback(AWAR_CONFIG_CHANGED, static_PGT_config_callback,  this);
146
147    // add_protein_callback(static_ARB_protein_callback, this);
148    // add_gene_callback(static_ARB_gene_callback, this);
149    // add_config_callback(static_PGT_config_callback, this);
150}
151
152
153/****************************************************************************
154 *  IMAGE DIALOG - DESTRUCTOR
155 ****************************************************************************/
156imageDialog::~imageDialog()
157{
158    // FREE CLASS MEMBER STRINGS
159    if(m_species) free(m_species);
160    if(m_experiment) free(m_experiment);
161    if(m_proteome) free(m_proteome);
162
163    // FREE m_descriptorList
164    map<char*, char*, ltstr>::iterator descr_it;
165
166    for(descr_it= m_descriptorList.begin();
167        descr_it != m_descriptorList.end(); descr_it++)
168    {
169        free(((*descr_it).first));
170        free(((*descr_it).second));
171    }
172    m_descriptorList.clear();
173
174    // FREE m_gene_GBDATA_map
175    map<char *, GBDATA*, ltstr>::iterator gb_it;
176
177    for(gb_it= m_gene_GBDATA_map.begin();
178        gb_it != m_gene_GBDATA_map.end(); gb_it++)
179    {
180        free(((*gb_it).first));
181    }
182    m_gene_GBDATA_map.clear();
183
184    // FREE m_spotList
185    vector<SPOT>::iterator spot_it;
186
187    for(spot_it= m_spotList.begin(); spot_it != m_spotList.end(); spot_it++)
188    {
189//         if((*spot_it).text) free((*spot_it).text); // DONT! POINTER TO DESCR.LIST!!!
190        if((*spot_it).id) free((*spot_it).id);
191    }
192    m_spotList.clear();
193}
194
195
196/****************************************************************************
197*  IMAGE DIALOG - CREATE WINDOW
198****************************************************************************/
199void imageDialog::createWindow()
200{
201    // CREATE TOP LEVEL WIDGET
202    m_top= XtVaCreateManagedWidget("top",
203        xmFormWidgetClass, m_shell,
204        XmNmarginHeight, 0,
205        XmNmarginWidth, 0,
206        NULL);
207
208    // CREATE TOP TOOLBAR WIDGET
209    m_topToolbar= XtVaCreateManagedWidget("topToolbar",
210        xmFormWidgetClass, m_top,
211        XmNmarginHeight, 0,
212        XmNmarginWidth, 0,
213        XmNtopAttachment, XmATTACH_FORM,
214        XmNleftAttachment, XmATTACH_FORM,
215        XmNrightAttachment, XmATTACH_FORM,
216        NULL);
217
218    // CREATE HORIZONTAL SEPARATOR
219    Widget separator= XtVaCreateManagedWidget("separator",
220        xmSeparatorWidgetClass, m_top,
221        XmNtopAttachment, XmATTACH_WIDGET,
222        XmNtopWidget, m_topToolbar,
223        XmNleftAttachment, XmATTACH_FORM,
224        XmNrightAttachment, XmATTACH_FORM,
225        XmNorientation, XmHORIZONTAL,
226        NULL);
227
228    // CREATE LEFT TOOLBAR WIDGET
229    m_leftToolbar= XtVaCreateManagedWidget("topToolbar",
230        xmRowColumnWidgetClass, m_top,
231        XmNorientation, XmVERTICAL,
232        XmNmarginHeight, 0,
233        XmNmarginWidth, 0,
234        XmNtopAttachment, XmATTACH_WIDGET,
235        XmNtopWidget, separator,
236        XmNleftAttachment, XmATTACH_FORM,
237        XmNbottomAttachment, XmATTACH_FORM,
238        NULL);
239
240    // CREATE A STATUS LABEL AREA
241    m_statusLabel= XtVaCreateManagedWidget("statusLabel",
242        // xmTextWidgetClass, m_top,
243        xmLabelWidgetClass, m_top,
244        XmNbottomAttachment, XmATTACH_FORM,
245        XmNleftAttachment, XmATTACH_WIDGET,
246        XmNleftWidget, m_leftToolbar,
247        XmNrightAttachment, XmATTACH_FORM,
248        XmNheight, 20,
249        XmNborderWidth, 1,
250        XtVaTypedArg, XmNborderColor, XmRString, "gray", strlen("gray"),
251        XmNlabelString, CreateDlgString("Ok..."),
252        XmNalignment, XmALIGNMENT_BEGINNING,
253        NULL);
254
255    // CREATE A SCROLL WIDGET - CONTAINS THE DRAWING AREA
256    Widget scroll= XtVaCreateManagedWidget("scroll",
257        xmScrolledWindowWidgetClass, m_top,
258        XmNscrollingPolicy, XmAUTOMATIC,
259        XmNtopAttachment, XmATTACH_WIDGET,
260        XmNtopWidget, m_topToolbar,
261        XmNleftAttachment, XmATTACH_WIDGET,
262        XmNleftWidget, m_leftToolbar,
263        XmNrightAttachment, XmATTACH_FORM,
264        XmNbottomAttachment, XmATTACH_WIDGET,
265        XmNbottomWidget, m_statusLabel,
266        NULL);
267
268    // DRAWING AREA WIDGET - IMAGE IS DISPLAYED IN HERE
269    m_drawingArea= XtVaCreateManagedWidget("area",
270        xmDrawingAreaWidgetClass, scroll,
271        XmNwidth, 60,  // DEFAULT
272        XmNheight, 60, // DEFAULT
273        XtVaTypedArg, XmNbackground,
274        XmRString, "white", 6,
275        NULL);
276
277    // CALLBACK FOR DRAWING AREA: IF XIMAGE NEEDS REDRAW
278    XtAddCallback(m_drawingArea, XmNexposeCallback, staticImageRedrawCallback, this);
279
280    // CALLBACK FOR DRAWING AREA: IF A MOUSE (KEYBOARD) EVENT OCCURED
281    XtAddCallback(m_drawingArea, XmNinputCallback, staticImageEventCallback, this);
282
283    // FILL TOOLBARS WITH WIDGETS
284    createTopToolbar();
285    createLeftToolbar();
286}
287
288
289/****************************************************************************
290*  IMAGE DIALOG - CREATE TOP TOOLBAR
291****************************************************************************/
292void imageDialog::createTopToolbar()
293{
294    // CREATE PROTEOME DATA LABEL
295    Widget label01= XtVaCreateManagedWidget("label",
296        xmLabelWidgetClass, m_topToolbar,
297        XmNlabelString, CreateDlgString("Proteome Data:"),
298        XmNalignment, XmALIGNMENT_BEGINNING,
299        XmNheight, 30,
300        XmNwidth, 100,
301        XmNtopAttachment, XmATTACH_FORM,
302        XmNleftAttachment, XmATTACH_FORM,
303        NULL);
304
305    // CREATE TIFF IMAGE LABEL
306    Widget label02= XtVaCreateManagedWidget("label",
307        xmLabelWidgetClass, m_topToolbar,
308        XmNlabelString, CreateDlgString("TIFF Image:"),
309        XmNalignment, XmALIGNMENT_BEGINNING,
310        XmNheight, 30,
311        XmNwidth, 100,
312        XmNtopAttachment, XmATTACH_WIDGET,
313        XmNtopWidget, label01,
314        XmNleftAttachment, XmATTACH_FORM,
315        NULL);
316
317    Widget ARBdataButton= XtVaCreateManagedWidget("ARBdataButton",
318        xmPushButtonWidgetClass, m_topToolbar,
319        XmNlabelString, CreateDlgString("..."),
320        XmNwidth, 40,
321        XmNheight, 30,
322        XmNtopAttachment, XmATTACH_FORM,
323        XmNrightAttachment, XmATTACH_FORM,
324//         XmNleftAttachment, XmATTACH_WIDGET,
325//         XmNleftWidget, m_ARBdata,
326        NULL);
327    XtAddCallback(ARBdataButton, XmNactivateCallback, staticARBdataButtonCallback, this);
328
329    Widget TIFFnameButton= XtVaCreateManagedWidget("TIFFnameButton",
330        xmPushButtonWidgetClass, m_topToolbar,
331        XmNlabelString, CreateDlgString("..."),
332        XmNwidth, 40,
333        XmNheight, 30,
334        XmNtopAttachment, XmATTACH_WIDGET,
335        XmNtopWidget, ARBdataButton,
336        XmNrightAttachment, XmATTACH_FORM,
337//         XmNleftAttachment, XmATTACH_WIDGET,
338//         XmNleftWidget, m_TIFFname,
339        NULL);
340    XtAddCallback(TIFFnameButton, XmNactivateCallback, staticTIFFnameButtonCallback, this);
341
342    m_ARBdata= XtVaCreateManagedWidget("ARBentries",
343        xmTextWidgetClass, m_topToolbar,
344        XmNheight, 30,
345        XmNeditable, false,
346        XmNtopAttachment, XmATTACH_FORM,
347        XmNleftAttachment, XmATTACH_WIDGET,
348        XmNleftWidget, label01,
349        XmNrightAttachment, XmATTACH_WIDGET,
350        XmNrightWidget, ARBdataButton,
351        NULL);
352
353    m_TIFFname= XtVaCreateManagedWidget("TIFFname",
354        xmTextWidgetClass, m_topToolbar,
355        XmNheight, 30,
356        XmNtopAttachment, XmATTACH_WIDGET,
357        XmNtopWidget, m_ARBdata,
358        XmNleftAttachment, XmATTACH_WIDGET,
359        XmNleftWidget, label02,
360        XmNrightAttachment, XmATTACH_WIDGET,
361        XmNrightWidget, TIFFnameButton,
362        NULL);
363
364    m_LockToggleButton= XtVaCreateManagedWidget("Lock visualized data",
365        xmToggleButtonGadgetClass, m_topToolbar,
366        XmNset, false,
367        XmNheight, 30,
368        XmNtopAttachment, XmATTACH_WIDGET,
369        XmNtopWidget, m_TIFFname,
370        XmNrightAttachment, XmATTACH_FORM,
371        NULL);
372    XtAddCallback(m_LockToggleButton, XmNvalueChangedCallback, staticLockToggleButtonCallback, this);
373
374    m_UpdateGeneButton= XtVaCreateManagedWidget("Link to gene map",
375        xmToggleButtonGadgetClass, m_topToolbar,
376        XmNset, false,
377        XmNheight, 30,
378        XmNtopAttachment, XmATTACH_WIDGET,
379        XmNtopWidget, m_TIFFname,
380        XmNrightAttachment, XmATTACH_WIDGET,
381        XmNrightWidget, m_LockToggleButton,
382        NULL);
383    XtAddCallback(m_UpdateGeneButton, XmNvalueChangedCallback, staticUpdateGeneButtonCallback, this);
384
385    Widget label03= XtVaCreateManagedWidget("label",
386        xmLabelWidgetClass, m_topToolbar,
387        XmNlabelString, CreateDlgString("Mouse Buttons:"),
388        XmNalignment, XmALIGNMENT_BEGINNING,
389        XmNheight, 30,
390        XmNwidth, 100,
391        XmNtopAttachment, XmATTACH_WIDGET,
392        XmNtopWidget, label02,
393        XmNleftAttachment, XmATTACH_FORM,
394        NULL);
395
396    XtVaCreateManagedWidget("label",
397        xmLabelWidgetClass, m_topToolbar,
398        XmNlabelString, CreateDlgString("left button = select protein  --  right button = (un)mark protein"),
399        XmNalignment, XmALIGNMENT_BEGINNING,
400        XmNheight, 30,
401        XmNtopAttachment, XmATTACH_WIDGET,
402        XmNtopWidget, m_TIFFname,
403        XmNleftAttachment, XmATTACH_WIDGET,
404        XmNleftWidget, label03,
405        XmNrightAttachment, XmATTACH_WIDGET,
406        XmNrightWidget, m_UpdateGeneButton,
407        NULL);
408}
409
410
411/****************************************************************************
412*  IMAGE DIALOG - CREATE LEFT TOOLBAR
413****************************************************************************/
414void imageDialog::createLeftToolbar()
415{
416    // GET FOREGROUND AND BACKGROUND PIXEL COLORS
417    Pixel fg, bg;
418    XtVaGetValues(m_leftToolbar, XmNforeground, &fg, XmNbackground, &bg, NULL);
419
420    // USED PIXMAPS (BUTTON LOGOS)
421    Pixmap circle22_xpm, cross22_xpm, text22_xpm, markonly22_xpm, onlyid22_xpm,
422           markall22_xpm, marknone22_xpm, arb2mark_xpm, mark2arb_xpm, help_xpm,
423           markid22_xpm, markinvert22_xpm;
424
425    // OPEN THE PIXMAP FILES
426    Screen *s        = XtScreen(m_leftToolbar);
427    circle22_xpm=     PGT_LoadPixmap("circle22.xpm", s, fg, bg);
428    cross22_xpm=      PGT_LoadPixmap("cross22.xpm", s, fg, bg);
429    text22_xpm=       PGT_LoadPixmap("text22.xpm", s, fg, bg);
430    markonly22_xpm=   PGT_LoadPixmap("markonly22.xpm", s, fg, bg);
431    onlyid22_xpm=     PGT_LoadPixmap("onlyid22.xpm", s, fg, bg);
432    markall22_xpm=    PGT_LoadPixmap("markall22.xpm", s, fg, bg);
433    markinvert22_xpm= PGT_LoadPixmap("markinvert22.xpm", s, fg, bg);
434    marknone22_xpm=   PGT_LoadPixmap("marknone22.xpm", s, fg, bg);
435    markid22_xpm=     PGT_LoadPixmap("markid22.xpm", s, fg, bg);
436    arb2mark_xpm=     PGT_LoadPixmap("arb2mark22.xpm", s, fg, bg);
437    mark2arb_xpm=     PGT_LoadPixmap("mark2arb22.xpm", s, fg, bg);
438    help_xpm=         PGT_LoadPixmap("help22.xpm", s, fg, bg);
439
440    // SHOW CROSSHAIR BUTTON
441    Widget spotsButton= XtVaCreateManagedWidget("spotsbtn",
442        xmPushButtonWidgetClass, m_leftToolbar,
443        XmNlabelType, XmPIXMAP,
444        XmNlabelPixmap, cross22_xpm,
445        NULL);
446    XtAddCallback(spotsButton, XmNactivateCallback, staticCrosshairButtonCallback, this);
447
448    // SHOW CIRCLE BUTTON
449    Widget circleButton= XtVaCreateManagedWidget("circlebtn",
450        xmPushButtonWidgetClass, m_leftToolbar,
451        XmNlabelType, XmPIXMAP,
452        XmNlabelPixmap, circle22_xpm,
453        NULL);
454    XtAddCallback(circleButton, XmNactivateCallback, staticCircleButtonCallback, this);
455
456    // SHOW TEXT BUTTON
457    Widget textButton= XtVaCreateManagedWidget("textbtn",
458        xmPushButtonWidgetClass, m_leftToolbar,
459        XmNlabelType, XmPIXMAP,
460        XmNlabelPixmap, text22_xpm,
461        NULL);
462    XtAddCallback(textButton, XmNactivateCallback, staticTextButtonCallback, this);
463
464    // CREATE HORIZONTAL SEPARATOR
465    XtVaCreateManagedWidget("separator",
466        xmSeparatorWidgetClass, m_leftToolbar,
467        XmNorientation, XmHORIZONTAL,
468        NULL);
469
470    // SHOW ONLY SPOTS WITH TEXT BUTTON
471    Widget textOnlyButton= XtVaCreateManagedWidget("textonlybtn",
472        xmPushButtonWidgetClass, m_leftToolbar,
473        XmNlabelType, XmPIXMAP,
474        XmNlabelPixmap, onlyid22_xpm,
475        NULL);
476    XtAddCallback(textOnlyButton, XmNactivateCallback, staticTextOnlyButtonCallback, this);
477
478    // SHOW ONLY SPOTS WITH TEXT BUTTON
479    Widget markedOnlyButton= XtVaCreateManagedWidget("markedonlybtn",
480        xmPushButtonWidgetClass, m_leftToolbar,
481        XmNlabelType, XmPIXMAP,
482        XmNlabelPixmap, markonly22_xpm,
483        NULL);
484    XtAddCallback(markedOnlyButton, XmNactivateCallback, staticMarkedOnlyButtonCallback, this);
485
486    // CREATE HORIZONTAL SEPARATOR
487    XtVaCreateManagedWidget("separator",
488        xmSeparatorWidgetClass, m_leftToolbar,
489        XmNorientation, XmHORIZONTAL,
490        NULL);
491
492    // MARK ALL PROTEINS BUTTON
493    Widget markAllButton= XtVaCreateManagedWidget("markallbtn",
494        xmPushButtonWidgetClass, m_leftToolbar,
495        XmNlabelType, XmPIXMAP,
496        XmNlabelPixmap, markall22_xpm,
497        NULL);
498    XtAddCallback(markAllButton, XmNactivateCallback, staticMarkAllButtonCallback, this);
499
500    // INVERT PROTEIN MARKER BUTTON
501    Widget markInvertButton= XtVaCreateManagedWidget("markinvertbtn",
502        xmPushButtonWidgetClass, m_leftToolbar,
503        XmNlabelType, XmPIXMAP,
504        XmNlabelPixmap, markinvert22_xpm,
505        NULL);
506    XtAddCallback(markInvertButton, XmNactivateCallback, staticMarkInvertButtonCallback, this);
507
508    // UNMARK ALL PROTEINS BUTTON
509    Widget markNoneButton= XtVaCreateManagedWidget("marknonebtn",
510        xmPushButtonWidgetClass, m_leftToolbar,
511        XmNlabelType, XmPIXMAP,
512        XmNlabelPixmap, marknone22_xpm,
513        NULL);
514    XtAddCallback(markNoneButton, XmNactivateCallback, staticMarkNoneButtonCallback, this);
515
516    // TRANSFER MARKER FROM SPOTS TO GENES BUTTON
517    Widget markSpots2GenesButton= XtVaCreateManagedWidget("markspot2genesbtn",
518        xmPushButtonWidgetClass, m_leftToolbar,
519        XmNlabelType, XmPIXMAP,
520        XmNlabelPixmap, mark2arb_xpm,
521        NULL);
522    XtAddCallback(markSpots2GenesButton, XmNactivateCallback, staticSpots2GenesButtonCallback, this);
523
524    // TRANSFER MARKER FROM SPOTS TO GENES BUTTON
525    Widget markGenes2SpotsButton= XtVaCreateManagedWidget("markspot2genebtn",
526        xmPushButtonWidgetClass, m_leftToolbar,
527        XmNlabelType, XmPIXMAP,
528        XmNlabelPixmap, arb2mark_xpm,
529        NULL);
530    XtAddCallback(markGenes2SpotsButton, XmNactivateCallback, staticGenes2SpotsButtonCallback, this);
531
532    // MARK ALL SPOTS WITH INFO
533    Widget markSpotsWithInfoButton= XtVaCreateManagedWidget("markspotswithinfobtn",
534        xmPushButtonWidgetClass, m_leftToolbar,
535        XmNlabelType, XmPIXMAP,
536        XmNlabelPixmap, markid22_xpm,
537        NULL);
538    XtAddCallback(markSpotsWithInfoButton, XmNactivateCallback, staticMarkWithInfoButtonCallback, this);
539
540    // HELP BUTTON
541    Widget helpButton= XtVaCreateManagedWidget("helpbtn",
542        xmPushButtonWidgetClass, m_leftToolbar,
543        XmNlabelType, XmPIXMAP,
544        XmNlabelPixmap, help_xpm,
545        NULL);
546    XtAddCallback(helpButton, XmNactivateCallback, staticHelpDialogCallback, this);
547}
548
549
550/****************************************************************************
551*  CALLBACK - ARB DATA BUTTON CLICKED...
552*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
553****************************************************************************/
554static void staticARBdataButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
555{
556    // GET POINTER OF THE ORIGINAL CALLER
557    imageDialog *sD= (imageDialog *)clientData;
558
559    // CALL CLASS MEMBER FUNCTION
560    sD->ARBdataButtonCallback(widget, callData);
561}
562
563
564/****************************************************************************
565*  CALLBACK - ARB DATA BUTTON CLICKED...
566****************************************************************************/
567void imageDialog::ARBdataButtonCallback(Widget, XtPointer)
568{
569    selectionDialog *sD= new selectionDialog(this, SELECTION_DIALOG_READ);
570
571    // SET SPECIES, EXPERIMENT AND PROTEOME CALLBACK
572    sD->setSpeciesCallback(staticImageSpeciesCallback);
573    sD->setExperimentCallback(staticImageExperimentCallback);
574    sD->setProteomeCallback(staticImageProteomeCallback);
575}
576
577
578/****************************************************************************
579*  CALLBACK - SELECTION DIALOG SPECIES CHANGED
580****************************************************************************/
581static void staticImageSpeciesCallback(Widget, XtPointer clientData, XtPointer callData)
582{
583    // GET POINTER OF THE ORIGINAL CALLER
584    imageDialog *iD= (imageDialog *)clientData;
585
586    // GET SPECIES NAME FROM CALLDATA
587    char *name= *((char **)callData);
588
589    // SET NEW NAMES
590    iD->setSpecies(name);
591    iD->setExperiment("");
592    iD->setProteome("");
593
594    // UPDATE OUTPUT
595    iD->updateARBText();
596}
597
598
599/****************************************************************************
600*  CALLBACK - SELECTION DIALOG SPECIES CHANGED
601****************************************************************************/
602static void staticImageExperimentCallback(Widget, XtPointer clientData, XtPointer callData)
603{
604    // GET POINTER OF THE ORIGINAL CALLER
605    imageDialog *iD= (imageDialog *)clientData;
606
607    // GET SPECIES NAME FROM CALLDATA
608    char *name= *((char **)callData);
609
610    // SET NEW NAMES
611    iD->setExperiment(name);
612    iD->setProteome("");
613
614    // UPDATE OUTPUT
615    iD->updateARBText();
616}
617
618
619/****************************************************************************
620*  CALLBACK - SELECTION DIALOG SPECIES CHANGED
621****************************************************************************/
622static void staticImageProteomeCallback(Widget, XtPointer clientData, XtPointer callData)
623{
624    // GET POINTER OF THE ORIGINAL CALLER
625    imageDialog *iD= (imageDialog *)clientData;
626
627    // GET SPECIES NAME FROM CALLDATA
628    char *name= *((char **)callData);
629
630    // SET NEW NAMES
631    iD->setProteome(name);
632
633    // UPDATE OUTPUT
634    iD->updateARBText();
635}
636
637
638/****************************************************************************
639*  CALLBACK - TIFF IMAGE NAME BUTTON CLICKED...
640*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
641****************************************************************************/
642static void staticTIFFnameButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
643{
644    // GET POINTER OF THE ORIGINAL CALLER
645    imageDialog *sD= (imageDialog *)clientData;
646
647    // CALL CLASS MEMBER FUNCTION
648    sD->TIFFnameButtonCallback(widget, callData);
649}
650
651
652/****************************************************************************
653*  CALLBACK - TIFF IMAGE NAME BUTTON CLICKED...
654****************************************************************************/
655void imageDialog::TIFFnameButtonCallback(Widget, XtPointer)
656{
657    if (!m_hasFileDialog)
658    {
659        m_fileDialog= XmCreateFileSelectionDialog(m_shell, const_cast<char*>("importDialog"), NULL, 0);
660        XtAddCallback(m_fileDialog, XmNokCallback, staticImageFileDialogCallback, this);
661        XtAddCallback(m_fileDialog, XmNcancelCallback, staticImageFileDialogCloseCallback, this);
662        XtAddCallback(m_fileDialog, XmNnoMatchCallback, staticImageFileDialogCloseCallback, this);
663        XtSetSensitive(XmFileSelectionBoxGetChild(m_fileDialog, XmDIALOG_HELP_BUTTON), False);
664        XtVaSetValues(m_fileDialog, XmNdialogTitle, CreateDlgString("Open proteome data file..."), NULL);
665        m_hasFileDialog= true;
666    }
667
668    XtManageChild(m_fileDialog);
669    XtPopup(XtParent(m_fileDialog), XtGrabNone);
670}
671
672
673/****************************************************************************
674*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
675*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
676****************************************************************************/
677static void staticImageFileDialogCloseCallback(Widget parent, XtPointer, XtPointer)
678{
679    // CLOSE FILE OPEN DIALOG
680    XtUnmanageChild(parent);
681}
682
683
684/****************************************************************************
685*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
686*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
687****************************************************************************/
688static void staticImageFileDialogCallback(Widget widget, XtPointer clientData, XtPointer callData)
689{
690    // GET POINTER OF THE ORIGINAL CALLER
691    imageDialog *iD= (imageDialog *)clientData;
692
693    // CALL CLASS MEMBER FUNCTION
694    iD->imageFileDialogCallback(widget, callData);
695}
696
697
698/****************************************************************************
699*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
700****************************************************************************/
701void imageDialog::imageFileDialogCallback(Widget widget, XtPointer callData)
702{
703    // FETCH SELECTED FILENAME
704    XmFileSelectionBoxCallbackStruct *cbs;
705    cbs= (XmFileSelectionBoxCallbackStruct *)callData;
706
707    // CONVERT XMSTRING TO CHAR*
708    char *str;
709    XmStringGetLtoR(cbs->value, XmFONTLIST_DEFAULT_TAG, &str);
710
711    // CLOSE FILE OPEN DIALOG
712    XtUnmanageChild(widget);
713
714    // WRITE STRING TO TEXT FIELD
715    XtVaSetValues(m_TIFFname, XmNvalue, str, NULL);
716
717    // SAVE THE PATH TO THE IMAGE IN THE ARB DATABASE
718    set_ARB_image_path(str);
719
720    // LOAD/UPDATE THE IMAGE
721    updateImage();
722}
723
724
725/****************************************************************************
726*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
727*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
728****************************************************************************/
729static void staticCrosshairButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
730{
731    // GET POINTER OF THE ORIGINAL CALLER
732    imageDialog *iD= (imageDialog *)clientData;
733
734    // CALL CLASS MEMBER FUNCTION
735    iD->crosshairButtonCallback(widget, callData);
736}
737
738
739/****************************************************************************
740*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
741****************************************************************************/
742void imageDialog::crosshairButtonCallback(Widget, XtPointer)
743{
744    // INVERT FLAG
745    m_crosshairFlag= !m_crosshairFlag;
746
747    // REDRAW IMAGE
748    imageRedraw();
749}
750
751
752/****************************************************************************
753*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
754*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
755****************************************************************************/
756static void staticTextButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
757{
758    // GET POINTER OF THE ORIGINAL CALLER
759    imageDialog *iD= (imageDialog *)clientData;
760
761    // CALL CLASS MEMBER FUNCTION
762    iD->textButtonCallback(widget, callData);
763}
764
765
766/****************************************************************************
767*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
768****************************************************************************/
769void imageDialog::textButtonCallback(Widget, XtPointer)
770{
771    // INVERT FLAG
772    m_labelFlag= !m_labelFlag;
773
774    // REDRAW IMAGE
775    imageRedraw();
776}
777
778
779/****************************************************************************
780*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
781*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
782****************************************************************************/
783static void staticTextOnlyButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
784{
785    // GET POINTER OF THE ORIGINAL CALLER
786    imageDialog *iD= (imageDialog *)clientData;
787
788    // CALL CLASS MEMBER FUNCTION
789    iD->textOnlyButtonCallback(widget, callData);
790}
791
792
793/****************************************************************************
794*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
795****************************************************************************/
796void imageDialog::textOnlyButtonCallback(Widget, XtPointer)
797{
798    // INVERT FLAG
799    m_textOnlyFlag= !m_textOnlyFlag;
800
801    // REDRAW IMAGE
802    imageRedraw();
803}
804
805
806/****************************************************************************
807*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
808*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
809****************************************************************************/
810static void staticCircleButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
811{
812    // GET POINTER OF THE ORIGINAL CALLER
813    imageDialog *iD= (imageDialog *)clientData;
814
815    // CALL CLASS MEMBER FUNCTION
816    iD->circleButtonCallback(widget, callData);
817}
818
819
820/****************************************************************************
821*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
822****************************************************************************/
823void imageDialog::circleButtonCallback(Widget, XtPointer)
824{
825    // INVERT FLAG
826    m_circleFlag= !m_circleFlag;
827
828    // REDRAW IMAGE
829    imageRedraw();
830}
831
832
833/****************************************************************************
834*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
835*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
836****************************************************************************/
837static void staticMarkedOnlyButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
838{
839    // GET POINTER OF THE ORIGINAL CALLER
840    imageDialog *iD= (imageDialog *)clientData;
841
842    // CALL CLASS MEMBER FUNCTION
843    iD->markedOnlyButtonCallback(widget, callData);
844}
845
846
847/****************************************************************************
848*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
849****************************************************************************/
850void imageDialog::markedOnlyButtonCallback(Widget, XtPointer)
851{
852    // INVERT FLAG
853    m_markedOnlyFlag= !m_markedOnlyFlag;
854
855    // REDRAW IMAGE
856    imageRedraw();
857}
858
859
860/****************************************************************************
861*  CALLBACK - MARK ALL BUTTON
862*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
863****************************************************************************/
864static void staticMarkAllButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
865{
866    // GET POINTER OF THE ORIGINAL CALLER
867    imageDialog *iD= (imageDialog *)clientData;
868
869    // CALL CLASS MEMBER FUNCTION
870    iD->markAllButtonCallback(widget, callData);
871}
872
873
874/****************************************************************************
875*  CALLBACK - MARK ALL BUTTON
876****************************************************************************/
877void imageDialog::markAllButtonCallback(Widget, XtPointer)
878{
879    // SET MARKER
880    setAllMarker(PROTEIN_MARK);
881
882    // CREATE A NEW SPOT LIST
883    createSpotList();
884
885    // REDRAW IMAGE
886    imageRedraw();
887}
888
889
890/****************************************************************************
891*  CALLBACK - INVERT MARK BUTTON
892*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
893****************************************************************************/
894static void staticMarkInvertButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
895{
896    // GET POINTER OF THE ORIGINAL CALLER
897    imageDialog *iD= (imageDialog *)clientData;
898
899    // CALL CLASS MEMBER FUNCTION
900    iD->markInvertButtonCallback(widget, callData);
901}
902
903
904/****************************************************************************
905*  CALLBACK - INVERT MARK BUTTON
906****************************************************************************/
907void imageDialog::markInvertButtonCallback(Widget, XtPointer)
908{
909    // SET MARKER
910    setAllMarker(PROTEIN_INVERT);
911
912    // CREATE A NEW SPOT LIST
913    createSpotList();
914
915    // REDRAW IMAGE
916    imageRedraw();
917}
918
919
920/****************************************************************************
921*  CALLBACK - MARK NONE BUTTON
922*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
923****************************************************************************/
924static void staticMarkNoneButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
925{
926    // GET POINTER OF THE ORIGINAL CALLER
927    imageDialog *iD= (imageDialog *)clientData;
928
929    // CALL CLASS MEMBER FUNCTION
930    iD->markNoneButtonCallback(widget, callData);
931}
932
933
934/****************************************************************************
935*  CALLBACK - MARK NONE BUTTON
936****************************************************************************/
937void imageDialog::markNoneButtonCallback(Widget, XtPointer)
938{
939    // SET MARKER
940    setAllMarker(PROTEIN_UNMARK);
941
942    // CREATE A NEW SPOT LIST
943    createSpotList();
944
945    // REDRAW IMAGE
946    imageRedraw();
947}
948
949
950/****************************************************************************
951*  (UN)MARK ALL BUTTONS
952****************************************************************************/
953bool imageDialog::setAllMarker(int state)
954{
955    GBDATA *gb_data, *gb_proteine_data, *gb_protein;
956    int flag;
957
958    // GET MAIN ARB GBDATA
959    gb_data= get_gbData();
960    if(!gb_data) return false;
961
962    // FIND SELECTED PROTEIN DATA ENTRY
963    gb_proteine_data= find_proteine_data(m_species, m_experiment, m_proteome);
964    if(!gb_proteine_data) return false;
965
966    // INIT AN ARB TRANSACTION
967    ARB_begin_transaction();
968
969    // BROWSE ALL PROTEIN ENTRIES...
970    gb_protein= GB_entry(gb_proteine_data, "protein");
971
972    while(gb_protein)
973    {
974        // GET ACTUAL STATE
975        flag= GB_read_flag(gb_protein);
976
977        switch(state)
978        {
979            case PROTEIN_MARK:
980                GB_write_flag(gb_protein, 1);
981            break;
982            case PROTEIN_UNMARK:
983                GB_write_flag(gb_protein, 0);
984            break;
985            case PROTEIN_INVERT:
986                GB_write_flag(gb_protein, !flag);
987            break;
988        }
989
990        // FETCH NEXT PROTEIN FROM LIST
991        ai_assert(GB_has_key(gb_protein, "protein"));
992        gb_protein= GB_nextEntry(gb_protein);
993    }
994
995    // CLOSE THE ARB TRANSACTION
996    ARB_commit_transaction();
997
998    return true;
999}
1000
1001
1002/****************************************************************************
1003*  CALLBACK - LOCK/UNLOCK ARB AWARS AND DATA UPDATE
1004*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1005****************************************************************************/
1006static void staticLockToggleButtonCallback(Widget widget, XtPointer clientData, XtPointer callData)
1007{
1008    // GET POINTER OF THE ORIGINAL CALLER
1009    imageDialog *iD= (imageDialog *)clientData;
1010
1011    // CALL CLASS MEMBER FUNCTION
1012    iD->lockToggleButtonCallback(widget, callData);
1013}
1014
1015
1016/****************************************************************************
1017*  CALLBACK - IMPORT IMAGE FILE NAME VALUE
1018****************************************************************************/
1019void imageDialog::lockToggleButtonCallback(Widget, XtPointer callData)
1020{
1021    XmToggleButtonCallbackStruct *cbs= (XmToggleButtonCallbackStruct *)callData;
1022
1023    if(cbs->set) m_lockVisualization= true;
1024    else m_lockVisualization= false;
1025
1026    // REDRAW IMAGE
1027    imageRedraw();
1028}
1029
1030
1031/****************************************************************************
1032*  IMAGE DIALOG - SET NEW SPECIES NAME
1033****************************************************************************/
1034void imageDialog::setSpecies(const char *species)
1035{
1036    // REMOVE OLD ENTRY, IF NECESSARY
1037    if(m_species) free(m_species);
1038
1039    m_species= strdup(species);
1040
1041    // SET ARB DATA AVAILABLE FLAG
1042    m_hasARBdata= false;
1043
1044    // SEND DATA TO ARB AWAR (IF NOT LOCKED)
1045    if(!m_lockVisualization) set_species_AWAR(m_species);
1046}
1047
1048
1049/****************************************************************************
1050*  IMAGE DIALOG - SET NEW EXPERIMENT NAME
1051****************************************************************************/
1052void imageDialog::setExperiment(const char *experiment)
1053{
1054    // REMOVE OLD ENTRY, IF NECESSARY
1055    if(m_experiment) free(m_experiment);
1056
1057    m_experiment= strdup(experiment);
1058
1059    // SET ARB DATA AVAILABLE FLAG
1060    m_hasARBdata= false;
1061
1062    // SEND DATA TO ARB AWAR (IF NOT LOCKED)
1063    if(!m_lockVisualization) set_experiment_AWAR(m_experiment);
1064}
1065
1066
1067/****************************************************************************
1068*  IMAGE DIALOG - SET NEW PROTEOME NAME
1069****************************************************************************/
1070void imageDialog::setProteome(const char *proteome)
1071{
1072    // REMOVE OLD ENTRY, IF NECESSARY
1073    if(m_proteome) free(m_proteome);
1074
1075    m_proteome= strdup(proteome);
1076
1077    // CREATE A NEW SPOT LIST
1078    createSpotList();
1079
1080    // SET ARB DATA AVAILABLE FLAG
1081    m_hasARBdata= true;
1082
1083    // DO WE HAVE AN AVAILABLE IMAGE? IF NOT, SIMULATE ONE...
1084    if(!m_hasTIFFdata && !m_hasImagedata) blankImage();
1085
1086    // SEND DATA TO ARB AWAR (IF NOT LOCKED)
1087    if(!m_lockVisualization) set_proteom_AWAR(m_proteome);
1088}
1089
1090
1091/****************************************************************************
1092*  IMAGE DIALOG - UPDATE THE ARB TEXT WIDGET
1093****************************************************************************/
1094void imageDialog::updateARBText()
1095{
1096    // CREATE BUFFER
1097    char *buf= (char *)malloc(1024 * sizeof(char));
1098    const char *sp=   "no species";
1099    const char *exp=  "no experiment";
1100    const char *prot= "no proteome";
1101
1102    // USE REAL STRINGS IF AVAILABLE
1103    if(m_species && (strlen(m_species))) sp= m_species;
1104    if(m_experiment && (strlen(m_experiment))) exp= m_experiment;
1105    if(m_proteome && (strlen(m_proteome))) prot= m_proteome;
1106
1107    // FILL BUFFER STRING
1108    sprintf(buf, "[%s] -> [%s] -> [%s]", sp, exp, prot);
1109
1110    // COPY STRING TO TEXT FIELD
1111    XtVaSetValues(m_ARBdata, XmNvalue, buf, NULL);
1112
1113    if(m_species && m_experiment && m_proteome)
1114    {
1115        // UPDATE FLAG
1116        m_hasARBdata= true;
1117
1118        // CREATE DESCRIPTIONS TABLE
1119        createDescriptions();
1120
1121        // CREATE A NEW SPOT LIST
1122        createSpotList();
1123
1124        // CHECK IF AN IMAGE IS AVAILABLE AND OPEN IT IF POSSIBLE
1125        char *path= get_ARB_image_path();
1126        if(path)
1127        {
1128            // WRITE STRING TO TEXT FIELD
1129            XtVaSetValues(m_TIFFname, XmNvalue, path, NULL);
1130
1131            // LOAD/UPDATE THE IMAGE
1132            if(updateImage())
1133            {
1134                // updateImage() failed...
1135
1136                // CLEAR ARB IMAGE PATH
1137                set_ARB_image_path("");
1138
1139                // WRITE STRING TO TEXT FIELD
1140                XtVaSetValues(m_TIFFname, XmNvalue, "", NULL);
1141            }
1142        }
1143    }
1144    // FREE BUFFER
1145    free(buf);
1146}
1147
1148
1149/****************************************************************************
1150*  IMAGE DIALOG - GET THE PATH TO THE LAST USED IMAGE
1151****************************************************************************/
1152char *imageDialog::get_ARB_image_path()
1153{
1154    if(!m_hasARBdata) return NULL;
1155
1156    char *path= NULL;
1157
1158    GBDATA *gb_proteom= find_proteome(m_species, m_experiment, m_proteome);
1159
1160    if(gb_proteom)
1161    {
1162        ARB_begin_transaction();
1163
1164        GBDATA *gb_imagepath= GB_entry(gb_proteom, "image_path");
1165
1166        if(gb_imagepath) path= GB_read_string(gb_imagepath);
1167
1168        ARB_commit_transaction();
1169    }
1170
1171    return path;
1172}
1173
1174
1175/****************************************************************************
1176*  IMAGE DIALOG - GET THE PATH TO THE LAST USED IMAGE
1177****************************************************************************/
1178void imageDialog::set_ARB_image_path(const char *path)
1179{
1180    if(!m_hasARBdata) return;
1181
1182    GBDATA *gb_proteom;
1183
1184    gb_proteom= find_proteome(m_species, m_experiment, m_proteome);
1185
1186    if(gb_proteom)
1187    {
1188        ARB_begin_transaction();
1189        GB_ERROR error = GBT_write_string(gb_proteom, "image_path", path);
1190        pgt_assert(!error);
1191        ARB_commit_transaction();
1192    }
1193
1194    return;
1195}
1196
1197
1198/****************************************************************************
1199*  IMAGE DIALOG - LOAD/UPDATE THE ARB AND IMAGE DATA
1200****************************************************************************/
1201int imageDialog::updateImage()
1202{
1203    // CREATE BUFFER
1204    char *buf= (char *)malloc(1024 * sizeof(char));
1205    char *filename;
1206    char *file;
1207
1208    // SET ENVIRONMENT VARIABLES
1209    Display *display= XtDisplay(m_drawingArea);
1210    Window window= XtWindow(m_drawingArea);
1211
1212    // GET SELECTED TIFF FILENAME
1213    filename= XmTextGetString(m_TIFFname);
1214
1215    // FILE ALREADY OPENED?
1216    if(m_filename && (!strcmp(filename, m_filename))) return -1;
1217
1218    // CREATE NEW IMAGE CLASS IF NECESSARY
1219    if(!m_image) m_image= new TIFFimage();
1220
1221    // OPEN TIFF IMAGE FILE
1222    if(m_image->open(filename)) return -1;
1223
1224    // GET DIMENSIONS
1225    m_width= m_image->width();
1226    m_height= m_image->height();
1227
1228    // CREATE A PIXMAP
1229    m_pixmap = XCreatePixmap(display, window, m_width, m_height, XDefaultDepth(display, 0));
1230
1231    // CREATE XIMAGE FROM IMAGE DATA
1232    m_ximage= m_image->createXImage(m_drawingArea);
1233
1234    // TIFF DATA AVAILABLE
1235    m_hasTIFFdata= true;
1236    m_hasImagedata= true;
1237
1238    // TRIGGER THE REDRAWING OF THE IMAGE
1239    imageRedraw();
1240
1241    // STORE NEW FILENAME
1242    m_filename= filename;
1243
1244    // ISOLATE FILENAME WITHOUT PATH (FOR USE IN WINDOW TITLE)
1245    file= strrchr(filename, '/');
1246    if(!file) file= filename; // IF NO '/' WAS FOUND USE WHOLE FILENAME
1247    else if(*(file+1)) file++; // REMOVE '/' CHAR FROM BEGINNING
1248
1249    // SET WINDOW TITLE
1250    sprintf(buf, "PGT - Image View (%s)", file);
1251    setDialogTitle(buf);
1252
1253    // FREE BUFFER
1254    free(buf);
1255
1256    return 0;
1257}
1258
1259
1260/****************************************************************************
1261*  IMAGE DIALOG - CREATE A BLANK IMAGE
1262*  (THIS IS NEEDED FOR DATA WITHOUT A RELATED IMAGE FILE)
1263****************************************************************************/
1264int imageDialog::blankImage()
1265{
1266    // CREATE AND FILL A BLANK IMAGE BACKGROUND
1267    int retval= fillBlankImage();
1268
1269    // TRIGGER THE REDRAWING OF THE IMAGE
1270    imageRedraw();
1271
1272    return retval;
1273}
1274
1275
1276/****************************************************************************
1277*  IMAGE DIALOG - FETCH THE MAX. DIMENSIONS FOR A BLANK WINDOW
1278****************************************************************************/
1279int imageDialog::getSpotMaxDimensions()
1280{
1281    // RETURN, IF WE HAVE NO AVAILABLE DATA
1282    if(!m_hasARBdata)
1283    {
1284        m_width=  0;
1285        m_height= 0;
1286
1287        return -1;
1288    }
1289
1290    // CREATE AN ITERATOR
1291    vector<SPOT>::iterator spot_it;
1292
1293    float max_fx= 0, max_fy= 0;
1294
1295    // TRAVERSE THE COMPLETE LIST
1296    for(spot_it= m_spotList.begin(); spot_it != m_spotList.end(); ++spot_it)
1297    {
1298        if((*spot_it).x + (*spot_it).diameter > max_fx)
1299            max_fx= (*spot_it).x + (*spot_it).diameter;
1300
1301        if((*spot_it).y + (*spot_it).diameter > max_fy)
1302            max_fy= (*spot_it).y + (*spot_it).diameter;
1303    }
1304
1305    m_width= (int)max_fx;
1306    m_height= (int)max_fy;
1307
1308    return 0;
1309}
1310
1311
1312/****************************************************************************
1313*  IMAGE DIALOG - FETCH THE MAX. DIMENSIONS FOR A BLANK WINDOW
1314****************************************************************************/
1315int imageDialog::fillBlankImage()
1316{
1317    // SET ENVIRONMENT VARIABLES
1318    Display *display= XtDisplay(m_drawingArea);
1319    Window window= XtWindow(m_drawingArea);
1320    GC gc= XCreateGC(display, window, 0, 0);
1321
1322    // GET SPOT MAX. DIMENSIONS (TO M_WIDTH, M_HEIGHT)
1323    getSpotMaxDimensions();
1324
1325    // EXIT, IF SIZE IS TOO SMALL
1326    if((m_width < MIN_IMAGE_SIZE) && (m_width < MIN_IMAGE_SIZE))
1327        return -1;
1328
1329    // CREATE A PIXMAP, IF NOT ALREADY DONE...
1330    if(!m_hasImagedata) m_pixmap = XCreatePixmap(display, window, m_width, m_height, XDefaultDepth(display, 0));
1331
1332    // SET COLOR TO GRAY
1333    setColor(display, gc, 0xCC, 0xCC, 0xCC);
1334
1335    // SOLID-FILL AREA WITH COLOR
1336    XFillRectangle(display, m_pixmap, gc, 0, 0,
1337        (unsigned int) m_width, (unsigned int) m_height) ;
1338
1339    // SET COLOR TO DARKER GRAY
1340    setColor(display, gc, 0xBB, 0xBB, 0xBB);
1341
1342    Pixmap Pattern;
1343    static char Pat[] =
1344        {0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
1345         0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
1346         0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00,
1347         0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00}; // 16x16 PIXMAP
1348
1349    Pattern= XCreateBitmapFromData(display, window, Pat, 16, 16);
1350
1351    XSetStipple(display, gc, Pattern);
1352
1353    XSetFillStyle(display, gc, FillStippled);
1354
1355    // PATTERN-FILL AREA
1356    XFillRectangle(display, m_pixmap, gc, 0, 0,
1357        (unsigned int) m_width, (unsigned int) m_height) ;
1358
1359    // TIFF DATA AVAILABLE
1360    m_hasImagedata= true;
1361
1362    // FREE OUR GC AS WE DONT NEED IT ANYMORE
1363    XFreeGC(display, gc);
1364
1365    return 0;
1366}
1367
1368
1369/****************************************************************************
1370*  IMAGE DIALOG - REDRAW XIMAGE
1371*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1372****************************************************************************/
1373static void staticImageRedrawCallback(Widget, XtPointer clientData, XtPointer)
1374{
1375    // GET POINTER OF THE ORIGINAL CALLER
1376    imageDialog *iD= (imageDialog *)clientData;
1377
1378    // CALL CLASS MEMBER FUNCTION
1379    iD->imageRedrawCallback();
1380}
1381
1382
1383/****************************************************************************
1384*  IMAGE DIALOG - REDRAW XIMAGE - CALLBACK
1385****************************************************************************/
1386void imageDialog::imageRedrawCallback()
1387{
1388    // RETURN, IF NO IMAGE DATA IS AVAILABLE
1389    if(!m_hasImagedata) return;
1390
1391    // SET ENVIRONMENT VARIABLES
1392    Display *display= XtDisplay(m_drawingArea);
1393    Window window= XtWindow(m_drawingArea);
1394    GC gc= XCreateGC(display, window, 0, 0);
1395
1396    // COPY PIXMAP TO DRAWING AREA
1397    XCopyArea(display, m_pixmap, window, gc, 0, 0, m_width, m_height, 0, 0);
1398
1399    // FREE OUR GC AS WE DONT NEED IT ANYMORE
1400    XFreeGC(display, gc);
1401}
1402
1403
1404/****************************************************************************
1405*  IMAGE DIALOG - REDRAW XIMAGE
1406****************************************************************************/
1407void imageDialog::imageRedraw()
1408{
1409    // RETURN, IF NO IMAGE DATA IS AVAILABLE
1410    if(!m_hasImagedata) return;
1411
1412    // SET ENVIRONMENT VARIABLES
1413    Display *display= XtDisplay(m_drawingArea);
1414    Window window= XtWindow(m_drawingArea);
1415    GC gc= XCreateGC(display, window, 0, 0);
1416
1417    // RESIZE DRAWING AREA
1418    XtVaSetValues(m_drawingArea,
1419        XmNwidth, m_width,
1420        XmNheight, m_height,
1421        NULL);
1422
1423    // COPY XIMAGE (TIFF IMAGE) TO LOCAL PIXMAP
1424    if(m_hasTIFFdata) XPutImage(display, m_pixmap, gc, m_ximage, 0, 0, 0, 0, m_width, m_height);
1425    else if(m_hasImagedata) fillBlankImage();
1426
1427    // ARB DATA AVAILABLE !?
1428    if(!m_hasARBdata) setText("[no ARB data available]", 10, 10);
1429    else drawSpots();
1430
1431    // COPY PIXMAP TO DRAWING AREA
1432//     XPutImage(display, window, gc, m_ximage, 0, 0, 0, 0, m_width, m_height);
1433    XCopyArea(display, m_pixmap, window, gc, 0, 0, m_width, m_height, 0, 0);
1434
1435    // UPDATE THE STATUS LABEL WHENEVER THE IMAGE IS REDRAWN
1436    updateStatusLabel();
1437}
1438
1439
1440/****************************************************************************
1441*  IMAGE DIALOG - REDRAW XIMAGE
1442****************************************************************************/
1443void imageDialog::setText(const char *text, int x, int y)
1444{
1445    // NO TEXT, IF POINTER = NULL
1446    if(!text) return;
1447
1448    // SET ENVIRONMENT VARIABLES
1449    Display *display= XtDisplay(m_drawingArea);
1450    Window window= XtWindow(m_drawingArea);
1451    // GC gc= XCreateGC(display, m_pixmap, 0, 0);
1452    GC gc= XCreateGC(display, window, 0, 0);
1453
1454    // SET TEXT COLOR
1455    setColor(display, gc, m_textColor.r, m_textColor.g, m_textColor.b);
1456
1457    // GET FONT LIST
1458    XFontStruct *fontstruct= XLoadQueryFont(display, "-*-courier-*-r-*--10-*");
1459    XmFontList fontlist= XmFontListCreate(fontstruct, const_cast<char*>("charset1"));
1460
1461    // SET FONT (A SMALL DIRTY WORKAROUND)
1462    XSetFont (display, gc, XLoadFont(display, "fixed"));
1463
1464    XmStringDraw(display, m_pixmap, fontlist, CreateDlgString(text),
1465        gc, x, y, m_width, XmALIGNMENT_BEGINNING,
1466        XmSTRING_DIRECTION_L_TO_R, NULL);
1467}
1468
1469
1470/****************************************************************************
1471*  IMAGE DIALOG - REDRAW XIMAGE
1472****************************************************************************/
1473void imageDialog::setColor(Display *display, GC gc, int r, int g, int b)
1474{
1475    XColor xc;
1476
1477    xc.red= r << 8; xc.green= g << 8; xc.blue= b << 8;
1478    xc.flags = DoRed | DoGreen | DoBlue;
1479    XAllocColor(display, DefaultColormap(display, DefaultScreen(display)), &xc);
1480    XSetForeground(display, gc, xc.pixel);
1481}
1482
1483
1484/****************************************************************************
1485*  IMAGE DIALOG - REDRAW XIMAGE
1486****************************************************************************/
1487void imageDialog::drawCrosshair(int x, int y)
1488{
1489    // SET ENVIRONMENT VARIABLES
1490    Display *display= XtDisplay(m_drawingArea);
1491//     Window window= XtWindow(m_drawingArea);
1492    GC gc= XCreateGC(display, m_pixmap, 0, 0);
1493
1494    // RED COLOR
1495    setColor(display, gc, m_crosshairColor.r, m_crosshairColor.g, m_crosshairColor.b);
1496
1497    // DRAW THE LINES FOR A CROSSHAIR
1498    XDrawLine(display, m_pixmap, gc, x-2, y, x+2, y);
1499    XDrawLine(display, m_pixmap, gc, x, y-2, x, y+2);
1500
1501    XFlush(display);
1502}
1503
1504
1505/****************************************************************************
1506*  IMAGE DIALOG - DRAW CIRCLE
1507****************************************************************************/
1508void imageDialog::drawCircle(int x, int y, int d, int r, int g, int b)
1509{
1510    // (X,Y) = POSITION
1511    // D     = DIAMETER
1512    // R,G,B = COLOR VALUE
1513
1514    // SET ENVIRONMENT VARIABLES
1515    Display *display= XtDisplay(m_drawingArea);
1516    GC gc= XCreateGC(display, m_pixmap, 0, 0);
1517
1518    // DRAW THE CIRCLE(S)
1519    setColor(display, gc, r, g, b);
1520    XFillArc(display, m_pixmap, gc, x-(d/2), y-(d/2), d, d, 0, 360*64);
1521
1522    setColor(display, gc, 0, 0, 0);
1523    XDrawArc(display, m_pixmap, gc, x-(d/2), y-(d/2), d, d, 0, 360*64);
1524
1525    XFlush(display);
1526}
1527
1528
1529/****************************************************************************
1530*  IMAGE DIALOG - FETCH COLOR & TEXT SETTINGS
1531****************************************************************************/
1532bool imageDialog::getSettings()
1533{
1534    // FETCH CONFIGS
1535    char *crosshairColor = get_CONFIG(CONFIG_PGT_COLOR_CROSSHAIR);
1536    char *unmarkedColor  = get_CONFIG(CONFIG_PGT_COLOR_UNMARKED);
1537    char *markedColor    = get_CONFIG(CONFIG_PGT_COLOR_MARKED);
1538    char *selectedColor  = get_CONFIG(CONFIG_PGT_COLOR_SELECTED);
1539    char *textColor      = get_CONFIG(CONFIG_PGT_COLOR_TEXT);
1540
1541    if(crosshairColor)
1542    {
1543        if(strlen(crosshairColor) != 7) crosshairColor= strdup(DEFAULT_COLOR_CROSSHAIR);
1544
1545        hex2rgb(&m_crosshairColor.r,
1546                &m_crosshairColor.g,
1547                &m_crosshairColor.b,
1548                crosshairColor);
1549    }
1550
1551
1552    if(unmarkedColor)
1553    {
1554        if(strlen(unmarkedColor) != 7) unmarkedColor= strdup(DEFAULT_COLOR_UNMARKED);
1555
1556        hex2rgb(&m_unmarkedColor.r,
1557                &m_unmarkedColor.g,
1558                &m_unmarkedColor.b,
1559                unmarkedColor);
1560    }
1561
1562    if(markedColor)
1563    {
1564        if(strlen(markedColor) != 7) markedColor= strdup(DEFAULT_COLOR_MARKED);
1565
1566        hex2rgb(&m_markedColor.r,
1567                &m_markedColor.g,
1568                &m_markedColor.b,
1569                markedColor);
1570    }
1571
1572    if(selectedColor)
1573    {
1574        if(strlen(selectedColor) != 7) selectedColor= strdup(DEFAULT_COLOR_SELECTED);
1575
1576        hex2rgb(&m_selectedColor.r,
1577                &m_selectedColor.g,
1578                &m_selectedColor.b,
1579                selectedColor);
1580    }
1581
1582    if(textColor)
1583    {
1584        if(strlen(selectedColor) != 7) textColor= strdup(DEFAULT_COLOR_SELECTED);
1585
1586        hex2rgb(&m_textColor.r,
1587                &m_textColor.g,
1588                &m_textColor.b,
1589                textColor);
1590    }
1591
1592    free(crosshairColor );
1593    free(unmarkedColor  );
1594    free(markedColor    );
1595    free(selectedColor  );
1596    free(textColor      );
1597
1598    return true;
1599}
1600
1601
1602/****************************************************************************
1603*  IMAGE DIALOG - DISPLAY ARB DATA -> DRAW SPOTS
1604****************************************************************************/
1605void imageDialog::drawSpots()
1606{
1607    // SOME VARIABLES
1608    bool show_spot;
1609    int x, y, diameter;
1610
1611    // CHECK IF TIFF- AND ARB-DATA IS AVAILABLE
1612    if(!m_hasImagedata && !m_hasARBdata) return;
1613
1614    // LOCK CHANGES (AVOIDS DISTURBING CALLBACKS)
1615    m_changeInProgress= true;
1616
1617    // CREATE AN ITERATOR
1618    vector<SPOT>::iterator spot_it;
1619
1620    // DO WE HAVE SPOT ENTRIES?
1621    if(m_spotList.size() == 0) return;
1622
1623
1624    // RESET SPOT COUNTER VALUES
1625    m_numSpots         = 0;
1626    m_numMarkedSpots   = 0;
1627    m_numSelectedSpots = 0;
1628    freeset(m_selectedSpotName, NULL);
1629
1630    // ITERATE THROUGH THE SPOTS
1631    for(spot_it= m_spotList.begin(); spot_it != m_spotList.end(); ++spot_it)
1632    {
1633        // INCREASE SPOT COUNTER
1634        m_numSpots++;
1635        if((*spot_it).marked) m_numMarkedSpots++;
1636        if((*spot_it).selected)
1637        {
1638            if(!m_selectedSpotName) m_selectedSpotName= strdup((*spot_it).id);
1639
1640            m_numSelectedSpots++;
1641        }
1642
1643        // FIRST, LET US SHOW THE ACTUAL SPOT
1644        show_spot= true;
1645
1646        // X,Y ARE USED OFTEN, SO EXTRACT THEM
1647        x= (int)(*spot_it).x;
1648        y= (int)(*spot_it).y;
1649        diameter= (int)(*spot_it).diameter;
1650
1651        // SHOW ONLY SPOTS WHO HAVE AN IDENTIFIER?
1652        if(m_textOnlyFlag && (!(*spot_it).id || (*((*spot_it).id) == 0))) show_spot= false;
1653
1654        // SHOW ONLY SPOTS WHICH ARE MARKED?
1655        if(m_markedOnlyFlag && !((*spot_it).marked)) show_spot= false;
1656
1657        // ALWAYS SHOW THE SELECTED SPOT
1658        if((*spot_it).selected) show_spot= true;
1659
1660        // SO, LET US DRAW THE SPOT (OR NOT)...
1661        if(show_spot)
1662        {
1663            // DRAW CIRCLE AT THE DEFINED POSITION
1664            if(m_circleFlag  && (x > 0))
1665            {
1666                // IF SELECTED, DRAW THICKER CIRCLE -> THICK BLACK BORDER
1667                if((*spot_it).selected)
1668                {
1669                    // FAT BLACK CIRCLE (BORDER)
1670                    drawCircle(x, y, diameter+2, 0, 0, 0);
1671
1672                    // INNER COLORED CIRCLE
1673                    drawCircle(x, y, diameter, m_selectedColor.r, m_selectedColor.g, m_selectedColor.b);
1674                }
1675
1676                // IF MARKED, USE DIFFERENT COLOR FOR SPOT
1677                else if((*spot_it).marked)
1678                    drawCircle(x, y, diameter, m_markedColor.r, m_markedColor.g, m_markedColor.b);
1679
1680                // OTHERWISE JUST DRAW AN UNMARKED SPOT
1681                else drawCircle(x, y, diameter, m_unmarkedColor.r, m_unmarkedColor.g, m_unmarkedColor.b);
1682            }
1683
1684            // SET CROSSHAIR AT THE DEFINED POSITION
1685            if(m_crosshairFlag  && (x > 0)) drawCrosshair(x, y);
1686
1687            // ADD INFORMATIONAL TEXT TO THE (MARKED OR SELECTED) SPOT?
1688            if(m_labelFlag  && (x > 0) && ((*spot_it).selected || (*spot_it).marked))
1689                if((*spot_it).text) setText((*spot_it).text, x + (diameter/2) + 2, y);
1690        }
1691    }
1692
1693    // UNLOCK CHANGES (PERMIT CALLBACKS)
1694    m_changeInProgress= false;
1695}
1696
1697
1698/****************************************************************************
1699*  CALLBACK - IMAGE EVENT CALLBACK
1700*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1701****************************************************************************/
1702static void staticImageEventCallback(Widget widget, XtPointer clientData, XtPointer callData)
1703{
1704    // GET POINTER OF THE ORIGINAL CALLER
1705    imageDialog *iD= (imageDialog *)clientData;
1706
1707    // CALL CLASS MEMBER FUNCTION
1708    iD->imageEventCallback(widget, callData);
1709}
1710
1711
1712/****************************************************************************
1713*  CALLBACK - IMAGE EVENT CALLBACK
1714****************************************************************************/
1715void imageDialog::imageEventCallback(Widget, XtPointer callData)
1716{
1717    int x= 0, y= 0, button= 0;
1718
1719    // FETCH CALLBACKSTRUCT + EVENT
1720    XmDrawingAreaCallbackStruct *cbs= (XmDrawingAreaCallbackStruct *)callData;
1721    XEvent *event= (XEvent *)cbs->event;
1722
1723    if(event->xany.type == ButtonPress)
1724    {
1725        // GET COORDINATES
1726        x= event->xbutton.x;
1727        y= event->xbutton.y;
1728
1729        // GET PRESSED BUTTON
1730        button= event->xbutton.button;
1731
1732        // SELECT OR MARK BUTTON NEXT TO POS (X,Y)
1733        markSpotAtPos(button, x, y);
1734
1735        // CREATE A NEW SPOT LIST
1736        createSpotList();
1737
1738       // REDRAW IMAGE
1739        imageRedraw();
1740    }
1741}
1742
1743
1744/****************************************************************************
1745*  SELECT/MARK THE SPOT NEXT TO THE POS. X, Y
1746****************************************************************************/
1747void imageDialog::markSpotAtPos(int button, int x, int y)
1748{
1749    // LOCAL VARIABLES
1750    GBDATA *gb_data= NULL;
1751//     GBDATA *gb_proteome= NULL;
1752    GBDATA *gb_proteine_data= NULL;
1753    GBDATA *gb_protein= NULL;
1754    GBDATA *gb_nearest_protein= NULL;
1755    GBDATA *gb_protein_x= NULL;
1756    GBDATA *gb_protein_y= NULL;
1757    GBDATA *gb_protein_name= NULL;
1758    char *protein_name= NULL;
1759    float protein_x, protein_y;
1760    float delta, nearest_delta= 99999;
1761    float sqx, sqy;
1762    float fx= (float)x;
1763    float fy= (float)y;
1764
1765    // GET MAIN ARB GBDATA
1766    gb_data= get_gbData();
1767    if(!gb_data) return;
1768
1769    // FIND SELECTED PROTEOME/PROTEINE_DATA
1770    gb_proteine_data= find_proteine_data(m_species, m_experiment, m_proteome);
1771    if(!gb_proteine_data) return;
1772
1773    // INIT AN ARB TRANSACTION
1774    ARB_begin_transaction();
1775
1776    // BROWSE ALL PROTEIN ENTRIES...
1777    gb_protein= GB_entry(gb_proteine_data, "protein");
1778    while(gb_protein)
1779    {
1780        // FETCH COORDINATE CONTAINER
1781        gb_protein_x= GB_entry(gb_protein, m_x_container);
1782        gb_protein_y= GB_entry(gb_protein, m_y_container);
1783
1784        if(gb_protein_x && gb_protein_y)
1785        {
1786            // READ COORDINATES FROM THE CONTAINER
1787            protein_x= GB_read_float(gb_protein_x);
1788            protein_y= GB_read_float(gb_protein_y);
1789
1790            // CALCULATE DIAGONAL LENGTH
1791            sqx= (fx - protein_x) * (fx - protein_x);
1792            sqy= (fy - protein_y) * (fy - protein_y);
1793            delta= sqrt(sqx + sqy);
1794
1795            if(delta < nearest_delta)
1796            {
1797                gb_nearest_protein= gb_protein;
1798                nearest_delta= delta;
1799
1800                gb_protein_name= GB_entry(gb_protein, m_id_container);
1801                protein_name= GB_read_string(gb_protein_name);
1802            }
1803        }
1804
1805        // FETCH NEXT PROTEIN FROM LIST
1806        ai_assert(GB_has_key(gb_protein, "protein"));
1807        gb_protein= GB_nextEntry(gb_protein);
1808    }
1809
1810    // IF MOUSE CLICK IS TOO FAR AWAY FROM THE CENTER -> IGNORE
1811    if(nearest_delta > MAX_SELECTION_DISTANCE)
1812    {
1813        // CLOSE THE ARB TRANSACTION
1814        ARB_commit_transaction();
1815
1816        // RETURN WITHOUT SELECTING/MARKING ANYTHING
1817        return;
1818    }
1819
1820    // DO WE HAVE A 'NEAREST' PROTEIN SPOT?
1821    if(gb_nearest_protein)
1822    {
1823        // THE FOLLOWING ACTION DEPENDS ON THE PRESSED BUTTON:
1824        // LEFT  = SELECT SPOT/PROTEIN
1825        // RIGHT = MARK SPOT/PROTEIN
1826        if(button == LEFT_MOUSE_BUTTON)
1827        {
1828            // IF NOT LOCKED WRITE SELECTED PROTEIN NAME INTO THE AWAR
1829            if(protein_name) set_protein_AWAR(protein_name);
1830        }
1831        else if(button == RIGHT_MOUSE_BUTTON)
1832        {
1833            // INVERT MARKER (MARK/UNMARK PROTEIN)
1834            GB_write_flag(gb_nearest_protein, !GB_read_flag(gb_nearest_protein));
1835        }
1836    }
1837
1838    // CLOSE THE ARB TRANSACTION
1839    ARB_commit_transaction();
1840}
1841
1842
1843/****************************************************************************
1844*  ARB AWAR CALLBACK - PROTEIN ENTRY HAS CHANGED
1845*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1846****************************************************************************/
1847static void static_ARB_protein_callback(GBDATA *, imageDialog *iD, GB_CB_TYPE)
1848{
1849     // // GET POINTER OF THE ORIGINAL CALLER
1850    // imageDialog *iD= (imageDialog *)clientData;
1851
1852    // CALL CLASS MEMBER FUNCTION
1853    iD->ARB_protein_callback();
1854}
1855
1856
1857/****************************************************************************
1858*  ARB AWAR CALLBACK - PROTEIN ENTRY HAS CHANGED
1859****************************************************************************/
1860void imageDialog::ARB_protein_callback()
1861{
1862    if(!m_lockVisualization && !m_changeInProgress)
1863    {
1864        createSpotList();
1865        imageRedraw();
1866    }
1867
1868    // IF ENABLED COPY IDENTIFIER TO SELECTED GENE
1869    if(m_updateGene) updateSelectedGene();
1870}
1871
1872
1873/****************************************************************************
1874*  ARB AWAR CALLBACK - GENE ENTRY HAS CHANGED
1875*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1876****************************************************************************/
1877static void static_ARB_gene_callback(GBDATA *, imageDialog *iD, GB_CB_TYPE)
1878{
1879     // // GET POINTER OF THE ORIGINAL CALLER
1880    // imageDialog *iD= (imageDialog *)clientData;
1881
1882    // CALL CLASS MEMBER FUNCTION
1883    iD->ARB_gene_callback();
1884}
1885
1886
1887/****************************************************************************
1888*  ARB AWAR CALLBACK - GENE ENTRY HAS CHANGED
1889****************************************************************************/
1890void imageDialog::ARB_gene_callback()
1891{
1892    char *awar_selected_gene=NULL;
1893    char *config_gene_id=NULL;
1894    char *name= NULL;
1895    char *id= NULL;
1896    GBDATA *gb_genome, *gb_gene, *gb_gene_name, *gb_gene_id;
1897
1898    if(!m_lockVisualization && !m_changeInProgress)
1899    {
1900        // FETCH GENE AWAR CONTENT & CONFIG
1901        awar_selected_gene= get_gene_AWAR();
1902        config_gene_id= get_CONFIG(CONFIG_PGT_ID_GENE);
1903
1904        gb_genome= find_genome(m_species);
1905        if(!gb_genome) return;
1906
1907        // INIT AN ARB TRANSACTION
1908        ARB_begin_transaction();
1909
1910        gb_gene= GB_entry(gb_genome, "gene");
1911
1912        while(gb_gene)
1913        {
1914            gb_gene_name= GB_entry(gb_gene, "name");
1915
1916            if(gb_gene_name)
1917            {
1918                name= GB_read_as_string(gb_gene_name);
1919
1920                if(name && (!strcmp(name, awar_selected_gene)))
1921                {
1922                    gb_gene_id= GB_entry(gb_gene, config_gene_id);
1923
1924                    if(gb_gene_id)
1925                    {
1926                        id= GB_read_as_string(gb_gene_id);
1927                        set_protein_AWAR(id);
1928                        break;
1929                    }
1930                }
1931            }
1932
1933            ai_assert(GB_has_key(gb_gene, "gene"));
1934            gb_gene= GB_nextEntry(gb_gene);
1935        }
1936
1937        // CLOSE THE ARB TRANSACTION
1938        ARB_commit_transaction();
1939
1940        // UPDATE IMAGE
1941        createSpotList();
1942        imageRedraw();
1943
1944        // FREE OBSOLETE STRINGS
1945        if(awar_selected_gene) free(awar_selected_gene);
1946        if(config_gene_id) free(config_gene_id);
1947    }
1948
1949    // IF ENABLED COPY IDENTIFIER TO SELECTED GENE
1950    if(m_updateGene) updateSelectedGene();
1951}
1952
1953
1954/****************************************************************************
1955*  ARB AWAR CALLBACK - PGT CONFIG HAS CHANGED
1956*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1957****************************************************************************/
1958static void static_PGT_config_callback(GBDATA *, imageDialog *iD, GB_CB_TYPE)
1959{
1960     // // GET POINTER OF THE ORIGINAL CALLER
1961    // imageDialog *iD= (imageDialog *)clientData;
1962
1963    // CALL CLASS MEMBER FUNCTION
1964    iD->PGT_config_callback();
1965}
1966
1967
1968/****************************************************************************
1969*  ARB AWAR CALLBACK - PGT CONFIG HAS CHANGED
1970****************************************************************************/
1971void imageDialog::PGT_config_callback()
1972{
1973    // SETTINGS HAVE CHANGED - SO FETCH NEW SETTINGS...
1974    getSettings();
1975
1976    // SPOT LIST MAY HAVE CHANGED ASWELL - CREATE A NEW ONE...
1977    createDescriptions();
1978    createSpotList();
1979
1980    // UPDATE THE IMAGE (COLORS MAY HAVE CHANGED)
1981    imageRedraw();
1982}
1983
1984
1985/****************************************************************************
1986*  REACT TO A CHANGE OF THE SELECTED GENE: YES/NO
1987*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
1988****************************************************************************/
1989static void staticUpdateGeneButtonCallback(Widget, XtPointer clientData, XtPointer)
1990{
1991     // GET POINTER OF THE ORIGINAL CALLER
1992    imageDialog *iD= (imageDialog *)clientData;
1993
1994    // CALL CLASS MEMBER FUNCTION
1995    iD->updateGeneButtonCallback();
1996}
1997
1998
1999/****************************************************************************
2000*  REACT TO A CHANGE OF THE SELECTED GENE: YES/NO
2001****************************************************************************/
2002void imageDialog::updateGeneButtonCallback()
2003{
2004    // INVERT FLAG
2005    m_updateGene= !m_updateGene;
2006
2007    // IF ENABLED COPY IDENTIFIER TO SELECTED GENE
2008    if(m_updateGene) updateSelectedGene();
2009
2010    // REDRAW IMAGE
2011    imageRedraw();
2012}
2013
2014
2015/****************************************************************************
2016*  CREATE GENE IDENTIFIER KEY (FOR QUICK HASH ACCESS)
2017****************************************************************************/
2018void imageDialog::genGeneKey(char *buf, char *spot_id, float x, float y)
2019{
2020    if(buf == NULL) return;
2021
2022    unsigned int i_x= (unsigned int)x;
2023    unsigned int i_y= (unsigned int)y;
2024
2025    if((spot_id != NULL) && (strlen(spot_id) > 0))
2026    {
2027        sprintf(buf, "%s_%d_%d", spot_id, i_x, i_y);
2028    }
2029    else
2030    {
2031        sprintf(buf, "0_%d_%d", i_x, i_y);
2032    }
2033}
2034
2035
2036/****************************************************************************
2037*  CREATE / UPDATE THE COMPLETE SPOT LIST
2038****************************************************************************/
2039bool imageDialog::createSpotList()
2040{
2041    // LOCAL SPOT
2042    SPOT spot;
2043
2044    GBDATA *gb_data, *gb_proteine_data, *gb_protein, *gb_protein_id;
2045    GBDATA *gb_protein_x, *gb_protein_y, *gb_protein_area;
2046
2047    // GET MAIN ARB GBDATA
2048    gb_data= get_gbData();
2049    if(!gb_data) return false;
2050
2051    // CREATE GENE KEY BUFFER
2052    char *keyBuf= (char *)malloc(1024 * sizeof(char));
2053
2054    // FETCH PROTEIN AWAR CONTENT
2055    char *awar_selected_protein= get_protein_AWAR();
2056    char *awar_protein_id=       get_CONFIG(CONFIG_PGT_ID_PROTEIN);
2057    const char *awar_protein_x=        "x_coordinate"; // DEBUG - HARDCODED
2058    const char *awar_protein_y=        "y_coordinate"; // DEBUG - HARDCODED
2059    const char *awar_protein_area=     "area";         // DEBUG - HARDCODED
2060
2061    // FIND SELECTED PROTEOME
2062    gb_proteine_data= find_proteine_data(m_species, m_experiment, m_proteome);
2063    if(!gb_proteine_data)
2064    {
2065        free(keyBuf);
2066        if(awar_selected_protein) free(awar_selected_protein);
2067        if(awar_protein_id) free(awar_protein_id);
2068        return false;
2069    }
2070
2071    // FLUSH THE COMPLETE LIST
2072    vector<SPOT>::iterator spot_it;
2073    for(spot_it= m_spotList.begin(); spot_it != m_spotList.end(); ++spot_it)
2074    {
2075//         if((*spot_it).text) free((*spot_it).text); // DONT! ALSO POINTER TO DESCR.LIST!!!
2076        if((*spot_it).id) free((*spot_it).id);
2077    }
2078    m_spotList.clear();
2079
2080    // INIT AN ARB TRANSACTION
2081    ARB_begin_transaction();
2082
2083    // BROWSE ALL PROTEIN ENTRIES...
2084    gb_protein= GB_entry(gb_proteine_data, "protein");
2085    while(gb_protein)
2086    {
2087        // PREDEFINE SPOT
2088        spot.text=     NULL;
2089        spot.id=       NULL;
2090        spot.area=     0;
2091        spot.diameter= 8;
2092        spot.x=        0;
2093        spot.y=        0;
2094        spot.selected= false;
2095        spot.marked=   false;
2096        spot.gbdata=   gb_protein;
2097
2098        // FETCH NECESSARY ENTRIES
2099        gb_protein_x=    GB_entry(gb_protein, awar_protein_x);
2100        gb_protein_y=    GB_entry(gb_protein, awar_protein_y);
2101        gb_protein_area= GB_entry(gb_protein, awar_protein_area);
2102        gb_protein_id=   GB_entry(gb_protein, awar_protein_id);
2103
2104        // FETCH PROTEIN IDENTIFIER IF AVAILABLE
2105        if(gb_protein_id) spot.id= GB_read_string(gb_protein_id);
2106
2107        // GET THE SELECTION CONDITION OF OUR SPOT
2108        if((strlen(spot.id) > 0) && !strcmp(spot.id, awar_selected_protein)) spot.selected= true;
2109
2110        // GET PROTEIN MARKER CONDITION (MARKED/UNMARKED)
2111        spot.marked= (bool)GB_read_flag(gb_protein);
2112
2113        // UPDATE OTHER VALUES (AS FAR AS AVAILABLE)
2114        if(gb_protein_x) spot.x= GB_read_float(gb_protein_x);
2115        if(gb_protein_y) spot.y= GB_read_float(gb_protein_y);
2116        if(gb_protein_area)
2117        {
2118            spot.area=     GB_read_int(gb_protein_area);
2119            spot.diameter= (int)sqrt((4 * spot.area)/(4 * 3.141592));
2120        }
2121
2122//         if(spot.id && (strlen(spot.id) > 0))
2123//         {
2124            // CREATE KEY BUFFER
2125            genGeneKey(keyBuf, spot.id, spot.x, spot.y);
2126
2127            // FETCH DESCRIPTOR FROM DESCRIPTOR LIST (HASH-ARRAY)
2128            char *descr= m_descriptorList[keyBuf];
2129
2130            if(descr) spot.text= descr;
2131//         }
2132
2133        // ADD SPOT TO LIST
2134        m_spotList.push_back(spot);
2135
2136        // FETCH NEXT PROTEIN FROM LIST
2137        ai_assert(GB_has_key(gb_protein, "protein"));
2138        gb_protein= GB_nextEntry(gb_protein);
2139    }
2140
2141    // CLOSE THE ARB TRANSACTION
2142    ARB_commit_transaction();
2143
2144    // FREE KEY BUFFER
2145    free(keyBuf);
2146    if(awar_selected_protein) free(awar_selected_protein);
2147    if(awar_protein_id) free(awar_protein_id);
2148
2149    return true;
2150}
2151
2152
2153/****************************************************************************
2154*  CREATE A LIST WITH PROTEIN/SPOT DESCRIPTIONS
2155****************************************************************************/
2156bool imageDialog::createDescriptions()
2157{
2158    char *token= NULL, *entry= NULL, *id= NULL;
2159    GBDATA *gb_proteine_data, *gb_protein, *gb_genome, *gb_gene;
2160    GBDATA *gb_protein_id, *gb_entry, *gb_gene_id, *gb_protein_x, *gb_protein_y;
2161    bool first_token;
2162    char *content;
2163    float x= 0, y= 0;
2164
2165    // FIND SELECTED PROTEOME AND GENOME
2166    gb_proteine_data= find_proteine_data(m_species, m_experiment, m_proteome);
2167    if(!gb_proteine_data) return false;
2168    gb_genome= find_genome(m_species);
2169    if(!gb_genome) return false;
2170
2171    // FETCH NECESSARY AWARS
2172    char *awar_protein_infos= get_CONFIG(CONFIG_PGT_INFO_PROTEIN);
2173    char *awar_gene_infos=    get_CONFIG(CONFIG_PGT_INFO_GENE);
2174    char *awar_protein_id=    get_CONFIG(CONFIG_PGT_ID_PROTEIN);
2175    char *awar_gene_id=       get_CONFIG(CONFIG_PGT_ID_GENE);
2176    char *awar_protein_x=     const_cast<char*>("x_coordinate"); // DEBUG - HARDCODED
2177    char *awar_protein_y=     const_cast<char*>("y_coordinate"); // DEBUG - HARDCODED
2178    if(!awar_protein_infos || !awar_gene_infos ||
2179       !awar_protein_id || !awar_gene_id) return false;
2180
2181    // CREATE BUFFERS
2182    char *descriptor= (char *)malloc(1024 * sizeof(char));
2183    char *buf= (char *)malloc(1024 * sizeof(char));
2184    if(!descriptor || !buf) return false;
2185
2186//     // FREE OLD DESCRIPTOR LIST
2187    map<char*, char*, ltstr>::iterator descr_it;
2188
2189    for(descr_it= m_descriptorList.begin();
2190        descr_it != m_descriptorList.end(); descr_it++)
2191    {
2192        free(((*descr_it).first));
2193        free(((*descr_it).second));
2194    }
2195    m_descriptorList.clear();
2196
2197    // INIT AN ARB TRANSACTION
2198    ARB_begin_transaction();
2199
2200    // FREE m_gene_GBDATA_map
2201    map<char *, GBDATA*, ltstr>::iterator gb_it;
2202
2203    for(gb_it= m_gene_GBDATA_map.begin();
2204        gb_it != m_gene_GBDATA_map.end(); gb_it++)
2205    {
2206        free(((*gb_it).first));
2207    }
2208    m_gene_GBDATA_map.clear();
2209
2210    // CREATE GENE IDENTIFIER AND GBDATA* HASH (AVOIDS RECURSIONS)
2211    gb_gene= GB_entry(gb_genome, "gene");
2212    while(gb_gene)
2213    {
2214        gb_gene_id= GB_entry(gb_gene, awar_gene_id);
2215
2216        if(gb_gene_id)
2217        {
2218            content= GB_read_as_string(gb_gene_id);
2219
2220            if(content && (strlen(content) > 0)) m_gene_GBDATA_map[content] = gb_gene;
2221        }
2222
2223        ai_assert(GB_has_key(gb_gene, "gene"));
2224        gb_gene= GB_nextEntry(gb_gene);
2225    }
2226
2227    // BROWSE ALL PROTEIN ENTRIES...
2228    gb_protein= GB_entry(gb_proteine_data, "protein");
2229    while(gb_protein)
2230    {
2231        // CLEAN BUFFER
2232        *descriptor= 0;
2233        id= NULL;
2234        x= 0;
2235        y= 0;
2236        first_token= true;
2237
2238        // FETCH PROTEIN IDENTIFIER
2239        gb_protein_id= GB_entry(gb_protein, awar_protein_id);
2240        gb_protein_x= GB_entry(gb_protein, awar_protein_x);
2241        gb_protein_y= GB_entry(gb_protein, awar_protein_y);
2242
2243        // GET IDENTIFIER FIELD CONTENT
2244        if(gb_protein_id) id= GB_read_string(gb_protein_id);
2245        if(gb_protein_x) x= GB_read_float(gb_protein_x);
2246        if(gb_protein_y) y= GB_read_float(gb_protein_y);
2247
2248//         // IF WE HAVE AN IDENTIFIER...
2249//         if((id && (strlen(id) > 0)) || ((x + y) != 0))
2250//         {
2251            strncpy(buf, awar_protein_infos, 1023);
2252            token= strtok(buf, ",; ");
2253            while(token)
2254            {
2255                gb_entry= GB_entry(gb_protein, token);
2256
2257                // DO WE HAVE THE SELECTED CONTAINER?
2258                if(gb_entry)
2259                {
2260                    // FETCH WHATEVER IS IN THERE
2261                    entry= GB_read_as_string(gb_entry);
2262
2263                    // APPEND THIS TO OUR STRING
2264                    if(entry && (strlen(entry) > 0))
2265                    {
2266                        // DO WE NEED A SEPARATOR?
2267                        if(first_token) first_token= false;
2268                        else strncat(descriptor, ";", 2);
2269
2270                        // APPEND ENTRY TO DESCRIPTOR
2271                        strncat(descriptor, entry, 1023 - strlen(descriptor));
2272                    }
2273
2274                    // FREE OBSOLETE STRING MEM
2275                    if(entry) free(entry);
2276                }
2277                // FETCH NEXT TOKEN
2278                token= strtok(NULL, ",; ");
2279            }
2280
2281            // FETCH GENE
2282            if(id && (strlen(id) > 0))
2283                gb_gene= m_gene_GBDATA_map[id];
2284            else
2285                gb_gene= NULL;
2286
2287            if(gb_gene)
2288            {
2289                strncpy(buf, awar_gene_infos, 1023);
2290                token= strtok(buf, ",; ");
2291                while(token)
2292                {
2293                    gb_entry= GB_entry(gb_gene, token);
2294
2295                    // DO WE HAVE THE SELECTED CONTAINER?
2296                    if(gb_entry)
2297                    {
2298                        // FETCH WHATEVER IS IN THERE
2299                        entry= GB_read_as_string(gb_entry);
2300
2301                        // APPEND THIS TO OUR STRING
2302                        if(entry && (strlen(entry) > 0))
2303                        {
2304                            // DO WE NEED A SEPARATOR?
2305                            if(first_token) first_token= false;
2306                            else strncat(descriptor, ";", 2);
2307
2308                            // APPEND ENTRY TO DESCRIPTOR
2309                            strncat(descriptor, entry, 1023 - strlen(descriptor));
2310                        }
2311
2312                        // WE DO NOT NEED THE ENTRY ANYMORE...
2313                        free(entry);
2314                    }
2315                    // FETCH NEXT TOKEN
2316                    token= strtok(NULL, ",; ");
2317                }
2318            }
2319//         }
2320
2321        // CREATE KEY BUFFER
2322        genGeneKey(buf, id, x, y);
2323
2324        // APPEND ENTRY TO LIST
2325        char *d_append= strdup(descriptor);
2326        char *d_id= strdup(buf);
2327
2328//         // SUBOPTIMAL !?!? -- DEBUG -- WURDE VORHER BEREITS GELOESCHT!
2329//         descr_it= m_descriptorList.find(d_id);
2330//         if(descr_it != m_descriptorList.end())
2331//         {
2332//             free(((*descr_it).first));
2333//             free(((*descr_it).second));
2334//             m_descriptorList.erase(descr_it);
2335//         }
2336
2337        m_descriptorList[d_id] = d_append;
2338
2339        // FREE OBSOLETE STRINGS
2340        // free(d_id);
2341        // free(id);
2342
2343        // FETCH NEXT PROTEIN FROM LIST
2344        ai_assert(GB_has_key(gb_protein, "protein"));
2345        gb_protein= GB_nextEntry(gb_protein);
2346    }
2347
2348    // CLOSE THE ARB TRANSACTION
2349    ARB_commit_transaction();
2350
2351    free(descriptor);
2352    free(buf);
2353
2354    return true;
2355}
2356
2357
2358/****************************************************************************
2359*  UPDATE THE SELECTED GENE AWAR (IF ENABLED)
2360****************************************************************************/
2361bool imageDialog::updateSelectedGene()
2362{
2363    char *awar_selected_protein, *awar_gene_id, *name= NULL;
2364    GBDATA *gb_genome, *gb_gene, *gb_name;
2365
2366    // FETCH GENOME
2367    gb_genome= find_genome(m_species);
2368    if(!gb_genome) return false;
2369
2370    // FETCH PROTEIN AWAR CONTENT
2371    awar_selected_protein= get_protein_AWAR();
2372
2373    // FETCH GENE IDENTIFIER
2374    awar_gene_id= get_CONFIG(CONFIG_PGT_ID_GENE);
2375
2376    // FETCH GENE
2377    gb_gene= m_gene_GBDATA_map[awar_selected_protein];
2378
2379    if(gb_gene)
2380    {
2381        ARB_begin_transaction();
2382
2383        gb_name= GB_entry(gb_gene, "name");
2384        name= GB_read_string(gb_name);
2385
2386        ARB_commit_transaction();
2387    }
2388
2389
2390    if(name)
2391    {
2392        set_gene_AWAR(name);
2393        return true;
2394    }
2395
2396    return false;
2397}
2398
2399
2400/****************************************************************************
2401*  TRANSFER MARKS:  SPOT-MARKER -> GENE-MARKER
2402****************************************************************************/
2403bool imageDialog::mark_Spots2Genes()
2404{
2405    vector<SPOT>::iterator spot_it;
2406    GBDATA *gb_genome, *gb_gene, *gb_gene_id;
2407    char *content;
2408
2409    gb_genome= find_genome(m_species);
2410    if(!gb_genome) return false;
2411
2412    // INIT AN ARB TRANSACTION
2413    ARB_begin_transaction();
2414
2415    // TRAVERSE GENES
2416    gb_gene= GB_entry(gb_genome, "gene");
2417    while(gb_gene)
2418    {
2419        gb_gene_id= GB_entry(gb_gene, "locus_tag");
2420
2421        if(gb_gene_id)
2422        {
2423            content= GB_read_as_string(gb_gene_id);
2424
2425            // TRAVERSE THE COMPLETE LIST
2426            for(spot_it= m_spotList.begin(); spot_it != m_spotList.end(); ++spot_it)
2427            {
2428                if(!strcmp((*spot_it).id, content))
2429                {
2430                    if((*spot_it).marked)
2431                        GB_write_flag(gb_gene, 1);
2432                    else
2433                        GB_write_flag(gb_gene, 0);
2434                }
2435            }
2436        }
2437
2438        ai_assert(GB_has_key(gb_gene, "gene"));
2439        gb_gene= GB_nextEntry(gb_gene);
2440    }
2441
2442    // CLOSE THE ARB TRANSACTION
2443    ARB_commit_transaction();
2444
2445    return true;
2446}
2447
2448
2449/****************************************************************************
2450*  TRANSFER MARKS:  GENE-MARKER -> SPOT-MARKER
2451****************************************************************************/
2452bool imageDialog::mark_Genes2Spots()
2453{
2454    vector<SPOT>::iterator spot_it;
2455    GBDATA *gb_genome, *gb_gene, *gb_gene_id;
2456    char *content;
2457    int flag;
2458
2459    gb_genome= find_genome(m_species);
2460    if(!gb_genome) return false;
2461
2462    // REMOVE ALL MARKER
2463    setAllMarker(PROTEIN_UNMARK);
2464
2465    // INIT AN ARB TRANSACTION
2466    ARB_begin_transaction();
2467
2468    // TRAVERSE GENES
2469    gb_gene= GB_entry(gb_genome, "gene");
2470    while(gb_gene)
2471    {
2472        // GET ACTUAL STATE
2473        flag= GB_read_flag(gb_gene);
2474
2475        // FETCH GENE ID
2476        gb_gene_id= GB_entry(gb_gene, "locus_tag");
2477
2478        if(gb_gene_id)
2479        {
2480            // FETCH THE GENE-ID AS STRING
2481            content= GB_read_as_string(gb_gene_id);
2482
2483            // TRAVERSE THE COMPLETE LIST
2484            for(spot_it= m_spotList.begin(); spot_it != m_spotList.end(); ++spot_it)
2485            {
2486                if(!strcmp((*spot_it).id, content))
2487                    GB_write_flag((*spot_it).gbdata, flag);
2488            }
2489        }
2490
2491        // FIND NEXT GENE
2492        ai_assert(GB_has_key(gb_gene, "gene"));
2493        gb_gene= GB_nextEntry(gb_gene);
2494    }
2495
2496    // CLOSE THE ARB TRANSACTION
2497    ARB_commit_transaction();
2498
2499    // CREATE A NEW SPOT LIST
2500    createSpotList();
2501
2502    // REDRAW IMAGE
2503    imageRedraw();
2504
2505    return true;
2506}
2507
2508
2509/****************************************************************************
2510*  COPY SPOT MARKS TO THE ARB GENE MAP
2511*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
2512****************************************************************************/
2513static void staticSpots2GenesButtonCallback(Widget, XtPointer clientData, XtPointer)
2514{
2515     // GET POINTER OF THE ORIGINAL CALLER
2516    imageDialog *iD= (imageDialog *)clientData;
2517
2518    // CALL CLASS MEMBER FUNCTION
2519    iD->mark_Spots2Genes();
2520}
2521
2522
2523/****************************************************************************
2524*  COPY GENE MARKER TO SPOT VIEW
2525*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
2526****************************************************************************/
2527static void staticGenes2SpotsButtonCallback(Widget, XtPointer clientData, XtPointer)
2528{
2529     // GET POINTER OF THE ORIGINAL CALLER
2530    imageDialog *iD= (imageDialog *)clientData;
2531
2532    // CALL CLASS MEMBER FUNCTION
2533    iD->mark_Genes2Spots();
2534}
2535
2536
2537/****************************************************************************
2538*  SHOW HELP DIALOG
2539*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
2540****************************************************************************/
2541static void staticHelpDialogCallback(Widget, XtPointer clientData, XtPointer)
2542{
2543    new helpDialog((imageDialog*)clientData);
2544}
2545
2546
2547/****************************************************************************
2548*  UPDATE THE STATUS BAR TEXT
2549****************************************************************************/
2550void imageDialog::updateStatusLabel()
2551{
2552    // CREATE BUFFER
2553    char *buf= (char *)malloc(1024 * sizeof(char));
2554    if(!buf) return;
2555
2556    char *selected= const_cast<char*>("none");
2557
2558    // FILL BUFFER STRING
2559    if(m_numSpots == 0)
2560    {
2561        sprintf(buf, "No spot data available");
2562    }
2563    else
2564    {
2565        if(m_selectedSpotName && (strlen(m_selectedSpotName) > 0)) selected= m_selectedSpotName;
2566        sprintf(buf, "Spots (total/marked/selected): %d / %d / %d  --  Selected Protein: %s  --  ",
2567            m_numSpots, m_numMarkedSpots, m_numSelectedSpots, selected);
2568    }
2569
2570    // APPEND FLAGS...
2571    if(m_crosshairFlag) strcat(buf, " [CROSS-HAIR]");
2572    if(m_circleFlag) strcat(buf, " [CIRCLE]");
2573    if(m_labelFlag) strcat(buf, " [INFO]");
2574    if(m_linkedOnlyFlag) strcat(buf, " [LINKED ONLY]");
2575    if(m_textOnlyFlag) strcat(buf, " [ID ONLY]");
2576    if(m_markedOnlyFlag) strcat(buf, " [MARKED ONLY]");
2577
2578    // WRITE STRING TO STATUS LABEL
2579    XtVaSetValues(m_statusLabel, XmNlabelString, CreateDlgString(buf), NULL);
2580
2581    // FREE BUFFER
2582    free(buf);
2583}
2584
2585
2586/****************************************************************************
2587*  MARK ONLY SPOTS WITH INFO
2588*  !!! CAUTION: THIS IS A WRAPPER FUNCTION !!!
2589****************************************************************************/
2590static void staticMarkWithInfoButtonCallback(Widget, XtPointer clientData, XtPointer)
2591{
2592     // GET POINTER OF THE ORIGINAL CALLER
2593    imageDialog *iD= (imageDialog *)clientData;
2594
2595    // CALL CLASS MEMBER FUNCTION
2596    iD->markWithInfo();
2597}
2598
2599
2600/****************************************************************************
2601*  MARK ONLY SPOTS WITH INFO
2602****************************************************************************/
2603void imageDialog::markWithInfo()
2604{
2605    // LOCAL VARIABLES
2606    GBDATA *gb_data, *gb_proteine_data, *gb_protein, *gb_protein_id;
2607    char *id= NULL;
2608
2609    // GET MAIN ARB GBDATA
2610    gb_data= get_gbData();
2611    if(!gb_data) return;
2612
2613    // FIND SELECTED PROTEOME
2614    gb_proteine_data= find_proteine_data(m_species, m_experiment, m_proteome);
2615    if(!gb_proteine_data) return;
2616
2617    // FETCH PROTEIN ID AWAR
2618    char *awar_protein_id= get_CONFIG(CONFIG_PGT_ID_PROTEIN);
2619
2620    // INIT AN ARB TRANSACTION
2621    ARB_begin_transaction();
2622
2623    // BROWSE ALL PROTEIN ENTRIES...
2624    gb_protein= GB_entry(gb_proteine_data, "protein");
2625    while(gb_protein)
2626    {
2627        gb_protein_id=  GB_entry(gb_protein, awar_protein_id);
2628
2629        // FETCH PROTEIN IDENTIFIER IF AVAILABLE
2630        if(gb_protein_id) id= GB_read_string(gb_protein_id);
2631
2632        // MARK, IF WE HAVE AN IDENTIFIER
2633        if(strlen(id) > 0) GB_write_flag(gb_protein, 1);
2634        else GB_write_flag(gb_protein, 0);
2635
2636        // FETCH NEXT PROTEIN FROM LIST
2637        ai_assert(GB_has_key(gb_protein, "protein"));
2638        gb_protein= GB_nextEntry(gb_protein);
2639    }
2640
2641    // CLOSE THE ARB TRANSACTION
2642    ARB_commit_transaction();
2643
2644    // CREATE A NEW SPOT LIST
2645    createSpotList();
2646
2647    // REDRAW IMAGE
2648    imageRedraw();
2649}
Note: See TracBrowser for help on using the repository browser.