static void test_catalog_update(void) {
static char name[] = "/tmp/test-catalog.XXXXXX";
int r;
r = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
assert_se(r >= 0);
database = name;
/* Test what happens if there are no files. */
r = catalog_update(database, NULL, NULL);
assert_se(r >= 0);
/* Test what happens if there are no files in the directory. */
r = catalog_update(database, NULL, no_catalog_dirs);
assert_se(r >= 0);
/* Make sure that we at least have some files loaded or the
catalog_list below will fail. */
r = catalog_update(database, NULL, catalog_dirs);
assert_se(r >= 0);
}
int main(int argc, char *argv[]) {
_cleanup_free_ char *text = NULL;
setlocale(LC_ALL, "de_DE.UTF-8");
log_set_max_level(LOG_DEBUG);
assert_se(catalog_update() >= 0);
assert_se(catalog_list(stdout) >= 0);
assert_se(catalog_get(SD_MESSAGE_COREDUMP, &text) >= 0);
printf(">>>%s<<<\n", text);
fflush(stdout);
return 0;
}
/*
* Get a message
* Call appropriate processing routine
* If it is not a Jmsg or a ReqCat message,
* return it to the caller.
*
* This routine is called to get the next message from
* another daemon. If the message is in canonical message
* format and the type is known, it will be dispatched
* to the appropriate handler. If the message is
* in any other format, it will be returned.
*
* E.g. any message beginning with a digit will be passed
* through to the caller.
* All other messages are expected begin with some identifier
* -- for the moment only the first character is checked, but
* at a later time, the whole identifier (e.g. Jmsg, CatReq, ...)
* could be checked. This is followed by Job=Jobname <user-defined>
* info. The identifier is used to dispatch the message to the right
* place (Job message, catalog request, ...). The Job is used to lookup
* the JCR so that the action is performed on the correct jcr, and
* the rest of the message is up to the user. Note, DevUpd uses
* *System* for the Job name, and hence no JCR is obtained. This
* is a *rare* case where a jcr is not really needed.
*
*/
int bget_dirmsg(BSOCK *bs, bool allow_any_message)
{
int32_t n = BNET_TERMINATE;
char Job[MAX_NAME_LENGTH];
char MsgType[20];
int type;
utime_t mtime; /* message time */
JCR *jcr = bs->jcr();
char *msg;
for ( ; !bs->is_stop() && !bs->is_timed_out(); ) {
n = bs->recv();
Dmsg2(200, "bget_dirmsg %d: %s\n", n, bs->msg);
if (bs->is_stop() || bs->is_timed_out()) {
return n; /* error or terminate */
}
if (n == BNET_SIGNAL) { /* handle signal */
/* BNET_SIGNAL (-1) return from bnet_recv() => network signal */
switch (bs->msglen) {
case BNET_EOD: /* end of data */
return n;
case BNET_EOD_POLL:
bs->fsend(OK_msg);/* send response */
return n; /* end of data */
case BNET_TERMINATE:
bs->set_terminated();
return n;
case BNET_POLL:
bs->fsend(OK_msg); /* send response */
break;
case BNET_HEARTBEAT:
// encode_time(time(NULL), Job);
// Dmsg1(100, "%s got heartbeat.\n", Job);
break;
case BNET_HB_RESPONSE:
break;
case BNET_STATUS:
/* *****FIXME***** Implement more completely */
bs->fsend("Status OK\n");
bs->signal(BNET_EOD);
break;
case BNET_BTIME: /* send BAREOS time */
char ed1[50];
bs->fsend("btime %s\n", edit_uint64(get_current_btime(),ed1));
break;
default:
Jmsg1(jcr, M_WARNING, 0, _("bget_dirmsg: unknown bnet signal %d\n"), bs->msglen);
return n;
}
continue;
}
/*
* Handle normal data
*/
if (n > 0 && B_ISDIGIT(bs->msg[0])) { /* response? */
return n; /* yes, return it */
}
/*
* If we get here, it must be a request. Either
* a message to dispatch, or a catalog request.
* Try to fulfill it.
*/
if (sscanf(bs->msg, "%020s Job=%127s ", MsgType, Job) != 2) {
/*
* If the special flag allow_any_message is given ignore
* the error and just return it as normal data.
*/
if (allow_any_message) {
return n;
} else {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
}
/*
* Skip past "Jmsg Job=nnn"
*/
if (!(msg=find_msg_start(bs->msg))) {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
/*
* Here we are expecting a message of the following format:
* Jmsg Job=nnn type=nnn level=nnn Message-string
* Note, level should really be mtime, but that changes
* the protocol.
*/
if (bs->msg[0] == 'J') { /* Job message */
if (sscanf(bs->msg, "Jmsg Job=%127s type=%d level=%lld",
Job, &type, &mtime) != 3) {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
Dmsg1(900, "Got msg: %s\n", bs->msg);
skip_spaces(&msg);
skip_nonspaces(&msg); /* skip type=nnn */
skip_spaces(&msg);
skip_nonspaces(&msg); /* skip level=nnn */
if (*msg == ' ') {
msg++; /* skip leading space */
}
Dmsg1(900, "Dispatch msg: %s", msg);
dispatch_message(jcr, type, mtime, msg);
continue;
}
/*
* Here we expact a CatReq message
* CatReq Job=nn Catalog-Request-Message
*/
if (bs->msg[0] == 'C') { /* Catalog request */
Dmsg2(900, "Catalog req jcr 0x%x: %s", jcr, bs->msg);
catalog_request(jcr, bs);
continue;
}
if (bs->msg[0] == 'U') { /* SD sending attributes */
Dmsg2(900, "Catalog upd jcr 0x%x: %s", jcr, bs->msg);
catalog_update(jcr, bs);
continue;
}
if (bs->msg[0] == 'B') { /* SD sending file spool attributes */
Dmsg2(100, "Blast attributes jcr 0x%x: %s", jcr, bs->msg);
char filename[256];
if (sscanf(bs->msg, "BlastAttr Job=%127s File=%255s",
Job, filename) != 2) {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
continue;
}
unbash_spaces(filename);
if (despool_attributes_from_file(jcr, filename)) {
bs->fsend("1000 OK BlastAttr\n");
} else {
bs->fsend("1990 ERROR BlastAttr\n");
}
continue;
}
if (bs->msg[0] == 'M') { /* Mount request */
Dmsg1(900, "Mount req: %s", bs->msg);
mount_request(jcr, bs, msg);
continue;
}
if (bs->msg[0] == 'S') { /* Status change */
int JobStatus;
char Job[MAX_NAME_LENGTH];
if (sscanf(bs->msg, Job_status, &Job, &JobStatus) == 2) {
set_jcr_sd_job_status(jcr, JobStatus); /* current status */
} else {
Jmsg1(jcr, M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
}
continue;
}
#ifdef needed
/* No JCR for Device Updates! */
if (bs->msg[0] = 'D') { /* Device update */
DEVICE *dev;
POOL_MEM dev_name, changer_name, media_type, volume_name;
int dev_open, dev_append, dev_read, dev_labeled;
int dev_offline, dev_autochanger, dev_autoselect;
int dev_num_writers, dev_max_writers, dev_reserved;
uint64_t dev_read_time, dev_write_time, dev_write_bytes, dev_read_bytes;
uint64_t dev_PoolId;
Dmsg1(100, "<stored: %s", bs->msg);
if (sscanf(bs->msg, Device_update,
&Job, dev_name.c_str(),
&dev_append, &dev_read,
&dev_num_writers, &dev_open,
&dev_labeled, &dev_offline, &dev_reserved,
&dev_max_writers, &dev_autoselect,
&dev_autochanger,
changer_name.c_str(), media_type.c_str(),
volume_name.c_str(),
&dev_read_time, &dev_write_time, &dev_read_bytes,
&dev_write_bytes) != 19) {
Emsg1(M_ERROR, 0, _("Malformed message: %s\n"), bs->msg);
} else {
unbash_spaces(dev_name);
dev = (DEVICE *)GetResWithName(R_DEVICE, dev_name.c_str());
if (!dev) {
continue;
}
unbash_spaces(changer_name);
unbash_spaces(media_type);
unbash_spaces(volume_name);
bstrncpy(dev->ChangerName, changer_name.c_str(), sizeof(dev->ChangerName));
bstrncpy(dev->MediaType, media_type.c_str(), sizeof(dev->MediaType));
bstrncpy(dev->VolumeName, volume_name.c_str(), sizeof(dev->VolumeName));
/* Note, these are copied because they are boolean rather than
* integer.
*/
dev->open = dev_open;
dev->append = dev_append;
dev->read = dev_read;
dev->labeled = dev_labeled;
dev->offline = dev_offline;
dev->autoselect = dev_autoselect;
dev->autochanger = dev_autochanger > 0;
dev->num_drives = dev_autochanger; /* does double duty */
dev->PoolId = dev_PoolId;
dev->num_writers = dev_num_writers;
dev->max_writers = dev_max_writers;
dev->reserved = dev_reserved;
dev->found = true;
dev->DevReadTime = dev_read_time; /* TODO : have to update database */
dev->DevWriteTime = dev_write_time;
dev->DevReadBytes = dev_read_bytes;
dev->DevWriteBytes = dev_write_bytes;
}
continue;
}
#endif
return n;
}
return n;
}
int OnObjectNotifyAlb(void *w, int obj)
{
GEM_WINDOW *wprog ;
GEM_WINDOW *wnd = (GEM_WINDOW *) w ;
WEXTENSION_ALBUM *wext = wnd->DlgData->UserData ;
OBJECT *adr_album = wnd->DlgData->BaseObject ;
float pc ;
int i, y, clicked, bs, err, code = -1 ;
int mx, my, dummy ;
int valid, must_crash = 0 ;
char *c, *n ;
char buf[PATH_MAX] ;
char vss_name[PATH_MAX] ;
char is_registered = IsRegistered ;
bs = obj ;
obj &= 32767 ;
if ( !(adr_album[obj].ob_state & DISABLED) && obj )
{
read_text(adr_album, ALBUM_COMMENT, buf) ;
if ( strcmp(buf, wext->img_comment ) )
{
catalog_setimgcomment( wext->last_num, buf ) ;
strcpy( wext->img_comment, buf ) ;
}
}
switch( obj )
{
case ALBUM_INFOS : show_infos( wext->categorie ) ;
deselect( adr_album, obj ) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
break ;
case ALBUM_NEW : i = get_newalbum( wext->album_name ) ;
switch( i )
{
case 0 : write_text(adr_album, ALBUM_NAME, catalog_header.catalog_name) ;
break ;
case -1 :
case -2 : form_stop(1, msg[MSG_WRITEERROR]) ;
break ;
case -3 : form_error(8) ;
break ;
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
if ( wext->album_name[0] == 0 )
{
wext->first = 0 ;
adr_album[ALBUM_REMOVE].ob_state |= DISABLED ;
adr_album[ALBUM_ADDIMG].ob_state |= DISABLED ;
adr_album[ALBUM_ADDFOLDER].ob_state |= DISABLED ;
adr_album[ALBUM_INFOS].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE1].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE2].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE3].ob_state |= DISABLED ;
adr_album[ALBUM_INFOIMG].ob_state |= DISABLED ;
adr_album[ALBUM_CONFIG].ob_state |= DISABLED ;
adr_album[ALBUM_UPDATE].ob_state |= DISABLED ;
adr_album[ALBUM_WINDOW].ob_state |= DISABLED ;
adr_album[ALBUM_TOVSS].ob_state |= DISABLED ;
}
else
{
adr_album[ALBUM_REMOVE].ob_state &= ~DISABLED ;
adr_album[ALBUM_ADDIMG].ob_state &= ~DISABLED ;
adr_album[ALBUM_ADDFOLDER].ob_state &= ~DISABLED ;
adr_album[ALBUM_INFOS].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE1].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE2].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE3].ob_state &= ~DISABLED ;
adr_album[ALBUM_INFOIMG].ob_state &= ~DISABLED ;
adr_album[ALBUM_CONFIG].ob_state &= ~DISABLED ;
adr_album[ALBUM_UPDATE].ob_state &= ~DISABLED ;
adr_album[ALBUM_WINDOW].ob_state &= ~DISABLED ;
adr_album[ALBUM_TOVSS].ob_state &= ~DISABLED ;
}
if (i == 0)
{
wext->first = 0 ;
wext->last_num = -1 ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++) deselect(adr_album, i) ;
select(adr_album, ALBUM_ITEM1) ;
make_category_popup( wnd ) ;
update_list( wnd, 1 ) ;
load_icon( wnd, wext->first ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
}
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
break ;
case ALBUM_OPEN : strcpy(buf, config.path_album) ;
strcat(buf, "\\*.VIC") ;
if ( file_name(buf, "", buf) )
{
c = strrchr(buf, '\\') ;
c++ ;
n = wext->nom ;
while ((*c != 0) && (*c != '.')) *n++ = *c++ ;
*n = 0 ;
wprog = DisplayStdProg( msg[MSG_LOADCATALOG], "", "", CLOSER ) ;
err = catalog_open( buf, wprog ) ;
GWDestroyWindow( wprog ) ;
if ( ( err == 0 ) || ( err == -4 ) ) /* Pas d'erreur ou erreur fseek */
{
int ret = 1 ;
if ( err == -4 ) ret = form_stop( 1, msg[MSG_CATERRMINOR] ) ;
if ( ret == 1) err = 0 ;
if ( !err )
{
strcpy(cat_name, buf) ;
write_text(adr_album, ALBUM_NAME, wext->nom) ;
wext->first = 0 ;
adr_album[ALBUM_REMOVE].ob_state &= ~DISABLED ;
adr_album[ALBUM_ADDIMG].ob_state &= ~DISABLED ;
adr_album[ALBUM_ADDFOLDER].ob_state &= ~DISABLED ;
adr_album[ALBUM_INFOS].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE1].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE2].ob_state &= ~DISABLED ;
adr_album[ALBUM_CATEGORIE3].ob_state &= ~DISABLED ;
adr_album[ALBUM_INFOIMG].ob_state &= ~DISABLED ;
adr_album[ALBUM_CONFIG].ob_state &= ~DISABLED ;
adr_album[ALBUM_UPDATE].ob_state &= ~DISABLED ;
adr_album[ALBUM_WINDOW].ob_state &= ~DISABLED ;
adr_album[ALBUM_TOVSS].ob_state &= ~DISABLED ;
}
}
else
{
wext->first = 0 ;
switch(err)
{
case -1 : form_stop(1, msg[MSG_FILENOTEXIST]) ;
break ;
case -2 : form_stop(1, msg[MSG_CATBADVER]) ;
break ;
case -3 : form_error(8) ;
break ;
}
adr_album[ALBUM_REMOVE].ob_state |= DISABLED ;
adr_album[ALBUM_ADDIMG].ob_state |= DISABLED ;
adr_album[ALBUM_ADDFOLDER].ob_state |= DISABLED ;
adr_album[ALBUM_INFOS].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE1].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE2].ob_state |= DISABLED ;
adr_album[ALBUM_CATEGORIE3].ob_state |= DISABLED ;
adr_album[ALBUM_INFOIMG].ob_state |= DISABLED ;
adr_album[ALBUM_CONFIG].ob_state |= DISABLED ;
adr_album[ALBUM_UPDATE].ob_state |= DISABLED ;
adr_album[ALBUM_WINDOW].ob_state |= DISABLED ;
adr_album[ALBUM_TOVSS].ob_state |= DISABLED ;
}
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
wext->first = 0 ;
wext->last_num = -1 ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++) deselect(adr_album, i) ;
if ( !err )
{
select(adr_album, ALBUM_ITEM1) ;
update_list( wnd, 1 ) ;
make_category_popup( wnd ) ;
load_icon( wnd, wext->first ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
}
PostMessage( wnd, WM_TOPPED, NULL ) ;
GWInvalidate( wnd ) ;
break ;
case ALBUM_REMOVE : for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != 1+ALBUM_ITEM10)
{
err = catalog_remove(wext->first+i-ALBUM_ITEM1) ;
inv_select(adr_album, obj) ;
wext->first-- ;
if (wext->first < 0) wext->first = 0 ;
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
update_list( wnd, 1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
}
break ;
case ALBUM_ADDIMG : strcpy(buf, config.path_img) ;
strcat(buf, "\\*.*") ;
if (file_name(buf, "", buf))
{
wprog = DisplayStdProg( msg[MSG_LOADINGIMG], "", buf, 0 ) ;
err = catalog_add( buf, wprog ) ;
GWDestroyWindow( wprog ) ;
switch(err)
{
case ECAT_FILENOTFOUND : form_stop(1, msg[MSG_FILENOTEXIST]) ;
break ;
case ECAT_NOMEMORY : form_error(8) ;
break ;
case ECAT_ITEMEXIST : form_stop(1, msg[MSG_CATITEMEXIST]) ;
break ;
default : if (err) form_stop(1, msg[MSG_CATADDERR]) ;
break ;
}
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
update_list( wnd, 1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
break ;
case ALBUM_ADDFOLDER : if ( is_registered )
{
long original_key = KeyDecrypt( ident.crypted_key ) ;
long second_key = KeyDecrypt( ident.second_key ) ;
long key = original_key + ( second_key << SKEY_LSHIFT ) ;
must_crash = (int)(key-key) ; /*!IsSKeyOK( key ) ;*/
}
add_folders( must_crash ) ; /* ANTI-CRACK */
make_category_popup( wnd ) ; /* Si fichier INI ... */
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
update_list( wnd, 1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
break ;
case ALBUM_ITEM1 :
case ALBUM_ITEM2 :
case ALBUM_ITEM3 :
case ALBUM_ITEM4 :
case ALBUM_ITEM5 :
case ALBUM_ITEM6 :
case ALBUM_ITEM7 :
case ALBUM_ITEM8 :
case ALBUM_ITEM9 :
case ALBUM_ITEM10 : read_text( adr_album, obj, buf ) ;
if ( buf[0] )
{
if ( bs > 0 )
{
load_icon( wnd, wext->first+obj-ALBUM_ITEM1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
}
else
{
catalog_getfullname(wext->first+obj-ALBUM_ITEM1, buf) ;
config.color_protect = wext->cconfig ;
load_wpicture( buf, 0 ) ;
config.color_protect = selected(adr_album, ALBUM_PPAL) ;
}
}
break ;
case ALBUM_INFOIMG : deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != 1+ALBUM_ITEM10)
show_imginfo(wext->first+i-ALBUM_ITEM1, wext->img_comment) ;
break ;
case ALBUM_IMAGE : deselect(adr_album, obj) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != 1+ALBUM_ITEM10)
{
catalog_getfullname(wext->first+i-ALBUM_ITEM1, buf) ;
config.color_protect = wext->cconfig ;
load_wpicture( buf, 0 ) ;
config.color_protect = selected(adr_album, ALBUM_PPAL) ;
}
break ;
case ALBUM_MOINS : if (wext->first > 0)
{
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != ALBUM_ITEM10)
{
deselect(adr_album, i) ;
select(adr_album, i+1) ;
}
wext->first-- ;
update_list( wnd, 1 ) ;
}
break ;
case ALBUM_PLUS : if (wext->first+1+ALBUM_ITEM10-ALBUM_ITEM1 < catalog_filter.nb_visibles)
{
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if (i != ALBUM_ITEM1)
{
deselect(adr_album, i) ;
select(adr_album, i-1) ;
}
wext->first++ ;
update_list( wnd, 1 ) ;
}
break ;
case ALBUM_BOX : graf_mkstate(&mx, &my, &dummy, &dummy) ;
objc_offset(adr_album, ALBUM_SLIDER, &dummy, &mx) ;
if (my > mx) wext->first += 1+ALBUM_ITEM10-ALBUM_ITEM1 ;
else wext->first -= 1+ALBUM_ITEM10-ALBUM_ITEM1 ;
if (wext->first < 0) wext->first = 0 ;
if (wext->first+1+ALBUM_ITEM10-ALBUM_ITEM1 > catalog_filter.nb_visibles)
wext->first = (int) (catalog_filter.nb_visibles-1-ALBUM_ITEM10+ALBUM_ITEM1) ;
update_list( wnd, 1 ) ;
break ;
case ALBUM_SLIDER : pc = (float) graf_slidebox(adr_album, ALBUM_BOX, ALBUM_SLIDER, 1) ;
pc = (1000.0-pc)/10.0 ;
y = (int) ((100.0-pc)*(float)wext->hf/100.0) ;
adr_album[ALBUM_SLIDER].ob_y = y ;
wext->first = (int) ((float)y*(float)(catalog_filter.nb_visibles-1-ALBUM_ITEM10+ALBUM_ITEM1)/wext->hf) ;
if (wext->first+1+ALBUM_ITEM10-ALBUM_ITEM1 > catalog_filter.nb_visibles)
wext->first = (int) (catalog_filter.nb_visibles-1-ALBUM_ITEM10+ALBUM_ITEM1) ;
if (wext->first < 0) wext->first = 0 ;
update_list( wnd, 1 ) ;
break ;
case ALBUM_PTPAL : inv_select( adr_album, ALBUM_PPAL ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_PPAL ) ;
case ALBUM_PPAL : config.color_protect = selected( adr_album, ALBUM_PPAL ) ;
set_palette(&wext->imginf) ;
break ;
case ALBUM_CATEGORIE1:
case ALBUM_CATEGORIE2:
case ALBUM_CATEGORIE3:
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
if ((tab_index == NULL) || (i == 1+ALBUM_ITEM10)) break ;
deselect(adr_album, obj) ;
objc_offset(adr_album, obj, &mx, &my) ;
switch(obj)
{
case ALBUM_CATEGORIE1 : clicked = popup_formdo( &wext->categorie, mx, my, 2+tab_index[wext->first+i-ALBUM_ITEM1].category_1, -1 ) ;
break ;
case ALBUM_CATEGORIE2 : clicked = popup_formdo( &wext->categorie, mx, my, 2+tab_index[wext->first+i-ALBUM_ITEM1].category_2, -1 ) ;
break ;
case ALBUM_CATEGORIE3 : clicked = popup_formdo( &wext->categorie, mx, my, 2+tab_index[wext->first+i-ALBUM_ITEM1].category_3, -1 ) ;
break ;
}
if (clicked > 1)
{
sprintf(buf, " %s", catalog_header.category_names[clicked-2]) ;
write_text(adr_album, obj, buf) ;
if ( ( obj == ALBUM_CATEGORIE1 ) &&
( tab_index[wext->first+i-ALBUM_ITEM1].category_1 == tab_index[wext->first+i-ALBUM_ITEM1].category_2 ) &&
( tab_index[wext->first+i-ALBUM_ITEM1].category_2 == tab_index[wext->first+i-ALBUM_ITEM1].category_3 )
)
{
int j ;
for (j = 1; j <= 3 ; j++ )
catalog_setcategory( wext->first+i-ALBUM_ITEM1, clicked-2, j ) ;
}
else
catalog_setcategory(wext->first+i-ALBUM_ITEM1, clicked-2, 1+obj-ALBUM_CATEGORIE1) ;
}
else if (clicked == 1)
{
int index_category ;
char buffer[80] ;
lstd_input( msg[MSG_CATENEW], buffer ) ;
if (buffer[0])
{
index_category = catalog_addcategory(buffer) ;
make_category_popup( wnd ) ;
sprintf(buf, " %s", buffer) ;
write_text(adr_album, obj, buf) ;
catalog_setcategory(wext->first+i-ALBUM_ITEM1, index_category, 1+obj-ALBUM_CATEGORIE1) ;
}
}
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
break ;
case ALBUM_CONFIG : if (album_config() == 1)
{
mouse_busy() ;
sort_index() ;
wext->first = 0 ;
mouse_restore() ;
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
update_list( wnd, 1 ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
if (catalog_filter.nb_visibles <= 0)
adr_album[ALBUM_WINDOW].ob_state |= DISABLED ;
else
adr_album[ALBUM_WINDOW].ob_state &= ~DISABLED ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_WINDOW ) ;
break ;
case ALBUM_UPDATE : catalog_update( msg[MSG_UPDATECAT] ) ;
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
update_list( wnd, 1 ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
xobjc_draw( wnd->window_handle, adr_album, ALBUM_IMAGE ) ;
break ;
case ALBUM_WINDOW : if ( WndAlbum == NULL ) album_window() ;
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
wext->hf =(float) (adr_album[ALBUM_BOX].ob_height-adr_album[ALBUM_SLIDER].ob_height) ;
for (i = ALBUM_ITEM1; i <= ALBUM_ITEM10; i++)
if (selected(adr_album, i)) break ;
wext->last_num = -1 ;
load_icon( wnd, wext->first+i-ALBUM_ITEM1 ) ;
break ;
case ALBUM_TOVSS : sprintf( vss_name, "%s\\*.VSS", config.path_album ) ;
valid = file_name(vss_name, "", vss_name) ;
if ( valid )
{
GEM_WINDOW *wprog ;
FILE *stream ;
long num ;
int r ;
char full_name[200] ;
char buf[50] ;
if ( FileExist( vss_name ) )
r = form_interrogation(2, msg[MSG_FILEEXISTS]) ;
if ( r == 2 ) break ;
stream = fopen( vss_name, "wb" ) ;
if ( stream == NULL )
{
form_stop(1,msg[MSG_WRITEERROR]) ;
break ;
}
wprog = DisplayStdProg( msg[MSG_SAVEVSS], "", "", CLOSER ) ;
for ( num = 0; num < catalog_filter.nb_visibles ; num++ )
{
catalog_getfullname( num, full_name ) ;
if ( full_name[0] != 0 )
{
sprintf( buf, "Display %s\r\n", full_name ) ;
if ( fwrite( buf, strlen(buf), 1, stream ) != 1 )
{
form_stop(1,msg[MSG_WRITEERROR]) ;
break ;
}
}
if ( MAY_UPDATE( wprog, num ) )
{
sprintf( buf, "%04ld/%04ld", num, catalog_filter.nb_visibles ) ;
wprog->ProgPc( wprog, (int) ((100L*num)/(long)catalog_filter.nb_visibles), buf ) ;
}
}
fclose( stream ) ;
GWDestroyWindow( wprog ) ;
}
deselect(adr_album, obj) ;
xobjc_draw( wnd->window_handle, adr_album, obj ) ;
break ;
case ALBUM_OK : code = IDOK ;
break ;
}
if ( code == IDOK )
{
}
return( code ) ;
}
