faraon/x11_ui.fl

   1 # data file for the Fltk User Interface Designer (fluid)
   2 version 1,0108
   3 i18n_type 1
   4 i18n_include <libintl.h>
   5 i18n_function gettext
   6 header_name {.H}
   7 code_name {.C}
   8 decl {\#include <faraon.H>} {global
   9 }
  10
  11 decl {\#include <FL/fl_ask.H>} {global
  12 }
  13
  14 decl {\#include <FL/Fl_Preferences.H>} {global
  15 }
  16
  17 decl {\#include <Flek/Fl_Toggle_Tree.H>} {global
  18 }
  19
  20 decl {\#include <scroll.H>} {public global
  21 }
  22
  23 decl {\#include "slice.xpm"} {}
  24
  25 decl {\#include "note.xpm"} {}
  26
  27 decl {Fl_Pixmap slice_pixmap(slice_xpm_data);} {}
  28
  29 decl {Fl_Pixmap note_pixmap(note_xpm_data);} {}
  30
  31 decl {Fl_Toggle_Tree *config_tree;} {global
  32 }
  33
  34 decl {Fl_Toggle_Tree *slices_tree;} {global
  35 }
  36
  37 decl {Fl_Toggle_Tree *select_slice_tree;} {global
  38 }
  39
  40 decl {Fl_Toggle_Tree *notes_tree;} {global
  41 }
  42
  43 decl {Fl_Toggle_Tree *fill_tree;} {}
  44
  45 decl {sfinx_slice_t *fill_tree_except;} {global
  46 }
  47
  48 decl {u32_t fill_tree_mask;} {global
  49 }
  50
  51 decl {sfinx_file_t current_files_module_tree_path(SFINX_FILES_MODULE_UNSORTED_TREE_REQUEST);} {}
  52
  53 Function {fill_objects_tree(Fl_Toggle_Tree *ft, u32_t m, sfinx_slice_t *except, bool force)} {open private return_type void
  54 } {
  55   code {fill_tree = ft;
  56 fill_tree_mask = m;
  57 fill_tree_except = except;
  58 app->refresh_slices(force);} {}
  59 }
  60
  61 Function {relink_slice_action(sfinx_slice_t *selected)} {private return_type void
  62 } {
  63   code {sfinx_slice_t slice(SFINX_SLICE_RELINK);
  64 // slice to be relinked
  65 Fl_Toggle_Node *node = slices_tree->selected();
  66 if (!node)
  67         return;
  68 sfinx_slice_t *rslice = (sfinx_slice_t *)node->user_data();
  69 slice.id = rslice->id;
  70 // new parent id
  71 slice.parent_id = selected->id;
  72 debug("moving from %lld to %lld", rslice->parent_id, selected->id);
  73 app->sfinx.send(slice);
  74 select_slice_w->hide();
  75 fill_objects_tree(slices_tree, SFINX_SLICE_OBJECT, 0, 1); // force refresh} {}
  76 }
  77
  78 Function {select_note_atag_action()} {open private return_type void
  79 } {
  80   code {sfinx_object_t *obj;
  81 Fl_Toggle_Node *node = slices_tree->selected();
  82 if (!node)
  83         return;
  84 if (node->can_open()) // slice
  85         obj = ((sfinx_slice_t *)node->user_data())->object();
  86 else // object
  87         obj = (sfinx_object_t *)node->user_data();
  88 Fl_Toggle_Node *snode = notes_tree->selected();
  89 sfinx_object_t *sobj = (sfinx_object_t *)snode->user_data();
  90 if (sobj == obj) // try to self tag
  91         return;
  92 if (!obj->cmp((sfinx_object_t *)note_mtag_b->user_data())) // already set as main tag
  93         return;
  94 for (int i = 1; i <= note_tags_br->size(); i++) {
  95         if (!obj->cmp((sfinx_object_t *)note_tags_br->data(i))) // already set as additional tag
  96                 return;
  97 }
  98 string s = obj->name + " [ " + obj->description + " ]";
  99 note_tags_br->add(s.c_str(), obj);
 100 note_tags_br->redraw();} {}
 101 }
 102
 103 Function {select_note_mtag_action()} {open private return_type void
 104 } {
 105   code {sfinx_object_t *obj;
 106 Fl_Toggle_Node *node = slices_tree->selected();
 107 if (!node)
 108         return;
 109 if (node->can_open()) // slice
 110         obj = ((sfinx_slice_t *)node->user_data())->object();
 111 else // object
 112         obj = (sfinx_object_t *)node->user_data();
 113 Fl_Toggle_Node *snode = notes_tree->selected();
 114 sfinx_object_t *sobj = (sfinx_object_t *)snode->user_data();
 115 if (sobj == obj) // try to self tag
 116         return;
 117 note_mtag_b->user_data(obj);
 118 note_mtag_b->copy_label((obj->name + " [ " + obj->description + " ]").c_str());
 119 note_mtag_b->redraw();
 120 // check for additional slices if it is here - remove it
 121 for (int i = 1; i <= note_tags_br->size(); i++) {
 122         if (!obj->cmp((sfinx_object_t *)note_tags_br->data(i))) {
 123                 note_tags_br->remove(i);
 124                 return;
 125         }
 126 }} {}
 127 }
 128
 129 Function {select_file_main_slice_action()} {private return_type void
 130 } {
 131   code {//file_main_slice_b->user_data(to_voidp(current_slice_id));
 132 static string l;
 133 sfinx_slice_t *slice = (sfinx_slice_t *)slices_tree->selected()->user_data();
 134 l = slice->name();
 135 file_main_slice_b->label(l.c_str());
 136 file_main_slice_b->redraw();
 137 // check for additional slices if it is here - remove it
 138 for (int i = 1; i <= file_additional_slices_br->size(); i++) {
 139 //      if (file_additional_slices_br->data(i) == to_voidp(current_slice_id)) {
 140 //              file_additional_slices_br->remove(i);
 141 //              return;
 142 //      }
 143 }} {}
 144 }
 145
 146 Function {select_file_additional_slice_action()} {private return_type void
 147 } {
 148   code {//if (to_voidp(current_slice_id) == file_main_slice_b->user_data()) // already set as main slice
 149         //return;
 150 //for (int i = 1; i <= file_additional_slices_br->size(); i++) {
 151 //      if (file_additional_slices_br->data(i) == to_voidp(current_slice_id))
 152 //              return;
 153 //}
 154 //sfinx_slice_t *slice = (sfinx_slice_t *)slices_tree->selected()->user_data();
 155 //file_additional_slices_br->add(slice->name(), to_voidp(current_slice_id));
 156 file_additional_slices_br->redraw();} {}
 157 }
 158
 159 Function {search_add_slice_action()} {private return_type void
 160 } {
 161   code {for (int i = 1; i <= search_slices_br->size(); i++) {
 162 //      if (search_slices_br->data(i) == to_voidp(current_slice_id))
 163 //              return;
 164 }
 165 //sfinx_slice_t *slice = (sfinx_slice_t *)slices_tree->selected()->user_data();
 166 //search_slices_br->add(slice->name(), to_voidp(current_slice_id));
 167 search_slices_br->redraw();} {}
 168 }
 169
 170 Function {slices_tree_cb(Fl_Widget *, void *)} {open private return_type void
 171 } {
 172   code {Fl_Toggle_Node *node = slices_tree->selected();
 173 if (!node)
 174         return;
 175 if (!Fl::event_clicks())
 176         return;
 177 void (*select_slice_action)(void) = (void (*)())(slices_w->user_data());
 178 if (select_slice_action) {
 179         slices_w->hide();
 180         slices_w->user_data(0);
 181         select_slice_action();
 182 }} {}
 183 }
 184
 185 Function {notes_tree_cb(Fl_Widget *, void *)} {private return_type void
 186 } {
 187   code {Fl_Toggle_Node *node = notes_tree->selected();
 188 if (!node)
 189         return;
 190 //current_note_id = from_voidp(node->user_data());
 191 //current_slice_name = node->label();
 192 if (!Fl::event_clicks())
 193         return;
 194 void (*select_note_action)(void) = (void (*)())(notes_w->user_data());
 195 if (select_note_action) {
 196         notes_w->user_data(0);
 197         select_note_action();
 198 }} {}
 199 }
 200
 201 Function {select_slice_tree_cb(Fl_Widget *, void *)} {private return_type void
 202 } {
 203   code {if (!Fl::event_clicks())
 204         return;
 205 select_slice_b->do_callback();} {}
 206 }
 207
 208 Function {write_preferences()} {private return_type void
 209 } {
 210   code {app->server_name = config_sfinx_server_name_i->value();
 211 app->files_module_conf.clear();
 212 app->files_module_conf.add(FILES_MODULE_UNSORTED_PATH,
 213         config_files_module_unsorted_path_i->value());
 214 app->files_module_conf.add(FILES_MODULE_SORTED_TREE_PATH,
 215         config_files_module_sorted_path_i->value());
 216 app->files_module_conf.add(FILES_MODULE_DESC_FILE_NAME,
 217         config_files_module_desc_file_name_i->value());
 218 app->files_module_conf.add(FILES_MODULE_DESC_FILE_ENABLE,
 219         gen_desc_files_b->value());
 220 app->write_preferences();} {}
 221 }
 222
 223 Function {config_tree_cb(Fl_Widget *, void *)} {private return_type void
 224 } {
 225   code {static Fl_Group *prev_group;
 226 Fl_Toggle_Node *node = config_tree->selected();
 227 if (node) {
 228         Fl_Group *gr = *((Fl_Group **)(node->user_data()));
 229         if (prev_group)
 230                 prev_group->hide();
 231         prev_group = gr;
 232          gr->show();
 233 //config_tree->unselect();
 234  }} {}
 235 }
 236
 237 Function {fill_config_tree()} {private return_type void
 238 } {
 239   code {config_tree->add_next("Connection", 0, 0, (void *)&config_connection_gr);
 240 config_tree->add_next("Files Module", 0, 0, (void *)&config_files_module_gr);
 241 config_tree->add_next("Confirmation", 0, 0, (void *)&config_confirmation_gr);
 242 config_tree->callback(config_tree_cb);
 243 config_tree->edit_on_reselect(0);} {}
 244 }
 245
 246 Function {x11_ui::init()} {open return_type void
 247 } {
 248   Fl_Window main_w {
 249     label Faraon
 250     callback {if (fl_choice("Really quit ?", "No", "Yes", 0L))
 251         F::shutdown(0);}
 252     xywh {171 126 945 365} type Double hide
 253   } {
 254     Fl_Menu_Bar {} {open
 255       xywh {0 0 945 22}
 256     } {
 257       Submenu {} {
 258         label Connection
 259         xywh {0 0 67 22} labeltype ENGRAVED_LABEL
 260       } {
 261         MenuItem {} {
 262           label {Connect to ...}
 263           xywh {0 0 34 22} shortcut 0x80063 labeltype ENGRAVED_LABEL deactivate
 264         }
 265         MenuItem {} {
 266           label {Connect to default server}
 267           xywh {10 10 34 22} labeltype ENGRAVED_LABEL deactivate
 268         }
 269         MenuItem {} {
 270           label {Disconnect from Sfinx}
 271           xywh {10 10 34 22} labeltype ENGRAVED_LABEL deactivate
 272         }
 273         MenuItem {} {
 274           label {Connection Info}
 275           xywh {20 20 34 22} shortcut 0x80069 labeltype ENGRAVED_LABEL deactivate
 276         }
 277         MenuItem {} {
 278           label {Sfinx Stat}
 279           xywh {30 30 34 22} labeltype ENGRAVED_LABEL deactivate divider
 280         }
 281         MenuItem {} {
 282           label Preferences
 283           callback {app->read_preferences();
 284 config_sfinx_server_name_i->value(app->server_name.c_str());
 285 preferences_w->show();}
 286           xywh {30 30 34 22} shortcut 0x80070 labeltype ENGRAVED_LABEL divider
 287         }
 288         MenuItem {} {
 289           label Exit
 290           callback {if (fl_choice("Really quit ?", "No", "Yes", 0L))
 291         F::shutdown(0);}
 292           xywh {20 20 34 22} shortcut 0x80078 labeltype ENGRAVED_LABEL
 293         }
 294       }
 295       Submenu {} {
 296         label Modules open
 297         xywh {10 10 67 22} labeltype ENGRAVED_LABEL
 298       } {
 299         MenuItem {} {
 300           label {AI Module}
 301           callback {if (!app->connected()) {
 302  fl_message("Not connected to Sfinx Server !");
 303  return;
 304 }}
 305           xywh {10 10 34 22} shortcut 0x61 labeltype ENGRAVED_LABEL deactivate
 306         }
 307         MenuItem {} {
 308           label Slices
 309           callback {if (!app->connected()) {
 310  fl_message("Not connected to Sfinx Server !");
 311  return;
 312 }
 313 fill_objects_tree(slices_tree, 1 << SFINX_SLICE_OBJECT, 0, 0); // fluid bugs if any default params exists !
 314 slices_w->show();}
 315           xywh {10 10 34 22} shortcut 0x73 labeltype ENGRAVED_LABEL
 316         }
 317         MenuItem {} {
 318           label {Knowledge Module}
 319           callback {if (!app->connected()) {
 320  fl_message("Not connected to Sfinx Server !");
 321  return;
 322 }}
 323           xywh {40 40 34 22} shortcut 0x6b labeltype ENGRAVED_LABEL deactivate
 324         }
 325         MenuItem {} {
 326           label Tasks
 327           callback {if (!app->connected()) {
 328  fl_message("Not connected to Sfinx Server !");
 329  return;
 330 }}
 331           xywh {40 40 34 22} shortcut 0x74 labeltype ENGRAVED_LABEL deactivate
 332         }
 333         MenuItem {} {
 334           label Messages
 335           callback {if (!app->connected()) {
 336  fl_message("Not connected to Sfinx Server !");
 337  return;
 338 }}
 339           xywh {40 40 34 22} shortcut 0x6d labeltype ENGRAVED_LABEL deactivate
 340         }
 341         MenuItem {} {
 342           label Contacts
 343           callback {if (!app->connected()) {
 344  fl_message("Not connected to Sfinx Server !");
 345  return;
 346 }}
 347           xywh {50 50 34 22} shortcut 0x63 labeltype ENGRAVED_LABEL deactivate
 348         }
 349         MenuItem {} {
 350           label Events
 351           callback {if (!app->connected()) {
 352  fl_message("Not connected to Sfinx Server !");
 353  return;
 354 }}
 355           xywh {40 40 34 22} shortcut 0x65 labeltype ENGRAVED_LABEL deactivate
 356         }
 357         MenuItem {} {
 358           label Files
 359           callback {if (!app->connected()) {
 360  fl_message("Not connected to Sfinx Server !");
 361  return;
 362 }
 363 app->sfinx.send(SFINX_FILES_MODULE_CONF_REQUEST, (u8_t) 0);
 364 if (app->sfinx.send(current_files_module_tree_path))
 365   return;
 366 files_module_w->show();}
 367           xywh {20 20 34 22} shortcut 0x66 labeltype ENGRAVED_LABEL
 368         }
 369         MenuItem {} {
 370           label Notes
 371           callback {if (!app->connected()) {
 372  fl_message("Not connected to Sfinx Server !");
 373  return;
 374 }
 375 // ÒÉÓÕÅÍ ÄÅÒÅ×Ï ÚÁÍÅÔÏË
 376 fill_objects_tree(notes_tree, 1 << SFINX_NOTE_OBJECT, 0, 0); // fluid bugs if any default params exists !
 377 notes_w->show();}
 378           xywh {30 30 34 22} shortcut 0x6e labeltype ENGRAVED_LABEL
 379         }
 380       }
 381       Submenu {} {
 382         label Tools open
 383         xywh {20 20 67 22} labeltype ENGRAVED_LABEL
 384       } {
 385         MenuItem search_mi {
 386           label {Browser && Searcher}
 387           callback {if (!app->connected()) {
 388  fl_message("Not connected to Sfinx Server !");
 389  return;
 390 }
 391 search_i->take_focus();
 392 search_w->show();}
 393           xywh {30 30 34 22} shortcut 0x62 labeltype ENGRAVED_LABEL
 394         }
 395         MenuItem {} {
 396           label Reader
 397           callback {if (!app->connected()) {
 398  fl_message("Not connected to Sfinx Server !");
 399  return;
 400 }}
 401           xywh {30 30 34 22} shortcut 0x72 labeltype ENGRAVED_LABEL deactivate divider
 402         }
 403         MenuItem {} {
 404           label {AI Tracer}
 405           callback {if (!app->connected()) {
 406  fl_message("Not connected to Sfinx Server !");
 407  return;
 408 }}
 409           xywh {40 40 34 22} shortcut 0x40061 labeltype ENGRAVED_LABEL deactivate
 410         }
 411         MenuItem {} {
 412           label {Knowledge Tracer}
 413           callback {if (!app->connected()) {
 414  fl_message("Not connected to Sfinx Server !");
 415  return;
 416 }}
 417           xywh {40 40 34 22} shortcut 0x4006b labeltype ENGRAVED_LABEL deactivate
 418         }
 419         MenuItem {} {
 420           label {Indexing machine}
 421           callback {if (!app->connected()) {
 422  fl_message("Not connected to Sfinx Server !");
 423  return;
 424 }}
 425           xywh {30 30 34 22} shortcut 0x40069 labeltype ENGRAVED_LABEL deactivate
 426         }
 427         MenuItem {} {
 428           label {Check Sfinx DB}
 429           callback {if (!app->connected()) {
 430  fl_message("Not connected to Sfinx Server !");
 431  return;
 432 }}
 433           xywh {40 40 34 22} shortcut 0x40064 labeltype ENGRAVED_LABEL deactivate
 434         }
 435         MenuItem {} {
 436           label {DB Backups}
 437           callback {if (!app->connected()) {
 438  fl_message("Not connected to Sfinx Server !");
 439  return;
 440 }}
 441           xywh {30 30 34 22} shortcut 0x40062 labeltype ENGRAVED_LABEL deactivate divider
 442         }
 443         MenuItem {} {
 444           label {Clear log window}
 445           callback {log_br->clear();}
 446           xywh {30 30 34 22} shortcut 0x10063 labeltype ENGRAVED_LABEL
 447         }
 448       }
 449       Submenu {} {
 450         label {                                                                                                                                                                 } open
 451         xywh {20 20 67 22} labeltype ENGRAVED_LABEL deactivate
 452       } {}
 453       Submenu {} {
 454         label Help
 455         xywh {20 20 67 22} labeltype ENGRAVED_LABEL
 456       } {
 457         MenuItem {} {
 458           label {Manual     }
 459           xywh {30 30 34 22} shortcut 0xffbe labeltype ENGRAVED_LABEL deactivate divider
 460         }
 461         MenuItem {} {
 462           label About
 463           callback {about_w->show();}
 464           xywh {30 30 34 22} shortcut 0x80061 labeltype ENGRAVED_LABEL
 465         }
 466       }
 467     }
 468     Fl_Output status_bar_o {
 469       tooltip Status xywh {0 347 945 20} box PLASTIC_UP_BOX color 31 deactivate
 470     }
 471     Fl_Browser log_br {
 472       xywh {-1 21 948 326} type Select color 31 labelfont 4 textfont 4
 473     }
 474   }
 475   Fl_Window preferences_w {
 476     label Preferences
 477     xywh {215 308 742 373} type Double color 31 hide
 478   } {
 479     Fl_Button {} {
 480       label Cancel
 481       callback {preferences_w->hide();}
 482       xywh {390 330 112 25} labeltype ENGRAVED_LABEL
 483     }
 484     Fl_Button {} {
 485       label Apply
 486       callback {write_preferences();
 487 preferences_w->hide();}
 488       xywh {572 330 112 25} labeltype ENGRAVED_LABEL
 489     }
 490     Fl_Scroll prefs_tree_scroll {
 491       xywh {10 29 173 283} type VERTICAL_ALWAYS box ENGRAVED_FRAME color 28
 492       code0 {config_tree = new Fl_Toggle_Tree(12, 12, prefs_tree_scroll->w() - prefs_tree_scroll->scrollbar.w(), 10);}
 493       code1 {fill_config_tree();}
 494     } {}
 495     Fl_Group config_connection_gr {open
 496       xywh {183 19 535 283} box ENGRAVED_FRAME hide
 497     } {
 498       Fl_Input config_sfinx_server_name_i {
 499         label {Sfinx Server Name}
 500         xywh {273 89 375 26} color 29 labeltype ENGRAVED_LABEL align 1
 501       }
 502       Fl_Choice {} {
 503         label {Minimum Auth Level}
 504         xywh {227 179 211 23} down_box BORDER_BOX color 48 labeltype ENGRAVED_LABEL align 5 deactivate
 505       } {
 506         MenuItem {} {
 507           label {User Name && Passsword}
 508           xywh {0 0 35 22}
 509         }
 510         MenuItem {} {
 511           label {RSA Key}
 512           xywh {10 10 35 22}
 513         }
 514       }
 515       Fl_Choice {} {
 516         label {Minimum Debug Level}
 517         xywh {227 230 211 23} down_box BORDER_BOX color 48 labeltype ENGRAVED_LABEL align 5 deactivate
 518       } {
 519         MenuItem {} {
 520           label {Debug Level}
 521           xywh {10 10 35 22}
 522         }
 523         MenuItem {} {
 524           label {Chat Level}
 525           xywh {20 20 35 22}
 526         }
 527         MenuItem {} {
 528           label {Info Level}
 529           xywh {20 20 35 22}
 530         }
 531         MenuItem {} {
 532           label {Notice Level}
 533           xywh {30 30 35 22}
 534         }
 535         MenuItem {} {
 536           label {Warning Level}
 537           xywh {30 30 35 22}
 538         }
 539         MenuItem {} {
 540           label {Error Level}
 541           xywh {40 40 35 22}
 542         }
 543         MenuItem {} {
 544           label {Alert Level}
 545           xywh {40 40 35 22}
 546         }
 547         MenuItem {} {
 548           label {Critical Level}
 549           xywh {50 50 35 22}
 550         }
 551         MenuItem {} {
 552           label {Fatal Level}
 553           xywh {60 60 35 22}
 554         }
 555       }
 556       Fl_Choice {} {
 557         label {Minimum Crypt Level}
 558         xywh {476 179 211 23} down_box BORDER_BOX color 48 labeltype ENGRAVED_LABEL align 5 deactivate
 559       } {
 560         MenuItem {} {
 561           label {Plain Stream}
 562           xywh {10 10 35 22}
 563         }
 564         MenuItem {} {
 565           label {AES Stream}
 566           xywh {20 20 35 22}
 567         }
 568       }
 569     }
 570     Fl_Group config_files_module_gr {
 571       xywh {193 29 535 283} box ENGRAVED_FRAME hide
 572     } {
 573       Fl_Input config_files_module_unsorted_path_i {
 574         label {Unsorted files path on Sfinx server}
 575         xywh {283 68 375 26} color 29 labeltype ENGRAVED_LABEL align 1
 576       }
 577       Fl_Input config_files_module_sorted_path_i {
 578         label {Sorted file tree path on Sfinx server}
 579         xywh {283 128 375 26} color 29 labeltype ENGRAVED_LABEL align 1
 580       }
 581       Fl_Check_Button gen_desc_files_b {
 582         label {Generate description files}
 583         xywh {209 233 241 23} box PLASTIC_UP_BOX down_box DOWN_BOX selection_color 15 labeltype ENGRAVED_LABEL align 16
 584       }
 585       Fl_Input config_files_module_desc_file_name_i {
 586         label {Description file name}
 587         xywh {283 189 375 26} color 29 labeltype ENGRAVED_LABEL align 1
 588       }
 589       Fl_Check_Button process_files_mime_type_b {
 590         label {Detect files MIME type}
 591         xywh {472 233 241 23} box PLASTIC_UP_BOX down_box DOWN_BOX selection_color 15 labeltype ENGRAVED_LABEL align 16
 592       }
 593     }
 594     Fl_Group config_confirmation_gr {
 595       xywh {183 19 535 283} box ENGRAVED_FRAME hide
 596     } {
 597       Fl_Check_Button exit_confirm_b {
 598         label {Exit confirm}
 599         xywh {216 45 204 23} box PLASTIC_UP_BOX down_box DOWN_BOX selection_color 15 labeltype ENGRAVED_LABEL deactivate
 600       }
 601     }
 602   }
 603   Fl_Window select_slice_w {
 604     label {Select Sfinx Slice}
 605     xywh {67 62 730 352} type Double color 31 hide modal
 606   } {
 607     Fl_Button {} {
 608       label Cancel
 609       callback {select_slice_w->hide();}
 610       xywh {594 312 112 25} box PLASTIC_UP_BOX labeltype ENGRAVED_LABEL
 611     }
 612     Fl_Button select_slice_b {
 613       label Select
 614       callback {Fl_Toggle_Node *node = select_slice_tree->selected();
 615 if (!node)
 616         return;
 617 sfinx_slice_t *slice = (sfinx_slice_t *) node->user_data();
 618 void (*select_slice_action)(sfinx_slice_t *) = (void (*)(sfinx_slice_t *))(select_slice_b->user_data());
 619 select_slice_action(slice);}
 620       xywh {16 312 548 25} box PLASTIC_UP_BOX labeltype ENGRAVED_LABEL
 621     }
 622     Fl_Scroll select_slice_tree_scroll {open
 623       xywh {15 15 702 280} box ENGRAVED_FRAME color 28
 624       code0 {select_slice_tree = new Fl_Toggle_Tree(12, 12, select_slice_tree_scroll->w(), 10);}
 625       code1 {select_slice_tree->callback(select_slice_tree_cb);select_slice_tree->user_data((void *)select_slice_tree_scroll);}
 626       code2 {select_slice_w->resizable(select_slice_tree_scroll);}
 627       code3 {select_slice_tree_scroll->resizable(select_slice_tree);}
 628       class Fl_Scroll_Resize
 629     } {}
 630   }
 631   Fl_Window slices_w {
 632     label {Sfinx Data}
 633     xywh {200 315 866 370} type Double color 31 hide modal
 634   } {
 635     Fl_Button {} {
 636       label Cancel
 637       callback {slices_w->hide();}
 638       xywh {734 312 112 25} labeltype ENGRAVED_LABEL
 639     }
 640     Fl_Button {} {
 641       label {Delete slice}
 642       callback {Fl_Toggle_Node *node = slices_tree->selected();
 643 if (!node)
 644         return;
 645 sfinx_slice_t *slice = (sfinx_slice_t *)node->user_data();
 646 if (slice->id == 1) // Root Slice can't be deleted
 647         return;
 648 // set safe deletion mode
 649 slice_deletion_type_ch->value(0);
 650 data_deletion_type_ch->value(0);
 651 delete_sfinx_slice_to->value(slice->name());
 652 delete_slice_w->show();}
 653       xywh {454 312 128 25} labeltype ENGRAVED_LABEL
 654     }
 655     Fl_Scroll slices_tree_scroll {
 656       xywh {15 13 837 280} box ENGRAVED_FRAME color 28
 657       code0 {slices_tree = new Fl_Toggle_Tree(12, 12, slices_tree_scroll->w(), 10);}
 658       code1 {slices_tree->callback(slices_tree_cb); slices_tree->user_data((void *)slices_tree_scroll);}
 659       code2 {slices_w->resizable(slices_tree_scroll);}
 660       code3 {slices_tree_scroll->resizable(slices_tree);}
 661       class Fl_Scroll_Resize
 662     } {}
 663     Fl_Button {} {
 664       label {Edit slice}
 665       callback {Fl_Toggle_Node *node = slices_tree->selected();
 666 if (!node)
 667         return;
 668 sfinx_slice_t *slice = (sfinx_slice_t *)node->user_data();
 669 edit_slice_w->user_data((void *)slice);
 670 app->sfinx.send(SFINX_EDIT_SLICE_REQUEST, (u32_t)slice->id);
 671 edit_slice_w->label("Edit Sfinx Slice");}
 672       xywh {305 312 128 25} labeltype ENGRAVED_LABEL
 673     }
 674     Fl_Output slices_status_to {
 675       xywh {0 349 866 21} box PLASTIC_UP_BOX color 31 deactivate
 676     }
 677     Fl_Button {} {
 678       label {New slice}
 679       callback {Fl_Toggle_Node *node = slices_tree->selected();
 680 if (!node) {
 681         fl_alert("Please select slice connection point !");
 682         return;
 683 }
 684 edit_slice_w->user_data(0); // new slice
 685 slice_name_i->value(0);
 686 slice_directory_i->value(0);
 687 slice_name_i->take_focus();
 688 slice_description_i->value(0);
 689 sfinx_slice_t *slice = (sfinx_slice_t *)slices_tree->selected()->user_data();
 690 edit_slice_to->value(string(string("Parent slice: ") + slice->name()).c_str());
 691 edit_slice_w->label("New Sfinx Slice");
 692 edit_slice_w->show();}
 693       xywh {21 312 112 25} labeltype ENGRAVED_LABEL
 694     }
 695     Fl_Button {} {
 696       label {Relink slice}
 697       callback {Fl_Toggle_Node *node = slices_tree->selected();
 698 if (!node)
 699         return;
 700 sfinx_slice_t *slice = (sfinx_slice_t *)node->user_data();
 701 if (slice->id == 1) // root slice can't be relinked
 702         return;
 703 fill_objects_tree(select_slice_tree, SFINX_SLICE_OBJECT, slice, 0);
 704 select_slice_b->user_data((void *)relink_slice_action);
 705 select_slice_w->show();}
 706       xywh {155 312 128 25} labeltype ENGRAVED_LABEL
 707     }
 708     Fl_Button {} {
 709       label Search
 710       callback {search_mi->do_callback(0, (void *)0);}
 711       xywh {600 312 119 25} labeltype ENGRAVED_LABEL
 712     }
 713   }
 714   Fl_Window edit_slice_w {
 715     label {Edit Sfinx Slice}
 716     xywh {276 319 595 330} type Double color 31 hide modal
 717   } {
 718     Fl_Input slice_name_i {
 719       label {Slice Name}
 720       xywh {47 35 496 26} color 29 labeltype ENGRAVED_LABEL align 1
 721     }
 722     Fl_Input slice_directory_i {
 723       label {Slice Directory}
 724       xywh {47 93 496 26} color 29 labeltype ENGRAVED_LABEL align 1
 725     }
 726     Fl_Input slice_description_i {
 727       label {Slice Description}
 728       xywh {34 158 523 89} type Multiline color 29 labeltype ENGRAVED_LABEL align 1
 729     }
 730     Fl_Return_Button {} {
 731       label Ok
 732       callback {if (!slice_name_i->size()) {
 733         fl_message("Missing slice name !");
 734         return;
 735 }
 736 sfinx_slice_t *eslice = (sfinx_slice_t *)edit_slice_w->user_data();
 737 sfinx_slice_t slice;
 738 if (eslice) {
 739         slice.tid(SFINX_EDIT_SLICE);
 740         slice.id = eslice->id; // edited slice id
 741         slice.parent_id = eslice->parent_id;
 742 } else {
 743         slice.tid(SFINX_NEW_SLICE);
 744         sfinx_slice_t *s =  (sfinx_slice_t *)(slices_tree->selected()->user_data());
 745         slice.parent_id = s->id; // parent id for new slice
 746 }
 747 slice.name(slice_name_i->value());
 748 slice.directory(slice_directory_i->value());
 749 slice.description(slice_description_i->value());
 750 app->sfinx.send(slice);
 751 edit_slice_w->hide();
 752 fill_objects_tree(slices_tree, 1 << SFINX_SLICE_OBJECT, 0, 1); // force refresh}
 753       xywh {111 270 112 25} labeltype ENGRAVED_LABEL
 754     }
 755     Fl_Button {} {
 756       label Cancel
 757       callback {edit_slice_w->hide();}
 758       xywh {359 270 112 25} labeltype ENGRAVED_LABEL
 759     }
 760     Fl_Output edit_slice_to {
 761       xywh {0 312 598 21} box PLASTIC_UP_BOX color 31 labelsize 10 textsize 10
 762     }
 763   }
 764   Fl_Window delete_slice_w {
 765     label {Delete Sfinx Slice}
 766     xywh {350 43 388 223} type Double color 31 hide modal
 767   } {
 768     Fl_Button {} {
 769       label Cancel
 770       callback {delete_slice_w->hide();}
 771       xywh {238 175 112 25} labeltype ENGRAVED_LABEL
 772     }
 773     Fl_Button {} {
 774       label Delete
 775       callback {// need to confirm deletion ?!
 776 bool recursivly = slice_deletion_type_ch->value();
 777 sfinx_slice_t *slice = (sfinx_slice_t *)slices_tree->selected()->user_data();
 778 app->sfinx.send(data_deletion_type_ch->value() ?
 779         (recursivly ? SFINX_DELETE_SLICE_ASSOC_DATA_RECURSIVLY : SFINX_DELETE_SLICE_ASSOC_DATA) :
 780         (recursivly ? SFINX_DELETE_SLICE_MARK_DATA_UNSORTED_RECURSIVLY : SFINX_DELETE_SLICE_MARK_DATA_UNSORTED),
 781         (u32_t)slice->id);
 782 app->sfinx.send(recursivly ? SFINX_DELETE_SLICE_RECURSIVLY : SFINX_DELETE_SLICE_WITH_REATTACH,
 783         (u32_t)slice->id);
 784 delete_slice_w->hide();
 785 fill_objects_tree(slices_tree, 1 << SFINX_SLICE_OBJECT, 0, 1); // force refresh}
 786       xywh {39 175 112 25} labeltype ENGRAVED_LABEL
 787     }
 788     Fl_Output delete_sfinx_slice_to {
 789       label {Please confirm deletion of the slice}
 790       xywh {35 31 330 26} box ENGRAVED_FRAME color 29 labeltype ENGRAVED_LABEL align 1
 791     }
 792     Fl_Choice slice_deletion_type_ch {
 793       label {Slice && Data Deletion Action}
 794       xywh {73 82 240 23} down_box BORDER_BOX color 48 labeltype ENGRAVED_LABEL align 1
 795     } {
 796       MenuItem {} {
 797         label {Attach subslices to parent}
 798         xywh {10 10 35 22}
 799       }
 800       MenuItem {} {
 801         label {Delete all subslices recursivly}
 802         xywh {20 20 35 22}
 803       }
 804     }
 805     Fl_Choice data_deletion_type_ch {
 806       label {Associated Data Deletion Action}
 807       xywh {73 132 240 23} down_box BORDER_BOX color 48 labeltype ENGRAVED_LABEL align 1
 808     } {
 809       MenuItem {} {
 810         label {Mark all data 'Unsorted'}
 811         xywh {20 20 35 22}
 812       }
 813       MenuItem {} {
 814         label {Delete all data}
 815         xywh {30 30 35 22}
 816       }
 817     }
 818   }
 819   Fl_Window progress_w {
 820     label Progress
 821     xywh {286 302 464 98} type Double hide
 822   } {
 823     Fl_Progress progress_bar {
 824       label {67 %}
 825       xywh {22 46 422 27} box PLASTIC_DOWN_BOX selection_color 2
 826     }
 827     Fl_Box progress_l {
 828       label {Doing some work ...}
 829       xywh {66 10 330 25} box FLAT_BOX labeltype ENGRAVED_LABEL
 830     }
 831   }
 832   Fl_Window files_module_w {
 833     label {Files Module}
 834     xywh {87 152 730 370} type Double color 31 hide resizable
 835   } {
 836     Fl_Button {} {
 837       label Cancel
 838       callback {files_module_w->hide();}
 839       xywh {605 312 112 25} labeltype ENGRAVED_LABEL
 840     }
 841     Fl_Output files_module_status_to {
 842       xywh {0 349 733 21} box PLASTIC_UP_BOX color 31
 843     }
 844     Fl_Button classify_file_b {
 845       label Classify
 846       callback {int n = files_module_tree_br->value();
 847 if (!n)
 848         return;
 849 sfinx_file_t *file = ((sfinx_files_vector_t *)files_module_tree_br->user_data())->files[n - 1];
 850 //debug("slice_id - %d, parent_id - %d, name - %s", current_files_module_tree_path.file_id, current_files_module_tree_path.mtag_slice_id,
 851 //      file->name.c_str());
 852 string path;
 853 //if (current_files_module_tree_path.tid() == SFINX_FILES_MODULE_UNSORTED_TREE_REQUEST)
 854 //      app->files_module_conf.get(FILES_MODULE_UNSORTED_PATH, path);
 855 //else
 856 //      app->files_module_conf.get(FILES_MODULE_SORTED_TREE_PATH, path);
 857 char buf[256];
 858 int eyear, emonth, eday, ehour, emin, esec, cyear, cmonth, cday, chour, cmin, csec;
 859 file->etime.GetDate(eyear, emonth, eday);
 860 file->etime.GetTime(ehour, emin, esec);
 861 file->ctime.GetDate(cyear, cmonth, cday);
 862 file->ctime.GetTime(chour, cmin, csec);
 863 sprintf(buf, "%llu bytes | Modified: %02d/%02d/%04d %02d:%02d:%02d | Last Status Changed: %02d/%02d/%04d %02d:%02d:%02d", file->fsize, cday, cmonth,
 864         cyear, chour, cmin, csec, eday, emonth, eyear, ehour, emin, esec);
 865 string t = "URL: " + path + current_files_module_tree_path.name + "/" + file->name + " | " + file->mimetype + " | Size: " + buf;
 866 classify_file_to->value(t.c_str());
 867 file_title_i->value(0);
 868 file_name_i->value(file->name.c_str());
 869 // save orig file name
 870 file->orig_name = file->name;
 871 file->tid(SFINX_FILES_MODULE_CLASSIFY_REQUEST); // new file
 872 file_title_i->take_focus();
 873 file_authority_i->value(0);
 874 file_description_i->value(0);
 875 file_comments_i->value(0);
 876 sorted_location_b->value(1);
 877 file_compress_b->value(1);
 878 file_gen_csum_b->value(1);
 879 file_main_slice_b->label("Main Slice (Not Set)");
 880 file_main_slice_b->user_data(0); // ÔÕÔÁ ÈÒÁÎÉÔÓÑ slice_id
 881 file_additional_slices_br->clear();
 882 classify_file_w->user_data((void *)file);
 883 classify_file_w->show();}
 884       xywh {21 312 112 25} labeltype ENGRAVED_LABEL
 885     }
 886     Fl_Button {} {
 887       label Edit
 888       xywh {154 312 128 25} labeltype ENGRAVED_LABEL
 889     }
 890     Fl_Browser files_module_tree_br {
 891       callback {if (!Fl::event_clicks())
 892         return;
 893 sfinx_files_vector_t *tree = (sfinx_files_vector_t *) files_module_tree_br->user_data();
 894 int n = files_module_tree_br->value();
 895 //debug("selected %s file", tree->files[n - 1]->url.c_str());
 896 if (tree->files[n - 1]->is_directory) { // ÀÚÅÒ ÓÍÅÎÉÌ ÄÉÒÅËÔÏÒÉÀ
 897         // × file_id ÈÒÁÎÉÔÓÑ id ÔÅËÕÝÅÊ ÄÉÒÅËÔÏÒÉÉ-ÓÌÁÊÓÁ × ËÏÔÏÒÏÊ ÎÁÈÏÄÉÍÓÑ/×ÙÂÒÁÌÉ
 898         // × mtag_id - parent_id ÄÉÒÅËÔÏÒÉÉ
 899         // ÚÁÈÏÄÉÍ × ÄÉÒÅËÔÏÒÉÀ - ÔÅËÕÝÁÑ ÓÔÁÎÏ×ÉÔÓÑ parent'ÏÍ
 900         current_files_module_tree_path.file_id = tree->files[n - 1]->file_id;
 901         current_files_module_tree_path.mtag_id = tree->files[n - 1]->mtag_id;
 902         // × name ÈÒÁÎÉÔÓÑ ×ÅÓØ ÐÕÔØ ÏÔ root location
 903         // × orig_name ÔÏÌØËÏ ÉÍÑ ÔÅËÕÝÅÊ
 904         string t = current_files_module_tree_path.name.c_str();
 905 //      current_files_module_tree_path.orig_name = tree->files[n - 1]->name;
 906         t += ('/' + tree->files[n - 1]->name);
 907         current_files_module_tree_path.name = t;
 908         //debug("requesting dir %s", current_files_module_tree_path.c_str());
 909         app->sfinx.send(current_files_module_tree_path);
 910 } else {
 911         if (!(tree->files[n - 1]->file_id)) // classify file
 912                 classify_file_b->do_callback();
 913         else {
 914                 // app->sfinx.send(SFINX_SLICES_MODULE_TREE_REQUEST, (u8_t)0); // prepare for slice_name() calls
 915                 sfinx_file_t *file = tree->files[n - 1];
 916                 file->tid(SFINX_FILES_MODULE_EDIT_REQUEST);
 917                 app->sfinx.send(file);
 918         }
 919 }}
 920       xywh {8 45 716 255} type Multi color 31 resizable
 921       code0 {static int widths[] = { 10, 450, 200, 200, 0};}
 922       code1 {files_module_tree_br->column_widths(widths);}
 923     }
 924     Fl_Button {} {
 925       label Delete
 926       callback {int n = files_module_tree_br->value();
 927 if (!n)
 928         return;
 929 sfinx_file_t *file = ((sfinx_files_vector_t *)files_module_tree_br->user_data())->files[n - 1];
 930 string path;
 931 if (current_files_module_tree_path.tid() == SFINX_FILES_MODULE_UNSORTED_TREE_REQUEST) {
 932         // sure ?
 933         string message = "Deleting \\'" + file->name + "\\'. Are you sure ?";
 934         if (fl_choice(message.c_str(), "Yes", "No", 0L))
 935                 return;
 936         app->files_module_conf.get(FILES_MODULE_UNSORTED_PATH, path);
 937         path += "/" + file->name;
 938         sfinx_string_t f(SFINX_FILES_MODULE_UNLINK);
 939         f.set(path);
 940         app->sfinx.send(f);
 941 } else {
 942         // sorted can be marked unsorted or deleted
 943         string message = "Delete or Unsort \\'" + file->name + "\\' ?";
 944         int res = fl_choice(message.c_str(), "Cancel", "Unsort", "Delete");
 945         if (!res)
 946                 return;
 947         if (res == 2) { // delete
 948                 file->tid(SFINX_FILES_MODULE_SORTED_UNLINK);
 949                 app->sfinx.send(file);
 950         } else {
 951                 file->tid(SFINX_FILES_MODULE_UNSORT);
 952                 app->sfinx.send(file);
 953         }
 954 }
 955 //files_module_tree_br->remove(n);
 956 app->sfinx.send(current_files_module_tree_path);}
 957       xywh {300 312 112 25} labeltype ENGRAVED_LABEL
 958     }
 959     Fl_Button select_files_tree_b {
 960       label {Sorted tree}
 961       callback {files_module_tree_br->clear();
 962 current_files_module_tree_path.name.clear();
 963 current_files_module_tree_path.orig_name.clear();
 964 if (select_files_tree_b->user_data()) {
 965         select_files_tree_b->user_data(0);
 966         select_files_tree_b->label("Sorted tree");
 967         current_files_module_tree_path.tid(SFINX_FILES_MODULE_UNSORTED_TREE_REQUEST);
 968         current_files_module_tree_path.file_id = 0;
 969 } else {
 970         select_files_tree_b->user_data((void *)1);
 971         select_files_tree_b->label("Unsorted tree");
 972 //      current_files_module_tree_path.tid(SFINX_FILES_MODULE_SORTED_TREE_REQUEST);
 973         current_files_module_tree_path.file_id = 1; // root id
 974
 975 }
 976 select_files_tree_b->redraw();
 977 app->sfinx.send(current_files_module_tree_path);}
 978       xywh {562 10 128 25} labeltype ENGRAVED_LABEL
 979     }
 980     Fl_Button {} {
 981       label {Up [ .. ]}
 982       callback {const char *p = strrchr(current_files_module_tree_path.name.c_str(), '/');
 983 if (!p)
 984         current_files_module_tree_path.name.clear();
 985 else {
 986         char path[1024];
 987         path[0] = 0;
 988         strncat(path, current_files_module_tree_path.name.c_str(), p - current_files_module_tree_path.name.c_str());
 989         current_files_module_tree_path.name = path;
 990         current_files_module_tree_path.file_id = current_files_module_tree_path.mtag_id;
 991 }
 992 app->sfinx.send(current_files_module_tree_path);}
 993       xywh {35 10 112 25} labeltype ENGRAVED_LABEL
 994     }
 995     Fl_Button {} {
 996       label Reload
 997       callback {app->sfinx.send(current_files_module_tree_path);}
 998       xywh {166 10 112 25} labeltype ENGRAVED_LABEL
 999     }
1000     Fl_Button {} {
1001       label {Select All}
1002       callback {for (int i = 1; i <= files_module_tree_br->size(); i++)
1003         files_module_tree_br->select(i);}
1004       xywh {295 10 112 25} labeltype ENGRAVED_LABEL
1005     }
1006     Fl_Button {} {
1007       label {Unselect All}
1008       callback {files_module_tree_br->deselect();}
1009       xywh {428 10 112 25} labeltype ENGRAVED_LABEL
1010     }
1011   }
1012   Fl_Window classify_file_w {
1013     label {Classify File}
1014     xywh {84 298 1020 515} type Double color 31 hide modal
1015   } {
1016     Fl_Button {} {
1017       label Cancel
1018       callback {classify_file_w->hide();}
1019       xywh {612 454 112 25} labeltype ENGRAVED_LABEL
1020     }
1021     Fl_Input file_title_i {
1022       label Title
1023       xywh {16 27 496 26} color 29 labeltype ENGRAVED_LABEL align 1
1024     }
1025     Fl_Input file_authority_i {
1026       label Authority
1027       xywh {16 83 496 26} color 29 labeltype ENGRAVED_LABEL align 1
1028     }
1029     Fl_Input file_description_i {
1030       label Description
1031       xywh {549 78 447 101} type Multiline color 29 labeltype ENGRAVED_LABEL align 1
1032     }
1033     Fl_Input file_comments_i {
1034       label Comments
1035       xywh {582 220 416 212} type Multiline color 29 labeltype ENGRAVED_LABEL align 1
1036     }
1037     Fl_Output classify_file_to {
1038       xywh {0 497 1022 21} box PLASTIC_UP_BOX color 31 labelsize 10 textsize 10
1039     }
1040     Fl_Return_Button {} {
1041       label Ok
1042       callback {if (!file_main_slice_b->user_data()) {
1043         fl_alert("You have to select Main Slice for file !");
1044         return;
1045 }
1046 if (!file_name_i->size()) {
1047         fl_alert("File must have some name !");
1048         return;
1049 }
1050 sfinx_file_t *file = (sfinx_file_t *)classify_file_w->user_data();
1051 // file->tid(SFINX_FILES_MODULE_CLASSIFY_REQUEST);
1052 file->name = file_name_i->value();
1053 file->title = file_title_i->value();
1054 file->authority = file_authority_i->value();
1055 file->description = file_description_i->value();
1056 file->comments = file_comments_i->value();
1057 file->sorted_location = sorted_location_b->value();
1058 file->store_compressed = file_compress_b->value();
1059 file->generate_csum = file_gen_csum_b->value();
1060 file->mtag_id = from_voidp(file_main_slice_b->user_data());
1061 file->objects.clear();
1062 for (int i = 1; i <= file_additional_slices_br->size(); i++) {
1063 //      file->objects.push_back(from_voidp(file_additional_slices_br->data(i)));
1064 }
1065 app->sfinx.send(file);}
1066       xywh {243 454 112 25} labeltype ENGRAVED_LABEL
1067     }
1068     Fl_Check_Button sorted_location_b {
1069       label {Sorted Location}
1070       xywh {15 132 241 23} box PLASTIC_UP_BOX down_box DOWN_BOX selection_color 15 labeltype ENGRAVED_LABEL align 16
1071     }
1072     Fl_Check_Button file_crypt_b {
1073       label Encrypt
1074       xywh {15 165 241 23} box PLASTIC_UP_BOX down_box DOWN_BOX selection_color 15 labeltype ENGRAVED_LABEL align 16 deactivate
1075     }
1076     Fl_Check_Button file_compress_b {
1077       label {Store compressed}
1078       xywh {274 132 241 23} box PLASTIC_UP_BOX down_box DOWN_BOX selection_color 15 labeltype ENGRAVED_LABEL align 16
1079     }
1080     Fl_Box {} {
1081       xywh {13 205 552 227} box ENGRAVED_FRAME
1082     }
1083     Fl_Button file_main_slice_b {
1084       label {Main Slice (Not Set)}
1085       callback {app->refresh_slices();
1086 slices_w->user_data((void *)select_file_main_slice_action);
1087 slices_w->show();}
1088       tooltip {File Main Slice} xywh {45 226 489 25} box PLASTIC_THIN_UP_BOX labeltype ENGRAVED_LABEL
1089     }
1090     Fl_Browser file_additional_slices_br {
1091       label {Additional Slices}
1092       xywh {26 275 525 102} type Multi color 46 labeltype ENGRAVED_LABEL align 1
1093     }
1094     Fl_Button file_add_slice_b {
1095       label {Add Slice}
1096       callback {app->refresh_slices();
1097 slices_w->user_data((void *)select_file_additional_slice_action);
1098 slices_w->show();}
1099       xywh {82 391 138 25} box PLASTIC_THIN_UP_BOX labeltype ENGRAVED_LABEL
1100     }
1101     Fl_Button file_remove_slice_b {
1102       label {Remove Slice}
1103       callback {for (int i = file_additional_slices_br->size(); i >= 1; i--) {
1104         if (file_additional_slices_br->selected(i))
1105                 file_additional_slices_br->remove(i);
1106 }}
1107       xywh {358 391 138 25} box PLASTIC_THIN_UP_BOX labeltype ENGRAVED_LABEL
1108     }
1109     Fl_Input file_name_i {
1110       label {File Name}
1111       xywh {549 26 447 26} color 29 labeltype ENGRAVED_LABEL align 1
1112     }
1113     Fl_Check_Button file_gen_csum_b {
1114       label {Generate CSUM}
1115       xywh {274 165 241 23} box PLASTIC_UP_BOX down_box DOWN_BOX selection_color 15 labeltype ENGRAVED_LABEL align 16
1116     }
1117   }
1118   Fl_Window search_w {
1119     label Search
1120     xywh {169 380 749 389} type Double color 31 hide modal
1121   } {
1122     Fl_Button {} {
1123       label Cancel
1124       callback {search_w->hide();}
1125       xywh {182 347 363 25} box PLASTIC_ROUND_UP_BOX labeltype ENGRAVED_LABEL
1126     }
1127     Fl_Return_Button {} {
1128       label Search
1129       callback {sfinx_search_query_t query;
1130 query.pattern = search_i->value();
1131 if (search_in_files_b->value())
1132         query.add_area(SFINX_SEARCH_IN_FILES);
1133 // add restrictions ...
1134 app->sfinx.send(query);}
1135       xywh {539 48 163 25} box PLASTIC_ROUND_UP_BOX labeltype ENGRAVED_LABEL
1136     }
1137     Fl_Check_Button search_in_files_b {
1138       label {Search in Files}
1139       xywh {48 96 241 23} box PLASTIC_UP_BOX down_box DOWN_BOX selection_color 15 labeltype ENGRAVED_LABEL align 16 deactivate
1140     }
1141     Fl_Box {} {
1142       xywh {87 141 561 189} box ROUNDED_FRAME
1143     }
1144     Fl_Browser search_slices_br {
1145       label {Restrict Search by Slices}
1146       xywh {105 173 525 102} type Multi color 46 labeltype ENGRAVED_LABEL align 1
1147     }
1148     Fl_Button search_add_slice_b {
1149       label {Add Slice}
1150       callback {app->refresh_slices();
1151 slices_w->user_data((void *)search_add_slice_action);
1152 slices_w->show();}
1153       xywh {161 289 138 25} box PLASTIC_THIN_UP_BOX labeltype ENGRAVED_LABEL
1154     }
1155     Fl_Button {} {
1156       label {Remove Slice}
1157       callback {for (int i = search_slices_br->size(); i >= 1; i--) {
1158         if (search_slices_br->selected(i))
1159                 search_slices_br->remove(i);
1160 }}
1161       xywh {437 289 138 25} box PLASTIC_THIN_UP_BOX labeltype ENGRAVED_LABEL
1162     }
1163     Fl_Input search_i {
1164       label {Search for ...}
1165       xywh {46 47 447 26} color 29 labeltype ENGRAVED_LABEL align 1
1166     }
1167   }
1168   Fl_Window search_browser_w {
1169     label {Search Browser}
1170     xywh {217 305 854 476} type Double color 31 hide resizable modal
1171   } {
1172     Fl_Button {} {
1173       label Cancel
1174       callback {search_browser_w->hide();}
1175       xywh {638 449 187 20} box PLASTIC_ROUND_UP_BOX color 0 labeltype ENGRAVED_LABEL
1176     }
1177     Fl_Browser search_browser_br {
1178       xywh {4 4 846 439} type Hold box GTK_THIN_UP_BOX color 44 resizable
1179     }
1180     Fl_Button {} {
1181       label {Previous Page}
1182       xywh {25 449 169 20} box PLASTIC_ROUND_UP_BOX color 0 labeltype ENGRAVED_LABEL
1183     }
1184     Fl_Button {} {
1185       label {Next Page}
1186       xywh {231 449 169 20} box PLASTIC_ROUND_UP_BOX color 0 labeltype ENGRAVED_LABEL
1187     }
1188     Fl_Choice goto_page_ch {
1189       label {Current Page }
1190       xywh {531 450 72 20} box PLASTIC_THIN_UP_BOX down_box PLASTIC_THIN_UP_BOX color 44 labeltype ENGRAVED_LABEL
1191     } {}
1192   }
1193   Fl_Window notes_w {
1194     label {Notes Module} open
1195     xywh {272 69 730 370} type Double color 31 hide resizable
1196   } {
1197     Fl_Button {} {
1198       label Cancel
1199       callback {notes_w->hide();}
1200       xywh {605 312 112 25} labeltype ENGRAVED_LABEL
1201     }
1202     Fl_Output notes_module_status_to {
1203       xywh {0 349 733 21} box PLASTIC_UP_BOX color 31
1204     }
1205     Fl_Button {} {
1206       label New
1207       callback {Fl_Toggle_Node *node = notes_tree->selected();
1208 if (!node) {
1209         fl_alert("Please select slice connection point !");
1210         return;
1211 }
1212 sfinx_note_t *note = new sfinx_note_t(SFINX_NOTES_MODULE_ADD);
1213 edit_note_w->user_data((void *)note);
1214 sfinx_object_t *obj;
1215 if (node->can_open()) // slice
1216         obj = ((sfinx_slice_t *)node->user_data())->object();
1217 else // object
1218         obj = (sfinx_object_t *) node->user_data();
1219 note_mtag_b->user_data(obj);
1220 note_mtag_b->copy_label((obj->name + " [ " + obj->description + " ]").c_str());
1221 note_mtag_b->redraw();
1222 note_name_i->value(0);
1223 note_url_i->value(0);
1224 note_text_i->value(0);
1225 note_name_i->take_focus();
1226 edit_note_w->show();}
1227       xywh {21 312 112 25} labeltype ENGRAVED_LABEL
1228     }
1229     Fl_Button {} {
1230       label Edit
1231       callback {Fl_Toggle_Node *node = notes_tree->selected();
1232 if (!node || node->can_open()) {
1233         fl_alert("Please select note to edit !");
1234         return;
1235 }
1236 sfinx_object_t *obj = (sfinx_object_t *) node->user_data();
1237 if (obj->type != SFINX_NOTE_OBJECT)
1238         bug();
1239 sfinx_note_t note(SFINX_NOTES_MODULE_EDIT_REQUEST);
1240 note.id = obj->id;
1241 app->sfinx.send(note);}
1242       xywh {154 312 128 25} labeltype ENGRAVED_LABEL
1243     }
1244     Fl_Scroll notes_tree_scroll {
1245       xywh {13 45 705 254} box ENGRAVED_FRAME color 28
1246       code0 {notes_tree = new Fl_Toggle_Tree(12, 12, notes_tree_scroll->w(), 10);}
1247       code1 {notes_tree->callback(notes_tree_cb); notes_tree->user_data((void *)notes_tree_scroll);}
1248       code2 {notes_w->resizable(notes_tree_scroll);}
1249       code3 {notes_tree_scroll->resizable(notes_tree);}
1250       class Fl_Scroll_Resize
1251     } {}
1252     Fl_Button {} {
1253       label Delete
1254       callback {/*int n = notes_br->value();
1255 if (!n)
1256         return;
1257 sfinx_file_t *file = ((sfinx_files_vector_t *)files_module_tree_br->user_data())->files[n - 1];
1258 string path;
1259 if (current_files_module_tree_path.tid() == SFINX_FILES_MODULE_UNSORTED_TREE_REQUEST) {
1260         // sure ?
1261         string message = "Deleting \\'" + file->name + "\\'. Are you sure ?";
1262         if (fl_choice(message.c_str(), "Yes", "No", 0L))
1263                 return;
1264         app->files_module_conf.get(FILES_MODULE_UNSORTED_PATH, path);
1265         path += "/" + file->name;
1266         sfinx_string_t f(SFINX_FILES_MODULE_UNLINK);
1267         f.set(path);
1268         app->sfinx.send(f);
1269 } else {
1270         // sorted can be marked unsorted or deleted
1271         string message = "Delete or Unsort \\'" + file->name + "\\' ?";
1272         int res = fl_choice(message.c_str(), "Cancel", "Unsort", "Delete");
1273         if (!res)
1274                 return;
1275         if (res == 2) { // delete
1276                 file->tid(SFINX_FILES_MODULE_SORTED_UNLINK);
1277                 app->sfinx.send(file);
1278         } else {
1279                 file->tid(SFINX_FILES_MODULE_UNSORT);
1280                 app->sfinx.send(file);
1281         }
1282 }
1283 //files_module_tree_br->remove(n);
1284 app->sfinx.send(current_files_module_tree_path);*/}
1285       xywh {300 312 112 25} labeltype ENGRAVED_LABEL
1286     }
1287     Fl_Button {} {
1288       label {Up [ .. ]}
1289       xywh {35 10 112 25} labeltype ENGRAVED_LABEL
1290     }
1291     Fl_Button {} {
1292       label Reload
1293       callback {//app->sfinx.send(current_note);}
1294       xywh {166 10 112 25} labeltype ENGRAVED_LABEL
1295     }
1296     Fl_Button {} {
1297       label {Select All}
1298       callback {//for (int i = 1; i <= notes_br->size(); i++)
1299 //      notes_br->select(i);}
1300       xywh {297 10 112 25} labeltype ENGRAVED_LABEL
1301     }
1302     Fl_Button {} {
1303       label {Unselect All}
1304       callback {//notes_br->deselect();}
1305       xywh {428 10 112 25} labeltype ENGRAVED_LABEL
1306     }
1307   }
1308   Fl_Window edit_note_w {
1309     label {Edit Note}
1310     xywh {212 174 1020 385} type Double color 31 hide modal
1311   } {
1312     Fl_Button {} {
1313       label Cancel
1314       callback {edit_note_w->hide();}
1315       xywh {648 321 112 25} labeltype ENGRAVED_LABEL
1316     }
1317     Fl_Input note_name_i {
1318       label Name
1319       xywh {16 27 496 26} color 29 labeltype ENGRAVED_LABEL align 1
1320     }
1321     Fl_Input note_url_i {
1322       label URL
1323       xywh {16 83 496 26} color 29 labeltype ENGRAVED_LABEL align 1
1324     }
1325     Fl_Input note_text_i {
1326       label Text
1327       xywh {16 141 496 158} type Multiline color 29 labeltype ENGRAVED_LABEL align 1
1328     }
1329     Fl_Output edit_note_to {
1330       xywh {0 364 1022 21} box PLASTIC_UP_BOX color 31 labelsize 10 textsize 10
1331     }
1332     Fl_Return_Button {} {
1333       label Ok
1334       callback {if (!note_mtag_b->user_data()) {
1335         fl_alert("You have to select Main Object for note !");
1336         return;
1337 }
1338 if (!note_name_i->size()) {
1339         fl_alert("Note must have some name !");
1340         return;
1341 }
1342 if (!note_text_i->size()) {
1343         fl_alert("Note must have some text !");
1344         return;
1345 }
1346 sfinx_note_t *note = (sfinx_note_t *)edit_note_w->user_data();
1347 note->name = note_name_i->value();
1348 note->url = note_url_i->value();
1349 note->text = note_text_i->value();
1350 sfinx_object_t *obj = (sfinx_object_t *)note_mtag_b->user_data();
1351 note->mtag.id = obj->id;
1352 note->mtag.type = obj->type;
1353 note->mtag.slice_id = obj->slice_id;
1354 note_mtag_b->user_data(0);
1355 note->tags.clear();
1356 for (int i = 1; i <= note_tags_br->size(); i++) {
1357         obj = (sfinx_object_t *)note_tags_br->data(i);
1358         note->tags.push_back(*obj);
1359         note_tags_br->data(i, 0);
1360 }
1361 app->sfinx.send(note);
1362 delete note;
1363 edit_note_w->user_data(0);
1364 fill_objects_tree(notes_tree, 1 << SFINX_NOTE_OBJECT, 0, 1); // force refresh}
1365       xywh {279 321 112 25} labeltype ENGRAVED_LABEL
1366     }
1367     Fl_Box {} {
1368       xywh {535 72 467 227} box ENGRAVED_FRAME
1369     }
1370     Fl_Button note_mtag_b {
1371       label {Main Note Tag (Not Set)}
1372       callback {fill_objects_tree(slices_tree, (1 << SFINX_SLICE_OBJECT) | (1 << SFINX_FILE_OBJECT) | (1 << SFINX_NOTE_OBJECT), 0, 0); // fluid bugs if any default params exists !
1373 slices_w->user_data((void *)select_note_mtag_action);
1374 slices_w->show();}
1375       tooltip {Note Main Tag} xywh {594 93 348 25} box PLASTIC_THIN_UP_BOX labeltype ENGRAVED_LABEL
1376     }
1377     Fl_Browser note_tags_br {
1378       label {Additional Note Tags}
1379       xywh {559 146 420 102} type Multi color 46 labeltype ENGRAVED_LABEL align 1
1380     }
1381     Fl_Button note_add_tag_b {
1382       label {Add Tag}
1383       callback {fill_objects_tree(slices_tree, (1 << SFINX_SLICE_OBJECT) | (1 << SFINX_FILE_OBJECT) | (1 << SFINX_NOTE_OBJECT), 0, 0); // fluid bugs if any default params exists !
1384 slices_w->user_data((void *)select_note_atag_action);
1385 slices_w->show();}
1386       xywh {584 258 138 25} box PLASTIC_THIN_UP_BOX labeltype ENGRAVED_LABEL
1387     }
1388     Fl_Button note_remove_tag_b {
1389       label {Remove Tag}
1390       callback {for (int i = note_tags_br->size(); i >= 1; i--) {
1391         if (note_tags_br->selected(i))
1392                 note_tags_br->remove(i);
1393 }}
1394       xywh {811 258 138 25} box PLASTIC_THIN_UP_BOX labeltype ENGRAVED_LABEL
1395     }
1396     Fl_Choice note_secured_ch {
1397       label {Secure Level}
1398       xywh {536 27 211 23} down_box BORDER_BOX color 48 labeltype ENGRAVED_LABEL align 5 deactivate
1399     } {
1400       MenuItem {} {
1401         label None
1402         xywh {10 10 35 22}
1403       }
1404       MenuItem {} {
1405         label {Crypted Text}
1406         xywh {20 20 35 22}
1407       }
1408     }
1409   }
1410   Fl_Window delete_note_w {
1411     label {Delete Note} open
1412     xywh {44 182 388 168} type Double color 31 hide modal
1413   } {
1414     Fl_Button {} {
1415       label Cancel
1416       callback {delete_note_w->hide();}
1417       xywh {239 122 112 25} labeltype ENGRAVED_LABEL
1418     }
1419     Fl_Button {} {
1420       label Delete
1421       callback {Fl_Toggle_Node *node = notes_tree->selected();
1422 if (!node || node->can_open())
1423         return;
1424 sfinx_object_t *obj = (sfinx_object_t *) node->user_data();
1425 sfinx_note_t note(note_deletion_type_ch->value() ? SFINX_NOTES_MODULE_UNLINK : SFINX_NOTES_MODULE_UNSORT);
1426 note.id = obj->id;
1427 app->sfinx.send(note);
1428 delete_note_w->hide();
1429 fill_objects_tree(notes_tree, (1 << SFINX_SLICE_OBJECT) | (1 << SFINX_NOTE_OBJECT), 0, 1); // force refresh} selected
1430       xywh {40 122 112 25} labeltype ENGRAVED_LABEL
1431     }
1432     Fl_Output delete_sfinx_note_to {
1433       label {Please confirm deletion of the note}
1434       xywh {31 26 330 26} box ENGRAVED_FRAME color 29 labeltype ENGRAVED_LABEL align 1
1435     }
1436     Fl_Choice note_deletion_type_ch {
1437       label {Associated Data Deletion Action}
1438       xywh {74 80 240 23} down_box BORDER_BOX color 48 labeltype ENGRAVED_LABEL align 1
1439     } {
1440       MenuItem {} {
1441         label {Mark all data 'Unsorted'}
1442         xywh {20 20 35 22}
1443       }
1444       MenuItem {} {
1445         label {Delete all data}
1446         xywh {30 30 35 22}
1447       }
1448     }
1449   }
1450   Fl_Window about_w {
1451     xywh {357 229 374 154} type Double hide
1452   } {
1453     Fl_Button {} {
1454       label Ok
1455       callback {about_w->hide();}
1456       xywh {72 122 226 20} box PLASTIC_ROUND_UP_BOX labeltype ENGRAVED_LABEL
1457     }
1458     Fl_Box {} {
1459       image {../docs/sfinx.jpg} xywh {10 9 130 101}
1460     }
1461     Fl_Box {} {
1462       label Sfinx
1463       xywh {203 6 99 33} labeltype EMBOSSED_LABEL labelfont 9 labelsize 32
1464     }
1465     Fl_Box {} {
1466       label {Personal knowledge manager}
1467       xywh {150 40 214 22} labeltype EMBOSSED_LABEL labelcolor 64
1468     }
1469     Fl_Box {} {
1470       label {Copyright (C) 2007 Rus V. Brushkoff}
1471       xywh {150 58 214 22} labeltype EMBOSSED_LABEL labelfont 8 labelsize 11 labelcolor 56
1472     }
1473     Fl_Box {} {
1474       label {Email:  Rus@@Sfinx.Od.UA}
1475       xywh {150 75 214 22} labeltype EMBOSSED_LABEL labelfont 8 labelsize 11 labelcolor 56
1476     }
1477     Fl_Box {} {
1478       label {http://sfinx.od.ua/index.php?id=sfinx}
1479       xywh {150 93 214 22} labeltype EMBOSSED_LABEL labelfont 8 labelsize 11 labelcolor 56
1480     }
1481   }
1482   code {main_w->show();} {}
1483 }
1484
1485 Function {x11_ui::log(int level, const char *fmt, ...)} {return_type void
1486 } {
1487   code {char buf[10240];
1488 const char *level_str;
1489 static Mutex log_m;
1490 log_m.enterMutex();
1491 Fl::lock();
1492 ::va_list args;
1493 ::va_start(args, fmt);
1494 ::va_end(args);
1495 switch (level) {
1496         case SFINX_LOG_NOTICE:
1497                 level_str = "NOTICE";
1498                 break;
1499         case SFINX_LOG_WARN:
1500                 level_str = "WARN";
1501                 break;
1502         case SFINX_LOG_ERROR:
1503                 level_str = "ERROR";
1504                 break;
1505         case SFINX_LOG_FATAL:
1506                 level_str = "FATAL";
1507                 break;
1508         default:
1509                 level_str = "UNKN_LEVEL";
1510 }
1511 // add time ?
1512 strcpy(buf, level_str);
1513 strcat(buf, ": ");
1514 ::vsnprintf(buf + strlen(level_str) + 2, sizeof(buf) - (strlen(level_str) + 2), fmt, args);
1515 log_br->add(buf);
1516 Fl::unlock();
1517 log_m.leaveMutex();} {}
1518 }
1519
1520 Function {x11_ui::edit_slice(sfinx_slice_t *slice)} {return_type void
1521 } {
1522   code {// need locks
1523 Fl::lock();
1524 slice_name_i->value(slice->name());
1525 slice_directory_i->value(slice->directory());
1526 slice_name_i->take_focus();
1527 slice_description_i->value(slice->description());
1528 string status_line = "Parent slice: ";
1529 status_line += slice->parent_name();
1530 int cyear, cmonth, cday, eyear, emonth, eday, chour, cmin, csec, ehour, emin, esec;
1531 slice->ctime.GetDate(cyear, cmonth, cday);
1532 slice->etime.GetDate(eyear, emonth, eday);
1533 slice->ctime.GetTime(chour, cmin, csec);
1534 slice->etime.GetTime(ehour, emin, esec);
1535 char buf[128];
1536 sprintf(buf, " | Created at %02d/%02d/%02d %02d:%02d:%02d, Modified at %02d/%02d/%02d %02d:%02d:%02d", cyear, cmonth, cday, chour, cmin,
1537         csec, eyear, emonth, eday, ehour, emin, esec);
1538 status_line += buf;
1539 edit_slice_to->value(status_line.c_str());
1540 edit_slice_w->show();
1541 Fl::unlock();} {}
1542 }
1543
1544 Function {x11_ui::fill_preferences()} {return_type void
1545 } {
1546   code {Fl::lock();
1547 string t;
1548 app->files_module_conf.get(FILES_MODULE_UNSORTED_PATH, t);
1549 config_files_module_unsorted_path_i->value(t.c_str());
1550 app->files_module_conf.get(FILES_MODULE_SORTED_TREE_PATH, t);
1551 config_files_module_sorted_path_i->value(t.c_str());
1552 app->files_module_conf.get(FILES_MODULE_DESC_FILE_NAME, t);
1553 config_files_module_desc_file_name_i->value(t.c_str());
1554 u32_t gen_desc_files;
1555 app->files_module_conf.get(FILES_MODULE_DESC_FILE_ENABLE, &gen_desc_files);
1556 gen_desc_files_b->value(gen_desc_files);
1557 Fl::unlock();} {}
1558 }
1559
1560 Function {x11_ui::fill_files_module_tree(sfinx_files_vector_t *tree_)} {return_type void
1561 } {
1562   code {Fl::lock();
1563 static sfinx_files_vector_t tree;
1564 tree.copy(tree_);
1565 files_module_tree_br->user_data((void *)&tree);
1566 files_module_tree_br->clear();
1567 char buf[256];
1568 u32_t files = 0, dirs = 0;
1569 // set parent dir id
1570 if (tree.files.size())
1571         current_files_module_tree_path.mtag_id = tree.files[0]->compressed_fsize;
1572 for (u32_t i = 0; i < tree.files.size(); i++) {
1573         if (tree.files[i]->is_directory)
1574                 strcpy(buf, "\\t@b@.");
1575         else
1576                 strcpy(buf, "\\t");
1577         strncat(buf, tree.files[i]->name.c_str(), 50);
1578         char dir_len[64];
1579         if (tree.files[i]->is_directory) {
1580                 strcpy(dir_len, "\\t@b@.< DIR >\\t");
1581                 dirs++;
1582         } else {
1583                 sprintf(dir_len, "\\t%llu\\t", tree.files[i]->fsize);
1584                 files++;
1585         }
1586         strcat(buf, dir_len);
1587         int cyear, cmonth, cday, chour, cmin, csec;
1588         tree.files[i]->ctime.GetDate(cyear, cmonth, cday);
1589         tree.files[i]->ctime.GetTime(chour, cmin, csec);
1590         sprintf(dir_len, "%02d/%02d/%04d %02d:%02d:%02d\\t", cday, cmonth, cyear, chour, cmin, csec);
1591         strcat(buf, dir_len);
1592         strcat(buf, tree.files[i]->mimetype.c_str());
1593         files_module_tree_br->add(buf);
1594 }
1595 files_module_tree_br->redraw();
1596 string root;
1597 if (current_files_module_tree_path.tid() == SFINX_FILES_MODULE_UNSORTED_TREE_REQUEST)
1598         app->files_module_conf.get(FILES_MODULE_UNSORTED_PATH, root);
1599 else
1600         app->files_module_conf.get(FILES_MODULE_SORTED_TREE_PATH, root);
1601 sprintf(buf, "Path: %s | Total %d file%s and %d director%s", (root + current_files_module_tree_path.name.c_str()).c_str(), files, (files == 1) ? "" : "s",  dirs,
1602         (dirs == 1) ? "y" : "ies");
1603 files_module_status_to->value(buf);
1604 files_module_status_to->redraw();
1605 Fl::unlock();} {}
1606 }
1607
1608 Function {x11_ui::files_module_classify_reply(sfinx_string_t *classify_error)} {return_type void
1609 } {
1610   code {Fl::lock();
1611 if (classify_error->size() == 1) {
1612         classify_file_w->hide();
1613         app->sfinx.send(current_files_module_tree_path);
1614         // files_module_tree_br->remove(files_module_tree_br->value());
1615 } else
1616         fl_alert(classify_error->c_str());
1617 Fl::unlock();} {}
1618 }
1619
1620 Function {x11_ui::progress(sfinx_progress_t *p)} {return_type void
1621 } {
1622   code {Fl::lock();
1623 static char buf[128];
1624 switch (p->status()) {
1625         case SFINX_PROGRESS_START:
1626                 progress_l->label(p->label());
1627                 strcpy(buf, p->strvalue());
1628                 progress_bar->label(buf);
1629                 progress_bar->minimum(0);
1630                 progress_bar->maximum(p->max());
1631                 progress_bar->value(p->value());
1632                 progress_w->show();
1633                 progress_w->redraw();
1634                 break;
1635         case SFINX_PROGRESS_END:
1636                 progress_w->hide();
1637                 break;
1638         case SFINX_PROGRESS_NONE:
1639         default:
1640                 break;
1641 }
1642 Fl::unlock();} {}
1643 }
1644
1645 Function {x11_ui::alert(sfinx_string_t *alert)} {return_type void
1646 } {
1647   code {Fl::lock();
1648 if (alert->size() != 1)
1649         fl_alert(alert->c_str());
1650 Fl::unlock();} {}
1651 }
1652
1653 Function {x11_ui::notes_module_edit(sfinx_note_t *n)} {open return_type void
1654 } {
1655   code {Fl::lock();
1656 sfinx_note_t *note = new sfinx_note_t;
1657 note->copy(n);
1658 note->tid(SFINX_NOTES_MODULE_EDIT);
1659 edit_note_w->user_data((void *)note);
1660 char buf[256];
1661 int eyear, emonth, eday, ehour, emin, esec, cyear, cmonth, cday, chour, cmin, csec;
1662 note->etime.GetDate(eyear, emonth, eday);
1663 note->etime.GetTime(ehour, emin, esec);
1664 note->ctime.GetDate(cyear, cmonth, cday);
1665 note->ctime.GetTime(chour, cmin, csec);
1666 sprintf(buf, "Modified: %02d/%02d/%04d %02d:%02d:%02d | Last Status Changed: %02d/%02d/%04d %02d:%02d:%02d", cday, cmonth, cyear,
1667         chour, cmin, csec, eday, emonth, eyear, ehour, emin, esec);
1668 edit_note_to->value(buf);
1669 note_name_i->value(note->name.c_str());
1670 note_name_i->take_focus();
1671 note_url_i->value(note->url.c_str());
1672 note_text_i->value(note->text.c_str());
1673 // main tag
1674 note_mtag_b->user_data(&(note->mtag));
1675 note_mtag_b->copy_label((note->mtag.name + " [ " + note->mtag.description + " ]").c_str());
1676 note_mtag_b->redraw();
1677 // add tags
1678 note_tags_br->clear();
1679 for (u32_t i = 0; i < note->tags.size(); i++) {
1680         string s = note->tags[i].name + " [ " + note->tags[i].description + " ]";
1681         note_tags_br->add(s.c_str(), &(note->tags[i]));
1682 }
1683 edit_note_w->show();
1684 Fl::unlock();} {}
1685 }
1686
1687 Function {x11_ui::notes_module_reply(sfinx_string_t *classify_error)} {open return_type void
1688 } {
1689   code {Fl::lock();
1690 if (classify_error->size() == 1) {
1691         ::fill_objects_tree(notes_tree, 1 << SFINX_NOTE_OBJECT, 0, 1); // fluid bugs if any default params exists !
1692         edit_note_w->hide();
1693 } else
1694         fl_alert(classify_error->c_str());
1695 Fl::unlock();} {}
1696 }
1697
1698 Function {x11_ui::files_module_edit_reply(sfinx_string_t *classify_error)} {open return_type void
1699 } {
1700   code {Fl::lock();
1701 if (classify_error->size() == 1) {
1702         app->sfinx.send(current_files_module_tree_path);
1703         classify_file_w->hide();
1704 } else
1705         fl_alert(classify_error->c_str());
1706 Fl::unlock();} {}
1707 }
1708
1709 Function {x11_ui::files_module_edit(sfinx_file_t *f)} {open return_type void
1710 } {
1711   code {Fl::lock();
1712 static sfinx_file_t file;
1713 file.copy(f);
1714 char buf[256];
1715 int eyear, emonth, eday, ehour, emin, esec, cyear, cmonth, cday, chour, cmin, csec;
1716 file.etime.GetDate(eyear, emonth, eday);
1717 file.etime.GetTime(ehour, emin, esec);
1718 file.ctime.GetDate(cyear, cmonth, cday);
1719 file.ctime.GetTime(chour, cmin, csec);
1720 sprintf(buf, "%llu bytes | Modified: %02d/%02d/%04d %02d:%02d:%02d | Last Status Changed: %02d/%02d/%04d %02d:%02d:%02d", file.fsize, cday, cmonth, cyear,
1721         chour, cmin, csec, eday, emonth, eyear, ehour, emin, esec);
1722 string path;
1723 if (current_files_module_tree_path.tid() == SFINX_FILES_MODULE_UNSORTED_TREE_REQUEST)
1724         app->files_module_conf.get(FILES_MODULE_UNSORTED_PATH, path);
1725 else
1726         app->files_module_conf.get(FILES_MODULE_SORTED_TREE_PATH, path);
1727 string t = "URL: " + path + current_files_module_tree_path.name + "/" + file.name + " | " + file.mimetype + " | Size: " + buf;
1728 classify_file_to->value(t.c_str());
1729 file_title_i->value(file.title.c_str());
1730 file_name_i->value(file.name.c_str());
1731 // save orig file name
1732 file.orig_name = file.name;
1733 file.tid(SFINX_FILES_MODULE_EDIT_FILE); // edit file
1734 file_title_i->take_focus();
1735 file_authority_i->value(file.authority.c_str());
1736 file_description_i->value(file.description.c_str());
1737 file_comments_i->value(file.comments.c_str());
1738 sorted_location_b->value(file.sorted_location);
1739 file_compress_b->value(file.store_compressed);
1740 file_gen_csum_b->value(file.generate_csum);
1741 static string main_slice_name;
1742 main_slice_name = app->slice_name(file.mtag_id);
1743 file_main_slice_b->label(main_slice_name.c_str());
1744 file_main_slice_b->user_data(to_voidp(file.mtag_id)); // ÔÕÔÁ ÈÒÁÎÉÔÓÑ mtag_slice_id
1745 file_additional_slices_br->clear();
1746 //for (u32_t i = 0; i < file.objects.size(); i++)
1747 //      file_additional_slices_br->add((app->slice_name(file.objects[i]).c_str()), to_voidp(file.objects[i]));
1748 classify_file_w->user_data((void *)&file);
1749 classify_file_w->show();
1750 Fl::unlock();} {}
1751 }
1752
1753 Function {x11_ui::search_browser(sfinx_pair_vector_t *r)} {return_type void
1754 } {
1755   code {Fl::lock();
1756 search_browser_br->clear();
1757 if (!r->len()) {
1758         search_browser_br->add("Sfinx has no data for this query");
1759         goto out;
1760 }
1761 goto_page_ch->clear();
1762 /*for (u32_t i = 1; i < 50; i++) {
1763         char b[32];
1764         sprintf(b, "%d", i);
1765         goto_page_ch->add(b, 0, 0, (void *)i);
1766 //      Fl_Menu_Item *item = (Fl_Menu_Item *)(goto_page_ch->menu() + n);
1767 //      item->color(FL_GREEN);
1768 } */
1769 goto_page_ch->value(0);
1770 //goto_page_ch->selection_color(FL_GREEN);
1771
1772 // fill browser
1773 for (u32_t i = 0; i < r->len(); i++) {
1774         sfinx_pair_t *p = r->find(i);
1775         if (!p)
1776                 bug();
1777         sfinx_t *el;
1778         if (!p->get(i, &el))
1779                 bug();
1780         // adding element
1781         string inf;
1782         prepare_search_info(el, inf);
1783         string::size_type pos = 0, found;
1784         while ((found = inf.find('\\n', pos)) != string::npos) {
1785                 string line(inf, pos, found - pos);
1786                 search_browser_br->add(line.c_str());
1787                 pos = found + 1;
1788         }
1789         search_browser_br->add("@-");
1790 }
1791 out:
1792 search_browser_w->show();
1793 Fl::unlock();} {}
1794 }
1795
1796 Function {x11_ui::prepare_search_info(sfinx_t *el, string &inf)} {return_type void
1797 } {
1798   code {sfinx_file_t *f;
1799 switch (el->tid()) {
1800       case SFINX_ELEMENT_FILE:
1801         f = (sfinx_file_t *)el;
1802         inf = "\\nType: File\\n";
1803         inf.append("Slice Hierarchy: " + app->slice_hierarchy(f->mtag_id) + "\\n");
1804 /*        if (f->slices.size()) {
1805           inf.append("Additional Slices : ");
1806           for (u32_t i = 0; i < f->slices.size(); i++) {
1807             if (i)
1808               inf.append(", ");
1809             inf.append(app->slice_name(f->slices[i]));
1810          }
1811           inf.append("\\n");
1812        }*/
1813         inf.append("Title: " + f->title + "\\n");
1814         inf.append("Authority: " + f->authority + "\\n");
1815         inf.append("Description: " + f->description + "\\n");
1816         inf.append("Comments: " + f->comments + "\\n");
1817         inf.append("Name: " + f->name + "\\n");
1818         char buf[64];
1819         sprintf(buf, "%llu bytes\\n", f->fsize);
1820         inf.append("Size: ");
1821         inf.append(buf);
1822         if (f->csum.size())
1823                 inf.append("Csum: " + f->csum + "\\n");
1824         sprintf(buf, "%llu bytes\\n", f->compressed_fsize);
1825         inf.append("Compressed Size: ");
1826         inf.append(buf);
1827         if (f->compressed_csum.size())
1828                 inf.append("Compressed Csum: " + f->compressed_csum + "\\n");
1829         int year, month, day, hour, min, sec;
1830         f->ctime.GetDate(year, month, day);
1831         f->ctime.GetTime(hour, min, sec);
1832         sprintf(buf, "Create Entry Time: %02d/%02d/%04d %02d:%02d:%02d\\n", day, month, year, hour, min, sec);
1833         inf.append(buf);
1834         f->etime.GetDate(year, month, day);
1835         f->etime.GetTime(hour, min, sec);
1836         sprintf(buf, "Edit Entry Time: %02d/%02d/%04d %02d:%02d:%02d\\n", day, month, year, hour, min, sec);
1837         inf.append(buf);
1838         inf.append("\\n");
1839         break;
1840       default:
1841         debug("Can't fill element info !");
1842         bug();
1843 }} {}
1844 }
1845
1846 Function {x11_ui::fill_objects_tree()} {open return_type void
1847 } {
1848   code {Fl::lock();
1849 Fl_Toggle_Tree *tree = fill_tree;
1850 u32_t mask = fill_tree_mask;
1851 if (!tree) {
1852  tree = slices_tree;
1853  mask = SFINX_SLICE_OBJECT;
1854 }
1855 tree->clear();
1856 tree->draw_lines(1);
1857 tree->alternate_color(FL_LIGHT2);
1858 tree->trim_color(FL_LIGHT1);
1859 tree->edit_on_reselect(0);
1860 sfinx_slice_t *slice;
1861 Fl_Toggle_Node *node;
1862 u32_t max_name_len = 0;
1863 for (u32_t i = 0; i < app->slices.len(); i++) {
1864         slice = app->slices.get(i);
1865         if (slice == fill_tree_except)
1866                 continue;
1867         //debug("slice name - %s, id - %lld, parent_id - %lld", slice->name(), slice->id, slice->parent_id);
1868         string name = slice->name() + string(" [ ") +
1869                 slice->description() + string(" ]");
1870         // replace \\n with spaces
1871         string filt_elems( "\\n");
1872         string::size_type pos = 0;
1873         while (( pos = name.find_first_of(filt_elems, pos)) != string::npos)
1874                 name.replace(pos, 1, string(" "));
1875         if (name.size() > max_name_len)
1876                 max_name_len = name.size();
1877         if (!slice->parent_id) {
1878                 node = tree->add_sub((char *)name.c_str(), 1, &slice_pixmap, to_voidp(slice));
1879                 if (fill_tree_mask & (1 << SFINX_NOTE_OBJECT)) {
1880                         tree->open(node);
1881                         // add notes
1882                         for (u32_t x = 0; x < slice->objs.size(); x++) {
1883                                 tree->add_sub((char *)(slice->objs[x].name + slice->objs[x].description).c_str(), 0, &note_pixmap,
1884                                         to_voidp(&(slice->objs[x])));
1885                                 tree->traverse_up();
1886                         }
1887                 }
1888         } else {
1889                 node = tree->traverse_start();
1890                 while (node) {
1891                         sfinx_slice_t *s = (sfinx_slice_t *) node->user_data();
1892                         if (s->id == slice->parent_id)
1893                                 break;
1894                         node = tree->traverse_forward();
1895                 }
1896                 if (node) {
1897                         tree->open(node);
1898                         node = tree->add_sub((char *)name.c_str(), 1, &slice_pixmap, to_voidp(slice));
1899                         if (fill_tree_mask & (1 << SFINX_NOTE_OBJECT)) {
1900                                 tree->open(node);
1901                                 // add notes
1902                                 for (u32_t x = 0; x < slice->objs.size(); x++) {
1903                                         tree->add_sub((char *)(slice->objs[x].name + slice->objs[x].description).c_str(), 0, &note_pixmap,
1904                                                 to_voidp(&(slice->objs[x])));
1905                                         tree->traverse_up();
1906                                 }
1907                         }
1908                 } // node not found - just ignore
1909         }
1910 }
1911 s32_t width = max_name_len * 8;
1912 // need to count depth for width update
1913 Fl_Scroll_Resize *tree_scroll = (Fl_Scroll_Resize *) tree->user_data();
1914 if (!tree_scroll) // he, forgot to set ;)
1915         bug();
1916 tree->resize(tree->x(), tree->y(), width > tree_scroll->w() ? width : tree_scroll->w(), tree->h());
1917 // try to select previous node
1918 //node = slices_tree->find(to_voidp(current_slice_id));
1919 //if (node)
1920 //      slices_tree->select_range(node, node);
1921 Fl::unlock();} {}
1922 }