/*############################## init_text() ############################*/
void
init_text(void)
{
wpr_position = 0;
XmTextSetString(log_output, NULL);
XmTextSetInsertionPosition(log_output, 0);
if (current_log_number == -1)
{
int i;
char log_file[MAX_PATH_LENGTH];
for (i = max_log_number; i >= 0; i--)
{
if (p_log_file != NULL)
{
(void)fclose(p_log_file);
}
(void)sprintf(log_file, "%s/%s%d", log_dir, log_name, i);
if ((p_log_file = fopen(log_file, "r")) == NULL)
{
if (errno != ENOENT)
{
(void)xrec(FATAL_DIALOG, "Could not fopen() %s : %s (%s %d)",
log_file, strerror(errno), __FILE__, __LINE__);
return;
}
}
else
{
read_text();
if ((log_type_flag != TRANSFER_LOG_TYPE) &&
(log_type_flag != RECEIVE_LOG_TYPE) &&
(i == 0))
{
struct stat stat_buf;
if (fstat(fileno(p_log_file), &stat_buf) == -1)
{
(void)fprintf(stderr,
"ERROR : Could not fstat() %s : %s (%s %d)\n",
log_file, strerror(errno), __FILE__, __LINE__);
exit(INCORRECT);
}
current_inode_no = stat_buf.st_ino;
}
}
}
}
else
{
read_text();
}
XmTextShowPosition(log_output, wpr_position);
return;
}
static BOOL OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
HINSTANCE hInstance = lpCreateStruct->hInstance;
hwnd_main=hwnd;
hmenu_main=AtlLoadMenu(IDR_MENU1);
hmenu_main=GetSubMenu(hmenu_main,0);
config_read();
CWindow wnd(hwnd);
wnd.ModifyStyle(WS_CAPTION, 0);
wnd.SetWindowPos(nullptr, 0,0, 0,0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_DRAWFRAME|SWP_NOACTIVATE);
wnd.SetWindowPos(nullptr, config_x, config_y, config_w, config_h, SWP_NOACTIVATE|SWP_NOZORDER);
systray_add(hwnd,1024,AtlLoadIcon(IDI_ICON1),app_name);
hwnd_rich=CreateWindowEx(WS_EX_CLIENTEDGE,"RichEdit","",
WS_CHILD|WS_VISIBLE|ES_MULTILINE|ES_AUTOVSCROLL|ES_AUTOHSCROLL|WS_HSCROLL|WS_VSCROLL,
config_border,config_border,config_w-config_border*2,config_h-config_border*2,
hwnd, NULL,hInstance,NULL);
CWindow wnd_rich{hwnd_rich};
Rich_OldWndProc = (WNDPROC) wnd_rich.GetWindowLongPtr(GWLP_WNDPROC);
wnd_rich.SetWindowLongPtr(GWLP_WNDPROC,(LONG_PTR)Rich_WndProc);
if (!hwnd_rich)
{
wnd.MessageBox("Error creating RichEdit control","Error",MB_OK);
return 0;
}
wnd_rich.SendMessage(EM_SETBKGNDCOLOR,FALSE,static_cast<LPARAM>(config_color));
read_text();
return 1;
}
int main(int argc, char **argv) {
static struct gengetopt_args_info args_info;
assert(cmdline_parser(argc, argv, &args_info) == 0);
char* pattern = args_info.pattern_orig;
char* text = read_text(args_info.text_arg);
uint32_t n = strlen(text);
uint32_t m = strlen(pattern);
/* occ[] stores if a position is an occurrence */
uint32_t* occ = calloc(n, sizeof(*occ));
assert(occ != NULL);
/* Initialize random number generator */
gsl_rng *rng = gsl_rng_alloc(gsl_rng_mt19937);
uint32_t num_rounds = (size_t) args_info.rounds_arg;
for (size_t i = 0; i < num_rounds; i++) {
uint32_t mod = random_prime(rng);
for (size_t j = 0; j < m; j++)
for (size_t c = 0; c < 4; c++)
corrections[c] = (j == 0) ? c : (corrections[c] << 2) % mod;
uint32_t pattern_h = init_h(pattern, m, mod);
uint32_t pos = m;
for (uint32_t text_h = init_h(text, m, mod); pos < n;
text_h = next_h(text_h, text[pos - m], text[pos], mod), pos++)
if (pattern_h == text_h)
occ[pos - m]++;
}
for (uint32_t pos = 0; pos < n; pos++)
if (occ[pos] >= num_rounds) {
char* x = strndupa(text + pos, m);
printf("Occurrence %s at position %d\n", x, pos);
}
free(occ);
}
static BOOL OnCreate(HWND hwnd, LPCREATESTRUCT lpCreateStruct)
{
hwnd_main=hwnd;
hmenu_main=LoadMenu(hMainInstance,MAKEINTRESOURCE(IDR_MENU1));
hmenu_main=GetSubMenu(hmenu_main,0);
config_read();
SetWindowLong(hwnd,GWL_STYLE,GetWindowLong(hwnd,GWL_STYLE)&~(WS_CAPTION));
SetWindowPos(hwnd, 0, 0,0, 0,0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_DRAWFRAME|SWP_NOACTIVATE);
SetWindowPos(hwnd, 0, config_x, config_y, config_w, config_h, SWP_NOACTIVATE|SWP_NOZORDER);
systray_add(hwnd,1024,LoadIcon(hMainInstance,MAKEINTRESOURCE(iconRes)),app_name);
hwnd_rich=CreateWindowEx(WS_EX_CLIENTEDGE,"RichEdit","",
WS_CHILD|WS_VISIBLE|ES_MULTILINE|ES_AUTOVSCROLL|WS_VSCROLL, //WS_HSCROLL|ES_AUTOHSCROLL|
config_border,config_topborder,config_w-config_border*2,config_h-(config_border+config_topborder),
hwnd, NULL,hMainInstance,NULL);
Rich_OldWndProc = (WNDPROC) GetWindowLong(hwnd_rich,GWL_WNDPROC);
SetWindowLong(hwnd_rich,GWL_WNDPROC,(int)Rich_WndProc);
if (!hwnd_rich)
{
MessageBox(hwnd,"Error creating RichEdit control","Error",MB_OK);
return 0;
}
SendMessage(hwnd_rich,EM_SETBKGNDCOLOR,FALSE,config_color);
read_text();
return 1;
}
int cg_find_unified_root(char *root, size_t len)
{
char buf[10 * PAGE_SIZE];
char *fs, *mount, *type;
const char delim[] = "\n\t ";
if (read_text("/proc/self/mounts", buf, sizeof(buf)) <= 0)
return -1;
/*
* Example:
* cgroup /sys/fs/cgroup cgroup2 rw,seclabel,noexec,relatime 0 0
*/
for (fs = strtok(buf, delim); fs; fs = strtok(NULL, delim)) {
mount = strtok(NULL, delim);
type = strtok(NULL, delim);
strtok(NULL, delim);
strtok(NULL, delim);
strtok(NULL, delim);
if (strcmp(fs, "cgroup") == 0 &&
strcmp(type, "cgroup2") == 0) {
strncpy(root, mount, len);
return 0;
}
}
return -1;
}
void read_ant_info_record(int *bytes_read = NULL, int *sum = NULL)
{
for (int i = 0; i < 6; i++) {
int device_type = read_bytes(1, bytes_read, sum);
if (device_type < 255) {
QString text = read_text(20, bytes_read, sum);
for(int i=0; i < text.length(); i++)
{
if (text.at(i) == QChar(0))
text = text.left(i);
}
//while (text.endsWith( QChar(0) )) text.chop(1);
read_bytes(1, bytes_read, sum); // flag
uint16_t id = read_bytes(2, bytes_read, sum);
read_bytes(2, bytes_read, sum);
read_bytes(2, bytes_read, sum);
QString device_type_str;
if (device_type == 11)
device_type_str = "Primary Power Id";
else if (device_type == 120)
device_type_str = "Chest strap Id";
else
device_type_str = QString("ANT %1 Id").arg(device_type);
deviceInfo += QString("%1 %2 %3\n").arg(device_type_str).arg(id).arg(text);
}
}
}
int cg_read(const char *cgroup, const char *control, char *buf, size_t len)
{
char path[PATH_MAX];
snprintf(path, sizeof(path), "%s/%s", cgroup, control);
if (read_text(path, buf, len) >= 0)
return 0;
return -1;
}
/*
* On entry change
* Signal handler for view "cursor-changed" event
* Called from create_entry in entry.c
* Called from rename_entry in entry.c
*/
void on_entry_change(GtkTreeView *entry_view, gpointer data)
{
book_data *book = NULL;
section_data *section = NULL;
entry_data *entry = NULL;
GtkTreeSelection *selection = NULL;
GtkTreeModel *entry_model = NULL;
GtkTreeIter tree_iter;
// Get book from data
book = (book_data*)data;
if(book == NULL) {
sn_warning("No current book in %s.", __func__);
return;
}
// Write text of previous entry
write_current_entry();
// Get selected entry
selection = gtk_tree_view_get_selection(entry_view);
if(gtk_tree_selection_get_selected(selection, &entry_model, &tree_iter)) {
gtk_tree_model_get(entry_model, &tree_iter, ENTRY_ITEM, &entry, END_OF_LIST);
if(entry != NULL) {
// Get entrys parent section
section = entry->parent_section;
// Set current entry in section
sn_trace("* Selecting entry [%s/%s] in %s.",
section->name, entry->name, __func__);
if(section->curr_entry_path != NULL)
gtk_tree_path_free(section->curr_entry_path);
section->curr_entry_path = gtk_tree_model_get_path(entry_model, &tree_iter);
section->curr_entry = entry;
// Read text of current entry
sn_trace("> Reading current entry [%s/%s] in %s.",
section->name, entry->name, __func__);
read_text(book, entry);
// Add history
if(book->add_history) {
add_history();
}
book->add_history = FALSE;
}
}
gtk_widget_grab_focus(GTK_WIDGET(entry_view));
return;
} // On entry change
void add_text_to_book(char *filename,int odst)
{
FILE *txt;
ENCFILE fl;
set_font(H_FKNIHA,NOSHADOW(0));
if (all_text == NULL) all_text = create_list(256);
txt = enc_open(filename,&fl);
if (txt == NULL) return;
seek_section(txt,odst);
read_text(txt);
next_line(1000);
enc_close(&fl);
}
/*Reads informations from txt file and writes them to binary file*/
void Into_Binary(FILE *text_input, FILE *binary_output)
{
Row table[TABLE_SIZE]; /*Table array*/
int location=0; /*Location information in the array*/
int read=10; /*For row control*/
while(read==10){
/*Reads maximum 10 row from text file*/
read=read_text(text_input,&table[location]);
/*Writes table to binary file*/
fwrite(&table[location], sizeof(table[0]), read, binary_output);
location+=read;
}
}
int is_swap_enabled(void)
{
char buf[PAGE_SIZE];
const char delim[] = "\n";
int cnt = 0;
char *line;
if (read_text("/proc/swaps", buf, sizeof(buf)) <= 0)
return -1;
for (line = strtok(buf, delim); line; line = strtok(NULL, delim))
cnt++;
return cnt > 1;
}
int main (){
std::ifstream rFile("1-string-stream.txt");
std::map<std::string,int> word_count;
std::set<std::string> exclude_word = {"a","an","the","The","or","of","on","On"};
read_text(rFile, word_count, exclude_word);
std::ofstream wFile("output.txt");
display(word_count, wFile);
return 0;
}
void assim(Store& s, char* store_fname, char* text_fname, int order){
s.open(store_fname);
order++;
if (!s.is_init()){
wcerr << "Store is not initialized, initializing..." << endl;
s.init();
wcerr << "Store initialized!" << endl;
}
string txt = read_text(text_fname);
#ifndef CHARS
assimilate_text(txt, s, order);
#else
assimilate_text_chars(txt, s, order);
#endif
s.close(store_fname);
}
void std_input(char *title, char *text, char *txt_cancel)
{
int x, y, w, h ;
int button ;
if ( stdinput == NULL ) stdinput_fix() ;
if ( txt_cancel != NULL ) strcpy( stdinput[INPUT_CANCEL].ob_spec.free_string, txt_cancel ) ;
write_text(stdinput, INPUT_TEXT, "") ;
write_text(stdinput, INPUT_TITLE, title) ;
form_center(stdinput, &x, &y, &w, &h) ;
form_dial(0, x, y, w, h, x, y, w, h) ;
objc_draw(stdinput, 0, 200, x, y, w, h) ;
button = form_do(stdinput, INPUT_TEXT) ;
deselect(stdinput, button) ;
form_dial(3, x, y, w, h, x, y, w, h) ;
if (button == INPUT_OK) read_text(stdinput, INPUT_TEXT, text) ;
else text[0] = 0 ;
}
struct rlib_report_lines * read_line(gchar **ptr) {
struct rlib_report_lines *rl = g_malloc(sizeof(struct rlib_report_lines));
gint32 *type;
gpointer pointer = NULL;
struct rlib_element *current;
rl->xml_bgcolor.xml = (xmlChar *)read_xml_str(ptr);
rl->xml_color.xml = (xmlChar *)read_xml_str(ptr);
rl->xml_font_size.xml = (xmlChar *)read_xml_str(ptr);
rl->xml_suppress.xml = (xmlChar *)read_xml_str(ptr);
rl->e = NULL;
type = (gint32 *)*ptr;
if(*type == RLIB_FILE_LINE) {
*ptr += sizeof(gint32);
while(1) {
type = (gint32 *)*ptr;
if(*type == RLIB_FILE_LINE)
break;
if(*type == RLIB_ELEMENT_FIELD)
pointer = read_field(ptr);
if(*type == RLIB_ELEMENT_LITERAL)
pointer = read_text(ptr);
if(*type == RLIB_ELEMENT_FIELD || *type == RLIB_ELEMENT_LITERAL) {
if(rl->e == NULL) {
rl->e = g_malloc(sizeof(struct rlib_element));
current = rl->e;
} else {
struct rlib_element *e;
for(e=rl->e;e->next != NULL;e=e->next);
e->next = g_malloc(sizeof(struct rlib_element));
current = e->next;
}
current->data = pointer;
current->type = *type;
current->next = NULL;
}
}
*ptr += sizeof(gint32);
}
return rl;
}
int main(int argc, char *argv[]) {
Params params;
struct timeval startTime, endTime;
double total_time;
long total_bytes;
initCL(¶ms);
parseCL(¶ms, &argc, &argv);
validateCL(¶ms);
gettimeofday(&startTime, NULL);
if (params.buffer > 0) {
if (strncmp(params.mode, "text", 6) == 0) {
read_text_buffered(params.file, params.buffer);
} else if (strncmp(params.mode, "binary", 6) == 0) {
read_binary_buffered(params.file, params.buffer);
} else if (strncmp(params.mode, "hdf5", 4) == 0) {
read_hdf5_buffered(params.file, params.buffer);
} else {
errx(EXIT_FAILURE, "unknown mode '%s' for buffered",
params.mode);
}
} else {
if (strncmp(params.mode, "text", 4) == 0) {
read_text(params.file);
} else if (strncmp(params.mode, "binary", 6) == 0) {
read_binary(params.file);
} else if (strncmp(params.mode, "hdf5", 4) == 0) {
read_hdf5(params.file);
} else {
errx(EXIT_FAILURE, "unknown mode '%s' for unbuffered I/O",
params.mode);
}
}
gettimeofday(&endTime, NULL);
total_time = endTime.tv_sec - startTime.tv_sec +
(endTime.tv_usec - startTime.tv_usec)*1e-6;
total_bytes = get_size(params.file);
printf("%s\t%ld\t%d\t%.6f\n", params.file, total_bytes, params.buffer,
total_time);
finalizeCL(¶ms);
return EXIT_SUCCESS;
}
std::vector<task> read_tasks(const assignment& asst, const std::string& comment) {
namespace balg = boost::algorithm;
std::vector<task> tasks;
std::ostringstream ostream;
ostream << comment << '\n';
for(const auto& x : asst.point_map()) {
ostream << x.first << ": ;; #max = " << x.second << '\n';
}
std::istringstream istream{read_text(ostream.str())};
bool valid_line;
std::string line;
auto enforce = [&](bool b) {
if(!b) {
throw std::runtime_error{"invlid line in task-configuration: " + line};
}
};
while(true) {
std::tie(valid_line, line) = next_line(istream);
if(!valid_line) {
break;
}
std::istringstream line_stream{line};
std::string task_id;
enforce(std::getline(line_stream, task_id, ':'));
balg::trim_right(task_id);
std::string points_str;
enforce(std::getline(line_stream, points_str, ';'));
balg::trim(points_str);
auto points = std::stoul(points_str);
std::string comment;
enforce(std::getline(line_stream, comment, ';'));
balg::trim(comment);
tasks.emplace_back(task_id, points, comment);
}
return tasks;
}
int OnObjectNotifyJpeg(void *w, int obj)
{
GEM_WINDOW *wnd = (GEM_WINDOW *) w ;
WEXTENSION_JPEG *wext = wnd->DlgData->UserData ;
OBJECT *adr_jpeg = wnd->DlgData->BaseObject ;
int code = -1 ;
char buf[10] ;
switch( obj )
{
case JPEG_OK : code = IDOK ;
break ;
case JPEG_CANCEL : code = IDCANCEL ;
break ;
}
if ( code == IDOK )
{
read_text( adr_jpeg, JPEG_QUALITY, buf ) ;
wext->inf->quality = atoi( buf ) ;
}
return( code ) ;
}
/*
* Populate entries
* Called from populate_sections in section.c
* Called from on_section_change in section.c
* Called from create_entry in entry.c
*/
gboolean populate_entries(book_data *book, section_data *section)
{
GtkTreeModel *entry_model = NULL;
GtkTreeView *entry_view = NULL;
GtkTreeSelection *selection = NULL;
GtkTreeIter tree_iter;
entry_data *entry = NULL;
// Get entry view
entry_view = get_entry_view(book);
// Create new entry model
entry_model = create_entry_model(section);
// Set entry model on entry view
gtk_tree_view_set_model(entry_view, entry_model);
// Does the section have entries?
if(section->entry_list != NULL) {
// Get current entry in section
if(section->curr_entry != NULL) {
entry = section->curr_entry;
gtk_tree_model_get_iter(entry_model, &tree_iter, section->curr_entry_path);
} else {
entry = section->entry_list->data;
gtk_tree_model_get_iter_first (entry_model, &tree_iter);
}
// Set current entry in section
selection = gtk_tree_view_get_selection(entry_view);
gtk_tree_selection_select_iter(selection, &tree_iter);
if(section->curr_entry_path != NULL)
gtk_tree_path_free(section->curr_entry_path);
section->curr_entry_path = gtk_tree_model_get_path(entry_model, &tree_iter);
section->curr_entry = entry;
sn_trace("* Selectiong entry [%s/%s] in %s.",
section->name, entry->name, __func__);
} else {
// Set current entry in section
if(section->curr_entry_path != NULL)
gtk_tree_path_free(section->curr_entry_path);
section->curr_entry_path = NULL;
section->curr_entry = NULL;
sn_trace("* Selecting entry [(null)] in %s.", __func__);
}
// Read text of current entry
sn_trace("> Reading current entry [%s/%s] in %s.",
section->name, entry->name, __func__);
read_text(book, entry);
if (entry_model != NULL)
g_object_unref(entry_model);
return TRUE;
} // Populate entries
/* Entered after the '<' and the first character after that. Returns status
* code.
*/
static void
read_element(PInfo pi) {
struct _Attr attrs[MAX_ATTRS];
Attr ap = attrs;
char *name;
char *ename;
char *end;
char c;
long elen;
int hasChildren = 0;
int done = 0;
ename = read_name_token(pi);
end = pi->s;
elen = end - ename;
next_non_white(pi);
c = *pi->s;
*end = '\0';
if ('/' == c) {
/* empty element, no attributes and no children */
pi->s++;
if ('>' != *pi->s) {
//printf("*** '%s' ***\n", pi->s);
raise_error("invalid format, element not closed", pi->str, pi->s);
}
pi->s++; /* past > */
ap->name = 0;
pi->pcb->add_element(pi, ename, attrs, hasChildren);
pi->pcb->end_element(pi, ename);
return;
}
/* read attribute names until the close (/ or >) is reached */
while (!done) {
if ('\0' == c) {
next_non_white(pi);
c = *pi->s;
}
switch (c) {
case '\0':
raise_error("invalid format, document not terminated", pi->str, pi->s);
case '/':
// Element with just attributes.
pi->s++;
if ('>' != *pi->s) {
raise_error("invalid format, element not closed", pi->str, pi->s);
}
pi->s++;
ap->name = 0;
pi->pcb->add_element(pi, ename, attrs, hasChildren);
pi->pcb->end_element(pi, ename);
return;
case '>':
// has either children or a value
pi->s++;
hasChildren = 1;
done = 1;
ap->name = 0;
pi->pcb->add_element(pi, ename, attrs, hasChildren);
break;
default:
// Attribute name so it's an element and the attribute will be
// added to it.
ap->name = read_name_token(pi);
end = pi->s;
next_non_white(pi);
if ('=' != *pi->s++) {
raise_error("invalid format, no attribute value", pi->str, pi->s);
}
*end = '\0'; // terminate name
// read value
next_non_white(pi);
ap->value = read_quoted_value(pi);
if (0 != strchr(ap->value, '&')) {
if (0 != collapse_special((char*)ap->value)) {
raise_error("invalid format, special character does not end with a semicolon", pi->str, pi->s);
}
}
ap++;
if (MAX_ATTRS <= (ap - attrs)) {
raise_error("too many attributes", pi->str, pi->s);
}
break;
}
c = '\0';
}
if (hasChildren) {
char *start;
done = 0;
// read children
while (!done) {
start = pi->s;
next_non_white(pi);
c = *pi->s++;
if ('\0' == c) {
raise_error("invalid format, document not terminated", pi->str, pi->s);
}
if ('<' == c) {
switch (*pi->s) {
case '!': /* better be a comment or CDATA */
pi->s++;
if ('-' == *pi->s && '-' == *(pi->s + 1)) {
pi->s += 2;
read_comment(pi);
} else if (0 == strncmp("[CDATA[", pi->s, 7)) {
pi->s += 7;
read_cdata(pi);
} else {
raise_error("invalid format, invalid comment or CDATA format", pi->str, pi->s);
}
break;
case '/':
pi->s++;
name = read_name_token(pi);
end = pi->s;
next_non_white(pi);
c = *pi->s;
*end = '\0';
if (0 != strcmp(name, ename)) {
raise_error("invalid format, elements overlap", pi->str, pi->s);
}
if ('>' != c) {
raise_error("invalid format, element not closed", pi->str, pi->s);
}
pi->s++;
pi->pcb->end_element(pi, ename);
return;
case '\0':
raise_error("invalid format, document not terminated", pi->str, pi->s);
default:
// a child element
read_element(pi);
break;
}
} else { // read as TEXT
pi->s = start;
//pi->s--;
read_text(pi);
//read_reduced_text(pi);
// to exit read_text with no errors the next character must be <
if ('/' == *(pi->s + 1) &&
0 == strncmp(ename, pi->s + 2, elen) &&
'>' == *(pi->s + elen + 2)) {
// close tag after text so treat as a value
pi->s += elen + 3;
pi->pcb->end_element(pi, ename);
return;
}
}
}
}
}
int main(int argc, char **argv)
{
uint8_t codelen[128];
struct Histogram32 h32;
struct Codebook cb;
struct Encoder enc;
struct Tree tree;
FILE *fout;
int i,L;
if(argc == 1) L = 16;
//else if(argv == 2) L = atoi(argv[1]);
else {
fprintf(stderr,"Usage: %s\n", argv[0]);
fprintf(stderr,"\treads input data from stdin, compresses it using\n");
fprintf(stderr,"\tlength-restricted canonical huffman codes and writes\n");
fprintf(stderr,"\tthe result to 'enc.out'.\n");
exit(1);
}
read_text(stdin);
histogram32_init(&h32);
histogram32_add(&h32, buffer, buffer_fill);
package_merge(&h32, L, codelen);
//printf("final codelengths:\n");
//codelen_dump(codelen, stdout);
fprintf(stderr,"weight of huffman tree = %f\n", weight_of_tree(codelen));
fprintf(stderr,"compression factor = %.11f\n",compr_factor(buffer,buffer_fill,codelen));
ctree_create(&tree, codelen);
//tree_print_flat(&tree,stderr);
//ccodebook_create(&cb, codelen);
codebook_create(&cb,&tree);
//codebook_print(&cb,stderr);
encoder_init(&enc, &cb);
fout = fopen("enc.out","w");
fwrite(&buffer_fill,4,1,fout);
fwrite(codelen,128,1,fout);
for(i = 0; i < buffer_fill; i++) {
int c;
//fprintf(stderr,"byte %d of %d\n",i,buffer_fill);
encoder_put_symbol(&enc, buffer[i]);
while((c = encoder_get_byte(&enc)) != ENCODER_NEED_INPUT) {
uint8_t tmp = c;
fwrite(&tmp,1,1,fout);
}
}
i = encoder_get_last_byte(&enc);
if(i != ENCODER_NEED_INPUT) {
uint8_t tmp = i;
fwrite(&tmp,1,1,fout);
}
fclose(fout);
return 0;
}
int
main (int argc, char **argv)
{
int success = 1;
int verbose = 0; /* 1: verbose, 0 (or nothing: not verbose) */
int clone = 0; /* 1: verbose, 0 (or nothing: not verbose) */
int binary = 0;
FILE *torture_file;
char *msg;
int pos;
int len;
for (pos = 3; pos < argc; pos++) {
if (0 == strncmp (argv[pos], "-v", 2))
verbose = 1;
else if (0 == strncmp (argv[pos], "-c", 2))
clone = 1;
else if (0 == strncmp (argv[pos], "-b", 2))
binary = 1;
else
usage ();
}
if (argc < 3) {
usage ();
}
torture_file = fopen (argv[1], "r");
if (torture_file == NULL) {
usage ();
}
/* initialize parser */
parser_init ();
if (binary) {
if (read_binary (&msg, &len, torture_file) < 0)
return -1;
}
else {
msg = read_text (atoi (argv[2]), torture_file);
if (!msg)
return -1;
len = strlen (msg);
}
success = test_message (msg, len, verbose, clone);
if (verbose) {
fprintf (stdout, "test %s : ============================ \n", argv[2]);
fwrite (msg, 1, len, stdout);
if (0 == success)
fprintf (stdout, "test %s : ============================ OK\n", argv[2]);
else
fprintf (stdout, "test %s : ============================ FAILED\n", argv[2]);
}
osip_free (msg);
fclose (torture_file);
#ifdef __linux
if (success)
exit (EXIT_FAILURE);
else
exit (EXIT_SUCCESS);
#endif
return success;
}
int OnObjectNotifyPal(void *w, int obj)
{
GEM_WINDOW *wnd = (GEM_WINDOW *) w ;
WEXTENSION_PAL *wext = wnd->DlgData->UserData ;
OBJECT *adr_mkpal = wnd->DlgData->BaseObject ;
int off_x, off_y ;
int xm, ym, dummy ;
int pb_x, pb_y ;
int x1, y1, x2, y2 ;
int code = -1 ;
char buf[15] ;
graf_mkstate( &xm, &ym, &dummy, &dummy ) ;
switch( obj )
{
case MKPAL_MRED :
case MKPAL_PRED : if ( obj == MKPAL_PRED ) wext->curr_rgb[0]++ ;
else wext->curr_rgb[0]-- ;
if (wext->curr_rgb[0] < 1) wext->curr_rgb[0] = 1 ;
if (wext->curr_rgb[0] > 1000) wext->curr_rgb[0] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[0])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[0]) ;
write_text(adr_mkpal, MKPAL_TRED, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TRED ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_MGREEN :
case MKPAL_PGREEN : if ( obj == MKPAL_PGREEN ) wext->curr_rgb[1]++ ;
else wext->curr_rgb[1]-- ;
if (wext->curr_rgb[1] < 1) wext->curr_rgb[1] = 1 ;
if (wext->curr_rgb[1] > 1000) wext->curr_rgb[1] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[1])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[1]) ;
write_text(adr_mkpal, MKPAL_TGREEN, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TGREEN ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_MBLUE :
case MKPAL_PBLUE : if ( obj == MKPAL_PBLUE ) wext->curr_rgb[2]++ ;
else wext->curr_rgb[2]-- ;
if (wext->curr_rgb[2] < 1) wext->curr_rgb[2] = 1 ;
if (wext->curr_rgb[2] > 1000) wext->curr_rgb[2] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[2])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[2]) ;
write_text(adr_mkpal, MKPAL_TBLUE, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TBLUE ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_REDBOX :
objc_offset(adr_mkpal, MKPAL_RED, &off_x, &off_y) ;
if (ym > off_y) wext->curr_rgb[0] = wext->curr_rgb[0]-20 ;
else wext->curr_rgb[0] = wext->curr_rgb[0]+20 ;
if (wext->curr_rgb[0] < 1) wext->curr_rgb[0] = 1 ;
if (wext->curr_rgb[0] > 1000) wext->curr_rgb[0] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[0])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[0]) ;
write_text(adr_mkpal, MKPAL_TRED, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TRED ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_GREENBOX :
objc_offset(adr_mkpal, MKPAL_GREEN, &off_x, &off_y) ;
if (ym > off_y) wext->curr_rgb[1] = wext->curr_rgb[1]-20 ;
else wext->curr_rgb[1] = wext->curr_rgb[1]+20 ;
if (wext->curr_rgb[1] < 1) wext->curr_rgb[1] = 1 ;
if (wext->curr_rgb[1] > 1000) wext->curr_rgb[1] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[1])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[1]) ;
write_text(adr_mkpal, MKPAL_TGREEN, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TGREEN ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_BLUEBOX :
objc_offset(adr_mkpal, MKPAL_BLUE, &off_x, &off_y) ;
if (ym > off_y) wext->curr_rgb[2] = wext->curr_rgb[2]-20 ;
else wext->curr_rgb[2] = wext->curr_rgb[2]+20 ;
if (wext->curr_rgb[2] < 1) wext->curr_rgb[2] = 1 ;
if (wext->curr_rgb[2] > 1000) wext->curr_rgb[2] = 1000 ;
off_y = (int) ((1000-wext->curr_rgb[2])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
sprintf(buf, "%.4d", wext->curr_rgb[2]) ;
write_text(adr_mkpal, MKPAL_TBLUE, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TBLUE ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_RED : wext->curr_rgb[0] = (float) graf_slidebox(adr_mkpal, MKPAL_REDBOX, MKPAL_RED, 1) ;
off_y = (int) (wext->curr_rgb[0]*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
wext->curr_rgb[0] = 1000-wext->curr_rgb[0] ;
sprintf(buf, "%.4d", wext->curr_rgb[0]) ;
write_text(adr_mkpal, MKPAL_TRED, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TRED ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_GREEN : wext->curr_rgb[1] = (float) graf_slidebox(adr_mkpal, MKPAL_GREENBOX, MKPAL_GREEN, 1) ;
off_y = (int) (wext->curr_rgb[1]*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
wext->curr_rgb[1] = 1000-wext->curr_rgb[1] ;
sprintf(buf, "%.4d", wext->curr_rgb[1]) ;
write_text(adr_mkpal, MKPAL_TGREEN, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TGREEN ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_BLUE : wext->curr_rgb[2] = (float) graf_slidebox(adr_mkpal, MKPAL_BLUEBOX, MKPAL_BLUE, 1) ;
off_y = (int) (wext->curr_rgb[2]*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
wext->curr_rgb[2] = 1000-wext->curr_rgb[2] ;
sprintf(buf, "%.4d", wext->curr_rgb[2]) ;
write_text(adr_mkpal, MKPAL_TBLUE, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_TBLUE ) ;
vs_color(handle, wext->index, wext->curr_rgb) ;
break ;
case MKPAL_LOAD : charge_palette() ;
deselect(adr_mkpal, obj) ;
xobjc_draw( wnd->window_handle,adr_mkpal, obj ) ;
wext->flag_aff = 0 ;
break ;
case MKPAL_SAVE : sauve_palette() ;
deselect(adr_mkpal, obj) ;
xobjc_draw( wnd->window_handle,adr_mkpal, obj ) ;
wext->flag_aff = 0 ;
break ;
case MKPAL_START :
case MKPAL_END : if ( obj == MKPAL_START ) wext->stdeg = wext->index ;
else wext->enddeg = wext->index ;
if (selected(adr_mkpal, MKPAL_START) && selected(adr_mkpal, MKPAL_END))
{
deselect(adr_mkpal, MKPAL_START) ;
deselect(adr_mkpal, MKPAL_END) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_START ) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_END ) ;
cree_degrade(wext->stdeg, wext->enddeg) ;
wext->stdeg = wext->enddeg = 500 ;
}
break ;
case MKPAL_APPLIQUE : read_text(adr_mkpal, MKPAL_TRED, buf) ;
wext->rgb[0] = atoi(buf) ;
off_y = (int) ((1000-wext->rgb[0])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
read_text(adr_mkpal, MKPAL_TGREEN, buf) ;
wext->rgb[1] = atoi(buf) ;
off_y = (int) ((1000-wext->rgb[1])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
read_text(adr_mkpal, MKPAL_TBLUE, buf) ;
wext->rgb[2] = atoi(buf) ;
off_y = (int) ((1000-wext->rgb[2])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
vs_color(handle, wext->index, wext->rgb) ;
deselect(adr_mkpal, obj) ;
xobjc_draw( wnd->window_handle,adr_mkpal, obj ) ;
break ;
case MKPAL_BOX : objc_offset(adr_mkpal, obj, &pb_x, &pb_y) ;
if (wext->flag_aff)
{
x1 = pb_x+(wext->index % wext->nb_col_x)*wext->ww ;
y1 = pb_y+(wext->index / wext->nb_col_x)*wext->hh ;
x2 = x1+wext->ww-1 ;
y2 = y1+wext->hh-1 ;
vsf_color(handle, 1) ;
vswr_mode(handle, MD_XOR) ;
vsl_width(handle, 3) ;
v_hide_c(handle) ;
rectangle(x1, y1, x2, y2) ;
v_show_c(handle, 1) ;
}
else wext->flag_aff = 1 ;
graf_mkstate(&xm, &ym, &dummy, &dummy) ;
wext->index = (xm-pb_x)/wext->ww+ wext->nb_col_x*((ym-pb_y)/wext->hh) ;
vq_color(handle, wext->index, 0, wext->rgb) ;
sprintf(buf, "%.4d", wext->rgb[0]) ;
write_text(adr_mkpal, MKPAL_TRED, buf) ;
sprintf(buf, "%.4d", wext->rgb[1]) ;
write_text(adr_mkpal, MKPAL_TGREEN, buf) ;
sprintf(buf, "%.4d", wext->rgb[2]) ;
write_text(adr_mkpal, MKPAL_TBLUE, buf) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_RGB ) ;
x1 = pb_x+wext->ww*((xm-pb_x)/wext->ww) ;
y1 = pb_y+wext->hh*((ym-pb_y)/wext->hh) ;
x2 = x1+wext->ww-1 ;
y2 = y1+wext->hh-1 ;
vsf_color(handle, 1) ;
v_hide_c(handle) ;
vswr_mode(handle, MD_XOR) ;
vsl_width(handle, 3) ;
rectangle(x1, y1, x2, y2) ;
v_show_c(handle, 1) ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_CURRCOL ) ;
off_y = (int) ((1000-wext->rgb[0])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_RED].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_REDBOX ) ;
off_y = (int) ((1000-wext->rgb[1])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_GREEN].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_GREENBOX ) ;
off_y = (int) ((1000-wext->rgb[2])*(float)wext->hf/1000.0) ;
adr_mkpal[MKPAL_BLUE].ob_y = off_y ;
xobjc_draw( wnd->window_handle,adr_mkpal, MKPAL_BLUEBOX ) ;
break ;
case MKPAL_OK : code = IDOK ;
break ;
case MKPAL_CANCEL : code = IDCANCEL ;
break ;
}
if ( code == IDOK )
{
}
return( code ) ;
}
/* ************************************************************
* *
* main compression routine *
* *
********************************************************** */
void compress_file(void)
{
void read_text(FILE *, bwi_input *s);
void remap_alphabet(bwi_input *s);
void build_sa(bwi_input *s);
void compute_bwt(bwi_input *s);
void compute_info_superbuckets(bwi_input *s);
void compute_info_buckets(bwi_input *s);
void write_prologue(bwi_input *s);
void compress_superbucket(bwi_input *s, int);
int compute_locations(bwi_input *s);
int compute_locations_dict(bwi_input *s, int*);
int compute_ranks_dict(bwi_input *s, int*);
int compute_locations_huffword(bwi_input *s, int *);
void bit_flush( void );
void bit_write(int,int);
void init_bit_buffer(void);
void write_susp_infos(bwi_input *s);
bwi_input s;
int i,len, retr_occ, retr_occ2, loc_occ_range;
int Start_prologue_ranks;
/* --------- Load the text file from disk ------- */
if(Verbose) fprintf(stderr,"Reading input file... ");
read_text(Infile, &s);
if(Verbose) fprintf(stderr,"done! (%f seconds)\n",getTime());
/* --------- Compact alphabet ------- */
if(Verbose>1) fprintf(stderr,"Remapping alphabet... ");
remap_alphabet(&s);
if(Verbose>1) fprintf(stderr,"done! (%f seconds). ",getTime());
if(Verbose>1) fprintf(stderr,"Compact alphabet size = %d\n",s.alpha_size);
/* --------- Build suffix array ------- */
if(Verbose) fprintf(stderr,"Building suffix array");
build_sa(&s);
if(Verbose) fprintf(stderr,"done! (%f seconds)\n",getTime());
/* --------- Compute BWT ------- */
if(Verbose>1) fprintf(stderr,"Computing BWT... ");
compute_bwt(&s);
if(Verbose>1) fprintf(stderr,"done! (%f seconds)\n",getTime());
/* ------- mark chars and compute locations ----- */
if (Is_dictionary)
retr_occ = compute_locations_dict(&s,&loc_occ_range); // dictionary
else if (Is_huffword)
retr_occ = compute_locations_huffword(&s,&loc_occ_range);// huffword
else if (Is_URL)
retr_occ = compute_ranks_dict(&s,&loc_occ_range); // URL
else
retr_occ = compute_locations(&s); // standard
/* --------- Compute various infos for each superbucket ------- */
if(Verbose>1) fprintf(stderr,"Computing infos superbukets... ");
compute_info_superbuckets(&s);
if(Verbose>1) fprintf(stderr,"done! (%f seconds)\n", getTime());
/* --------- Compute various infos for each bucket ------- */
if(Verbose>1) fprintf(stderr,"Computing infos buckets... ");
compute_info_buckets(&s);
if(Verbose>1) fprintf(stderr,"done! (%f seconds)\n", getTime());
/* --------- Writing the compressed file ------- */
Infile_size = s.text_size;
Outfile_size=0;
write_prologue(&s);
if(Verbose) fprintf(stderr,"Prologue --> %d bytes!\n",Outfile_size);
for(i=0;i<Num_bucs_lev1;i++)
compress_superbucket(&s,i);
/* ---- keep starting positions of occ-explicit list ---- */
Start_prologue_occ = Outfile_size;
/* -- write the starting position of buckets -- */
write_susp_infos(&s);
if (fseek(Outfile,Start_prologue_occ,SEEK_SET)) {
fprintf(stderr, "Seek error on output file -compress_file-\n");
exit(1);
}
/* -- write the position of the marked chars ---- */
init_bit_buffer();
if(Is_dictionary || Is_huffword || Is_URL)
len = int_log2(loc_occ_range); // bits required for each rank
else
len = int_log2(s.text_size); // bits required for each pos
for(i=0; i < retr_occ; i++)
bit_write(len,s.loc_occ[i]);
bit_flush();
Start_prologue_ranks = (int)ftell(Outfile);
if(Verbose)
fprintf(stderr,"List of %d marked ranks --> %d bytes!\n",
retr_occ,Start_prologue_ranks-Start_prologue_occ);
/* -- in the case of URL we also store the DICT info -- */
/* It should be put together with the computation above --*/
/* Thus removing these differences in the code --*/
/* Hence Start_prologue_occ indicates the starting position of RANKS. */
/* After retr_occ RANKS start the LOCATIONS, which are again retr_occ */
/* in number. The value of retr_occ can be computed at decompression time */
/* by using the same formula adopted in compute_ranks_dict() */
if (Is_URL) {
retr_occ2 = compute_locations_dict(&s,&loc_occ_range); // DICT
if (retr_occ != retr_occ2)
out_of_mem("Unequal number of sampled NULLs\n");
for(i=0; i < retr_occ; i++)
bit_write(len,s.loc_occ[i]);
bit_flush();
if(Verbose)
fprintf(stderr,"List of %d marked locations --> %d bytes!\n",
retr_occ2,(int)ftell(Outfile) - Start_prologue_ranks);
}
}
/** Metode for å lese fra fil
* @param int romnr
* @param iftrea &file
*/
Suite::Suite(int romnr, ifstream &file): Rom(romnr, file) {
antall_senger = read_int(file);
antall_kvadratmeter = read_int(file);
beskrivelse = read_text(file);
}
int OnObjectNotifySldShow(void *w, int obj)
{
GEM_WINDOW *wnd = (GEM_WINDOW *) w ;
WEXTENSION_SLDSHOW *wext = wnd->DlgData->UserData ;
WDLG_DATA *wdlg = wnd->Extension ;
OBJECT *adr_sldshow = wnd->DlgData->BaseObject ;
int i, off_x, off_y ;
int code = -1 ;
char buffer[20] ;
switch( obj )
{
case SSH_TRANSITION : deselect(adr_sldshow, SSH_TRANSITION) ;
objc_offset(adr_sldshow, SSH_TRANSITION, &off_x, &off_y) ;
i = popup_formdo(&wdlg->popup_transition, off_x, off_y, 1+wext->transition, -1) ;
if (i > 0) wext->transition = i-1 ;
write_text( adr_sldshow, SSH_TRANSITION, msg[MSG_TRANSIT0+wext->transition] ) ;
xobjc_draw( wnd->window_handle, adr_sldshow, SSH_TRANSITION ) ;
break ;
case SSH_FOND : deselect(adr_sldshow, SSH_FOND) ;
objc_offset(adr_sldshow, SSH_FOND, &off_x, &off_y) ;
i = popup_formdo(&wdlg->popup_back, off_x, off_y, 1+wext->back, -1) ;
if (i > 0) wext->back = i-1 ;
if ( wext->back == BACK_WHITE )
write_text(adr_sldshow, SSH_FOND, msg[MSG_BLANC]) ;
else
write_text(adr_sldshow, SSH_FOND, msg[MSG_NOIR]) ;
xobjc_draw( wnd->window_handle, adr_sldshow, SSH_FOND ) ;
break ;
case SSH_TAFFZOOM : inv_select( adr_sldshow, SSH_AFFZOOM ) ;
break ;
case SSH_TAFFREDUC : inv_select( adr_sldshow, SSH_AFFREDUC ) ;
break ;
case SSH_TCYCLE : inv_select(adr_sldshow, SSH_CYCLE) ;
break ;
case SSH_TCLSSCREEN : inv_select(adr_sldshow, SSH_CLSSCREEN) ;
break ;
case SSH_TSHOWNAME : inv_select(adr_sldshow, SSH_SHOWNAME) ;
break ;
case SSH_TSHOWPROG : inv_select(adr_sldshow, SSH_SHOWPROG) ;
break ;
case SSH_NOTIMER :
case SSH_TNOTIMER : inv_select(adr_sldshow, SSH_NOTIMER) ;
if ( selected(adr_sldshow, SSH_NOTIMER) )
{
adr_sldshow[SSH_WAITMINI].ob_state |= DISABLED ;
adr_sldshow[SSH_TWAITMINI].ob_state |= DISABLED ;
}
else
{
adr_sldshow[SSH_WAITMINI].ob_state &= ~DISABLED ;
adr_sldshow[SSH_TWAITMINI].ob_state &= ~DISABLED ;
}
xobjc_draw( wnd->window_handle, adr_sldshow, SSH_WAITMINI ) ;
xobjc_draw( wnd->window_handle, adr_sldshow, SSH_TWAITMINI ) ;
break ;
case SLDSHOW_OK : code = IDOK ;
break ;
case SLDSHOW_CANCEL : code = IDCANCEL ;
break ;
}
if ( code == IDOK )
{
if ( selected(adr_sldshow, SSH_AFFZOOM) ) config.display_type |= DISPLAYTYPE_ZOOM ;
else config.display_type &= ~DISPLAYTYPE_ZOOM ;
if ( selected(adr_sldshow, SSH_AFFREDUC) ) config.display_type |= DISPLAYTYPE_REDUC ;
else config.display_type &= ~DISPLAYTYPE_REDUC ;
if ( wext->back >= 0 ) config.back = wext->back ;
if ( wext->transition >= 0 ) config.transition = wext->transition ;
if ( selected(adr_sldshow, SSH_CYCLE) ) config.cycle = 1 ;
else config.cycle = 0 ;
if ( selected(adr_sldshow, SSH_CLSSCREEN) ) config.do_not_cls_scr = 0 ;
else config.do_not_cls_scr = 1 ;
if ( selected(adr_sldshow, SSH_SHOWNAME) ) config.aff_name = 1 ;
else config.aff_name = 0 ;
if ( selected(adr_sldshow, SSH_SHOWPROG) ) config.aff_prog = 1 ;
else config.aff_prog = 0 ;
if ( !selected( adr_sldshow, SSH_NOTIMER ) )
{
read_text(adr_sldshow, SSH_WAITMINI, buffer) ;
config.wait_mini_sec = atoi(buffer) ;
}
else
config.wait_mini_sec = -1 ;
}
return( code ) ;
}
void read_username(int *bytes_read = NULL, int *sum = NULL)
{
QString name = read_text(20, bytes_read, sum);
//deviceInfo += QString("User : %1\n").arg(name);
}
void OnInitPrinterDialog(void *w)
{
static int printer_index ;
static int type_index = 0 ;
GEM_WINDOW *wnd = (GEM_WINDOW *) w ;
DIALOG *dlg = (DIALOG *) wnd->DlgData ;
DLGPRINTER_USER_DATA *dlg_user_data = dlg->UserData ;
DLGPRINTER_WEXTENSION *wext ;
OBJECT *adr_print = dlg->BaseObject ;
int i ;
char buffer[200] ;
wnd->Extension = calloc( sizeof(DLGPRINTER_WEXTENSION), 1 ) ;
wext = (DLGPRINTER_WEXTENSION *) wnd->Extension ;
read_text( adr_print, PRINT_FILE, buffer ) ;
if ( dlg_user_data->filename[0] ) write_text( adr_print, PRINT_FILE, dlg_user_data->filename ) ;
else write_text( adr_print, PRINT_FILE, buffer ) ;
wext->popup_page = popup_make(1+LAST_INDEX, 11) ;
for (i = 0; i <= LAST_INDEX; i++)
strcpy(wext->popup_page[1+i].ob_spec.free_string, tab_page[i]->nom) ;
wext->popup_printer = popup_make(nb_drivers, 20) ;
for (i = 0; i < nb_drivers; i++)
sprintf(wext->popup_printer[1+i].ob_spec.free_string, " %s", &printer_names[i][0]) ;
dlg_user_data->printer_index = printer_index ;
wext->popup_type = popup_make(2, 20) ;
strcpy(wext->popup_type[1].ob_spec.free_string, msg[MSG_PRINTCOLOR]) ;
strcpy(wext->popup_type[2].ob_spec.free_string, msg[MSG_PRINTBW]) ;
dlg_user_data->sizex = (float)dlg_user_data->raster.fd_w*(float)dlg_user_data->info.lpix/10000.0 ; /* En cm */
sprintf(buffer, "%.1f", dlg_user_data->sizex) ;
write_text(adr_print, PRINT_SIZEX, buffer) ;
dlg_user_data->sizey = (float)dlg_user_data->raster.fd_h*(float)dlg_user_data->info.hpix/10000.0 ; /* En cm */
sprintf(buffer, "%.1f", dlg_user_data->sizey) ;
write_text(adr_print, PRINT_SIZEY, buffer) ;
write_text(adr_print, PRINT_XPC, "100") ;
write_text(adr_print, PRINT_YPC, "100") ;
dlg_user_data->page.unite = CM ;
read_text(adr_print, PRINT_SIZEPAGEW, buffer) ;
dlg_user_data->page.largeur = atof(buffer) ;
read_text(adr_print, PRINT_SIZEPAGEH, buffer) ;
dlg_user_data->page.hauteur = atof(buffer) ;
setup_pagename(&dlg_user_data->page) ;
deselect(adr_print, PRINT_R90) ;
deselect(adr_print, PRINT_CENTREX) ;
deselect(adr_print, PRINT_CENTREY) ;
if (dlg_user_data->info.nplans == 1)
{
adr_print[PRINT_TYPE].ob_state |= DISABLED ;
dlg_user_data->type_index = 1 ;
}
else
{
adr_print[PRINT_TYPE].ob_state &= ~DISABLED ;
dlg_user_data->type_index = type_index ;
}
write_text(adr_print, PRINT_CONFIGPAGE, dlg_user_data->page.nom) ;
write_text(adr_print, PRINT_PRINTER, wext->popup_printer[1+dlg_user_data->printer_index].ob_spec.free_string) ;
write_text(adr_print, PRINT_TYPE, wext->popup_type[1+dlg_user_data->type_index].ob_spec.free_string) ;
sprintf(buffer, "%.4d/%.4d", micron2dpi(dlg_user_data->info.lpix), micron2dpi(dlg_user_data->info.hpix)) ;
write_text(adr_print, PRINT_RESOL, buffer) ;
compute_page( dlg ) ;
}
int OnObjectNotifyPrinterDialog(void *wi, int obj) /* >=0 : sortie de la fenetre, code IDOK ou IDCANCEL */
{
GEM_WINDOW *wnd = (GEM_WINDOW *) wi ;
DIALOG *dlg = (DIALOG *) wnd->DlgData ;
OBJECT *adr_print = dlg->BaseObject ;
DLGPRINTER_USER_DATA *dlg_user_data = dlg->UserData ;
DLGPRINTER_WEXTENSION *wext = wnd->Extension ;
float number ;
static int pc ;
int rx, ry ;
int xc, yc ;
int w, h ;
int clicked ;
int ix, iy ;
int xr, yr ;
int lx, ly, lw, lh ;
int code = -1 ;
char *c, buffer[100], buf[100] ;
switch( obj )
{
case PRINT_XPCMOINS :
case PRINT_XPCPLUS : read_text(adr_print, PRINT_XPC, buffer) ;
pc = atoi(buffer) ;
if (obj == PRINT_XPCPLUS) pc += PC_STEP ;
else pc -= PC_STEP ;
if (pc < 2) pc = 2 ;
if (pc > 999) pc = 999 ;
sprintf(buffer, "%d", pc) ;
write_text(adr_print, PRINT_XPC, buffer) ;
number = dlg_user_data->sizex*(float)pc/100.0 ;
adr_print[PRINT_IMAGE].ob_width = (int) (number*(float)dlg_user_data->spx/dlg_user_data->page.largeur) ;
sprintf(buffer, "%.1f", number) ;
write_text(adr_print, PRINT_SIZEX, buffer) ;
if (selected(adr_print, PRINT_KEEPRATIO))
{
sprintf(buffer, "%d", pc) ;
write_text(adr_print, PRINT_YPC, buffer) ;
number = dlg_user_data->sizey*(float)pc/100.0 ;
adr_print[PRINT_IMAGE].ob_height = (int) (number*(float)dlg_user_data->spy/dlg_user_data->page.hauteur) ;
sprintf(buffer, "%.1f", number) ;
write_text(adr_print, PRINT_SIZEY, buffer) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_YPC ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_SIZEY ) ;
}
rx = (int) ((float)dlg_user_data->info.lpix*(float)pc/100.0) ;
ry = (int) ((float)dlg_user_data->info.hpix*(float)pc/100.0) ;
sprintf(buffer, "%.4d/%.4d", micron2dpi(rx), micron2dpi(ry)) ;
write_text(adr_print, PRINT_RESOL, buffer) ;
deselect(adr_print, obj) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_XPC ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_SIZEX ) ;
xobjc_draw( wnd->window_handle, adr_print, obj ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_PAGE ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_RESOL ) ;
if (selected(adr_print, PRINT_CENTREX)) button_center( wnd, adr_print, 0, 0 ) ;
if (selected(adr_print, PRINT_CENTREY)) button_center( wnd, adr_print, 1, 0 ) ;
break ;
case PRINT_YPCMOINS :
case PRINT_YPCPLUS : read_text(adr_print, PRINT_YPC, buffer) ;
pc = atoi(buffer) ;
if (obj == PRINT_YPCPLUS) pc += PC_STEP ;
else pc -= PC_STEP ;
if (pc < 2) pc = 2 ;
if (pc > 999) pc = 999 ;
sprintf(buffer, "%d", pc) ;
write_text(adr_print, PRINT_YPC, buffer) ;
number = dlg_user_data->sizey*(float)pc/100.0 ;
adr_print[PRINT_IMAGE].ob_height = (int) (number*(float)dlg_user_data->spy/dlg_user_data->page.hauteur) ;
sprintf(buffer, "%.1f", number) ;
write_text(adr_print, PRINT_SIZEY, buffer) ;
if (selected(adr_print, PRINT_KEEPRATIO))
{
sprintf(buffer, "%d", pc) ;
write_text(adr_print, PRINT_XPC, buffer) ;
number = dlg_user_data->sizex*(float)pc/100.0 ;
adr_print[PRINT_IMAGE].ob_width = (int) (number*(float)dlg_user_data->spx/dlg_user_data->page.largeur) ;
sprintf(buffer, "%.1f", number) ;
write_text(adr_print, PRINT_SIZEX, buffer) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_XPC ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_SIZEX ) ;
}
rx = (int) ((float)dlg_user_data->info.lpix*(float)pc/100.0) ;
ry = (int) ((float)dlg_user_data->info.hpix*(float)pc/100.0) ;
sprintf(buffer, "%.4d/%.4d", micron2dpi(rx), micron2dpi(ry)) ;
write_text(adr_print, PRINT_RESOL, buffer) ;
deselect(adr_print, obj) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_YPC ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_SIZEY ) ;
xobjc_draw( wnd->window_handle, adr_print, obj ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_PAGE ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_RESOL ) ;
if (selected(adr_print, PRINT_CENTREX)) button_center( wnd, adr_print, 0, 0 ) ;
if (selected(adr_print, PRINT_CENTREY)) button_center( wnd, adr_print, 1, 0 ) ;
break ;
case PRINT_R90 :
case PRINT_TR90 : inv_select(adr_print, PRINT_R90) ;
xc = adr_print[PRINT_IMAGE].ob_width ;
adr_print[PRINT_IMAGE].ob_width = adr_print[PRINT_IMAGE].ob_height ;
adr_print[PRINT_IMAGE].ob_height = xc ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_PAGE ) ;
number = dlg_user_data->sizex ;
dlg_user_data->sizex = dlg_user_data->sizey ;
dlg_user_data->sizey = number ;
read_text(adr_print, PRINT_SIZEX, buf) ;
read_text(adr_print, PRINT_SIZEY, buffer) ;
write_text(adr_print, PRINT_SIZEX, buffer) ;
write_text(adr_print, PRINT_SIZEY, buf) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_SIZEX ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_SIZEY ) ;
read_text(adr_print, PRINT_XPC, buf) ;
read_text(adr_print, PRINT_YPC, buffer) ;
write_text(adr_print, PRINT_XPC, buffer) ;
write_text(adr_print, PRINT_YPC, buf) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_XPC ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_YPC ) ;
if (selected(adr_print, PRINT_CENTREX)) button_center( wnd, adr_print, 0, 0 ) ;
if (selected(adr_print, PRINT_CENTREY)) button_center( wnd, adr_print, 1, 0 ) ;
break ;
case PRINT_CENTREX :
case PRINT_TCENTREX : button_center( wnd, adr_print, 0, 1 ) ;
break ;
case PRINT_CENTREY :
case PRINT_TCENTREY : button_center( wnd, adr_print, 1, 1 ) ;
break ;
case PRINT_KEEPRATIO :
case PRINT_TKEEPRATIO : inv_select(adr_print, PRINT_KEEPRATIO) ;
break ;
case PRINT_IMAGE : w = adr_print[PRINT_IMAGE].ob_width ;
h = adr_print[PRINT_IMAGE].ob_height ;
objc_offset(adr_print, PRINT_IMAGE, &ix, &iy) ;
objc_offset(adr_print, PRINT_PAGE, &lx, &ly) ;
lw = adr_print[PRINT_PAGE].ob_width ;
lh = adr_print[PRINT_PAGE].ob_height ;
my_dragbox(w, h, ix, iy, lx, ly, lw, lh, &xr, &yr) ;
adr_print[PRINT_IMAGE].ob_x = xr-lx ;
adr_print[PRINT_IMAGE].ob_y = yr-ly ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_PAGE ) ;
if (selected(adr_print, PRINT_CENTREX)) inv_select(adr_print, PRINT_CENTREX) ;
if (selected(adr_print, PRINT_CENTREY)) inv_select(adr_print, PRINT_CENTREY) ;
break ;
case PRINT_CONFIGPAGE : deselect(adr_print, PRINT_CONFIGPAGE) ;
dlg_user_data->page_index = tab_page_index(&dlg_user_data->page) ;
objc_offset(adr_print, PRINT_CONFIGPAGE, &xc, &yc) ;
clicked = popup_formdo(&wext->popup_page, xc, yc, 1+dlg_user_data->page_index, 0) ;
if (clicked > 0)
{
write_text(adr_print, PRINT_CONFIGPAGE, tab_page[clicked-1]->nom) ;
memcpy(&dlg_user_data->page, tab_page[clicked-1], sizeof(PAGE)) ;
compute_page( dlg ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_GROUP ) ;
}
xobjc_draw( wnd->window_handle, adr_print, PRINT_CONFIGPAGE ) ;
show_dimpage( wnd, &dlg_user_data->page, adr_print ) ;
read_text(adr_print, PRINT_XPC, buffer) ;
pc = atoi(buffer) ;
sprintf(buffer, "%d", pc) ;
number = dlg_user_data->sizex*(float)pc/100.0 ;
adr_print[PRINT_IMAGE].ob_width = (int) (number*(float)dlg_user_data->spy/dlg_user_data->page.hauteur) ;
sprintf(buffer, "%.1f", number) ;
write_text(adr_print, PRINT_SIZEY, buffer) ;
read_text(adr_print, PRINT_YPC, buffer) ;
pc = atoi(buffer) ;
sprintf(buffer, "%d", pc) ;
number = dlg_user_data->sizey*(float)pc/100.0 ;
adr_print[PRINT_IMAGE].ob_height = (int) (number*(float)dlg_user_data->spx/dlg_user_data->page.largeur) ;
sprintf(buffer, "%.1f", number) ;
write_text(adr_print, PRINT_SIZEY, buffer) ;
rx = (int) ((float)dlg_user_data->info.lpix*(float)pc/100.0) ;
ry = (int) ((float)dlg_user_data->info.hpix*(float)pc/100.0) ;
sprintf(buffer, "%.4d/%.4d", micron2dpi(rx), micron2dpi(ry)) ;
write_text(adr_print, PRINT_RESOL, buffer) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_SIZEY ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_PAGE ) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_RESOL ) ;
if (selected(adr_print, PRINT_CENTREX)) button_center( wnd, adr_print, 0, 0 ) ;
if (selected(adr_print, PRINT_CENTREY)) button_center( wnd, adr_print, 1, 0 ) ;
break ;
case PRINT_PRINTER : deselect(adr_print, PRINT_PRINTER) ;
objc_offset(adr_print, PRINT_PRINTER, &xc, &yc) ;
clicked = popup_formdo(&wext->popup_printer, xc, yc, 1+dlg_user_data->printer_index, 0) ;
if (clicked > 0)
{
dlg_user_data->printer_index = clicked-1 ;
write_text(adr_print, PRINT_PRINTER, wext->popup_printer[1+dlg_user_data->printer_index].ob_spec.free_string) ;
}
xobjc_draw( wnd->window_handle, adr_print, PRINT_PRINTER ) ;
sprintf(buffer, "%d", id[dlg_user_data->printer_index]) ;
write_text(adr_print, PRINT_ID, buffer) ;
xobjc_draw( wnd->window_handle, adr_print, PRINT_ID ) ;
break ;
case PRINT_TYPE : if (!(adr_print[PRINT_TYPE].ob_state & DISABLED))
{
deselect(adr_print, PRINT_TYPE) ;
objc_offset(adr_print, PRINT_TYPE, &xc, &yc) ;
clicked = popup_formdo(&wext->popup_type, xc, yc, 1+dlg_user_data->type_index, 0) ;
if (clicked > 0)
{
dlg_user_data->type_index = clicked-1 ;
write_text(adr_print, PRINT_TYPE, wext->popup_type[1+dlg_user_data->type_index].ob_spec.free_string) ;
}
xobjc_draw( wnd->window_handle, adr_print, PRINT_TYPE ) ;
}
break ;
case PRINT_FILE : strcpy(buffer, dlg_user_data->filename) ;
c = strrchr(buffer, '\\') ;
if (c != NULL) *c = 0 ;
strcat(buffer, "\\*.*") ;
if ( file_name(buffer, "", buffer) == 1 )
{
INFO_IMAGE inf ;
strcpy(dlg_user_data->filename, buffer) ;
write_text(adr_print, PRINT_FILE, dlg_user_data->filename) ;
if ( img_format( dlg_user_data->filename, &inf ) == 0 )
{
memcpy( &dlg_user_data->info, &inf, sizeof(INFO_IMAGE) ) ;
deselect(adr_print, PRINT_R90) ;
deselect(adr_print, PRINT_CENTREX) ;
deselect(adr_print, PRINT_CENTREY) ;
memset(&dlg_user_data->raster, 0, sizeof(MFDB)) ;
dlg_user_data->raster.fd_w = dlg_user_data->info.largeur ;
dlg_user_data->raster.fd_h = dlg_user_data->info.hauteur ;
dlg_user_data->raster.fd_nplanes = dlg_user_data->info.nplans ;
dlg_user_data->raster.fd_wdwidth = dlg_user_data->raster.fd_w/16 ;
if (dlg_user_data->raster.fd_w % 16) dlg_user_data->raster.fd_wdwidth++ ;
dlg_user_data->sizex = (float)dlg_user_data->raster.fd_w*(float)dlg_user_data->info.lpix/10000.0 ; /* En cm */
sprintf(buffer, "%.1f", dlg_user_data->sizex) ;
write_text(adr_print, PRINT_SIZEX, buffer) ;
dlg_user_data->sizey = (float)dlg_user_data->raster.fd_h*(float)dlg_user_data->info.hpix/10000.0 ; /* En cm */
sprintf(buffer, "%.1f", dlg_user_data->sizey) ;
write_text(adr_print, PRINT_SIZEY, buffer) ;
write_text(adr_print, PRINT_XPC, "100") ;
write_text(adr_print, PRINT_YPC, "100") ;
compute_page( dlg ) ;
}
}
deselect(adr_print, obj) ;
break ;
case PRINT_OK : code = IDOK ;
break ;
case PRINT_CANCEL : code = IDCANCEL ;
break ;
}
if ( code == IDOK )
{
/* Mise a jour de UserData */
dlg_user_data->rotate90 = selected( adr_print, PRINT_R90 ) ;
read_text( adr_print, PRINT_XPC, buffer ) ;
dlg_user_data->xpc = atof( buffer ) ;
read_text( adr_print, PRINT_YPC, buffer ) ;
dlg_user_data->ypc = atof( buffer ) ;
dlg_user_data->posx = dlg_user_data->page.largeur*(float)adr_print[PRINT_IMAGE].ob_x/(float)adr_print[PRINT_PAGE].ob_width ;
dlg_user_data->posy = dlg_user_data->page.hauteur*(float)adr_print[PRINT_IMAGE].ob_y/(float)adr_print[PRINT_PAGE].ob_height ;
}
return( code ) ;
}
void setup_details(GEM_WINDOW *wnd, int display)
{
WEXTENSION_LDVDETAIL *wext = wnd->DlgData->UserData ;
LDV_CAPS *caps = NULL ;
OBJECT *bobj = wnd->DlgData->BaseObject ;
int nplanes ;
char buf[100] ;
read_text( bobj, LDVD_NPLANES, buf ) ;
nplanes = atoi( buf ) ;
if ( nplanes > 0 ) caps = LDVGetNPlanesCaps( wext->LdvModule, nplanes ) ;
if ( caps )
{
bobj[LDVD_NPLANES].ob_state &= ~DISABLED ;
sprintf( buf, "%d", caps->NbPlanesOut ) ;
write_text( bobj, LDVD_NBPLANESOUT, buf ) ;
buf[0] = 0 ;
if ( caps->Flags & LDVF_STDFORMAT ) strcat( buf, msg[MSG_LDVSTDFMT] ) ;
if ( caps->Flags & LDVF_ATARIFORMAT ) strcat( buf, msg[MSG_LDVATARIFMT] ) ;
if ( caps->Flags & LDVF_SPECFORMAT ) strcat( buf, msg[MSG_LDVSPECFMT] ) ;
write_text( bobj, LDVD_FORMAT, buf ) ;
buf[0] = 0 ;
if ( caps->Flags & LDVF_SUPPORTPREVIEW ) strcat( buf, msg[MSG_LDVSUPPREV] ) ;
if ( caps->Flags & LDVF_SUPPORTPROG ) strcat( buf, msg[MSG_LDVSUPPROG] ) ;
write_text( bobj, LDVD_SUPPORT, buf ) ;
if ( caps->Flags & LDVF_REALTIMEPARAMS )
bobj[LDVD_RTPREVIEW].ob_flags &= ~HIDETREE ;
else
bobj[LDVD_RTPREVIEW].ob_flags |= HIDETREE ;
if ( caps->Flags & LDVF_OPINPLACE )
bobj[LDVD_OPINPLACE].ob_flags &= ~HIDETREE ;
else
bobj[LDVD_OPINPLACE].ob_flags |= HIDETREE ;
if ( ( caps->NbPlanes <= 8 ) && ( caps->Flags & LDVF_AFFECTPALETTE ) )
bobj[LDVD_AFFECTPAL].ob_flags &= ~HIDETREE ;
else
bobj[LDVD_AFFECTPAL].ob_flags |= HIDETREE ;
if ( caps->Flags & LDVF_SUPPORTCANCEL )
bobj[LDVD_CANCEL].ob_flags &= ~HIDETREE ;
else
bobj[LDVD_CANCEL].ob_flags |= HIDETREE ;
}
else
{
write_text( bobj, LDVD_NBPLANESOUT, "~" ) ;
write_text( bobj, LDVD_FORMAT, "~" ) ;
write_text( bobj, LDVD_SUPPORT, "~" ) ;
bobj[LDVD_AFFECTPAL].ob_flags |= HIDETREE ;
caps = LDVGetNPlanesCaps( wext->LdvModule, 1 ) ;
if ( caps == NULL ) caps = LDVGetNPlanesCaps( wext->LdvModule, 2 ) ;
if ( caps == NULL ) caps = LDVGetNPlanesCaps( wext->LdvModule, 4 ) ;
if ( caps == NULL ) caps = LDVGetNPlanesCaps( wext->LdvModule, 8 ) ;
if ( caps == NULL ) caps = LDVGetNPlanesCaps( wext->LdvModule, 16 ) ;
if ( caps == NULL ) caps = LDVGetNPlanesCaps( wext->LdvModule, 24 ) ;
if ( caps == NULL ) caps = LDVGetNPlanesCaps( wext->LdvModule, 32 ) ;
if ( caps == NULL ) bobj[LDVD_NPLANES].ob_state |= DISABLED ;
}
if ( display )
{
xobjc_draw( wnd->window_handle, bobj, LDVD_GROUPDET ) ;
xobjc_draw( wnd->window_handle, bobj, LDVD_TFEATURES ) ;
}
}