// ------------------------------------------------------------------
// GoldED+
// Copyright (C) 1990-1999 Odinn Sorensen
// Copyright (C) 1999-2000 Alexander S. Aganichev
// ------------------------------------------------------------------
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston,
// MA 02111-1307 USA
// ------------------------------------------------------------------
// $Id$
// ------------------------------------------------------------------
// Arealister and other area-specific code
// ------------------------------------------------------------------
#include <golded.h>
#include <gutlos.h>
// ------------------------------------------------------------------
extern int arealistnumgrps;
bool in_arealist = false;
GPickArealist* PickArealist;
Echo area_maybe;
int areaswithgroupid = 0;
uint* areanumbers = NULL;
// 111111111122222222223333333333444444444455555555556666666666777777777
// 0123456789012345678901234567890123456789012345678901234567890123456789012345678
// ��Area�Description�������������������������Msgs���New��EchoID��������������GrpĿ
// � 1> NET FidoNet Z3/4/5/6 118+ 3* NET.FIDOZX A �
// AREALISTFORMAT "AM D CPUN E G"
int area_pos = -1;
int area_width = 4;
int marked_pos = -1;
int marked_width = 1;
const char marked_char = MMRK_MARK;
int desc_pos = -1;
int desc_width = -1;
int count_pos = -1;
int count_width = 6;
int pmark_pos = -1;
int pmark_width = 1;
const char pmark_char = '+';
int unread_pos = -1;
int unread_width = 6;
int changed_pos = -1;
int changed_width = 1;
const char changed_char = '*';
int echoid_pos = -1;
int echoid_width = 0;
int groupid_pos = -1;
int groupid_width = 0;
// ------------------------------------------------------------------
GPickArealist::GPickArealist() {
areawin1 = 0;
areawin2 = 0;
tempwin1 = 0;
tempwin2 = 0;
pmails = 0;
pmareas = 0;
pmscan = false;
area_fuzidx = 0;
}
// ------------------------------------------------------------------
void GPickArealist::AreasRenumber() {
for(int n=0,a=1,t=AL.size(); n<t; n++)
areanumbers[n] = AL[n]->isseparator() ? 0 : a++;
}
// ------------------------------------------------------------------
bool GPickArealist::is_selectable(uint idx) {
Area* area = AL.AreaNoToPtr(idx);
return (not area->isseparator());
}
// ------------------------------------------------------------------
void GPickArealist::do_delayed() {
Area* area = AL.AreaNoToPtr(index);
char buf[256], tmp[200];
strcpy(tmp, area->echoid());
update_statuslinef("%s: %u %s, %u %s, %u %s", "", tmp, area->Msgn.Count(), (area->Msgn.Count() == 1 ? LNG->msg : LNG->msgs), area->unread, LNG->unread, area->PMrk.Count(), LNG->personal);
strcpy(stpcpy(buf, title), area_maybe);
strsetsz(strcpy(tmp, buf), MAXCOL);
wwprintstr(tempwin, 0, 0, wattr, tmp);
if(CFG->switches.get(arealistpagebar))
wscrollbar(W_VERT, maximum_index+1, maximum_index, index);
}
// ------------------------------------------------------------------
void GPickArealist::close_all() {
if(areawin1)
wunlink(areawin1);
if(areawin2)
wunlink(areawin2);
if(tempwin1)
wunlink(tempwin1);
if(tempwin2)
wunlink(tempwin2);
}
// ------------------------------------------------------------------
void GPickArealist::dispbuf(char* buf, int areano) {
Area* area = AL.AreaNoToPtr(areano);
memset(buf, ' ', MAXCOL-2);
buf[MAXCOL-2] = NUL;
char areabuf[33];
sprintf(areabuf, "%u", CFG->switches.get(arealistnos) ? area->board() : areanumbers[areano]);
int areawidth = strlen(areabuf);
char markedbuf[2] = { " " };
*markedbuf = area->ismarked() ? marked_char : ' ';
int markedwidth = 1;
char descbuf[100];
int descwidth = strlen(strcpy(descbuf, area->desc()));
char countbuf[33];
if(area->isscanned)
sprintf(countbuf, "%u", (uint)area->Msgn.Count());
else
strcpy(countbuf, "-");
int countwidth = strlen(countbuf);
char pmarkbuf[2] = { " " };
*pmarkbuf = area->PMrk.Count() ? pmark_char : ' ';
int pmarkwidth = 1;
char unreadbuf[33];
if(area->isscanned)
sprintf(unreadbuf, "%u", (uint)((CFG->arealisttype == AL_TOTNEW) ? area->unread : area->lastread()));
else
strcpy(unreadbuf, "-");
int unreadwidth = strlen(unreadbuf);
char changedbuf[2] = { " " };
*changedbuf = area->isunreadchg ? changed_char : ' ';
int changedwidth = 1;
char echoidbuf[100];
int echoidwidth = strlen(strcpy(echoidbuf, area->echoid()));
char groupidbuf[10] = { "" };
if(groupid_width) {
if(area->groupid() & 0x8000u) {
if(groupid_width > 2)
sprintf(groupidbuf, "%u", area->groupid()&0x7FFF);
}
else if(g_isupper(area->groupid()))
sprintf(groupidbuf, "%c", (char)area->groupid());
}
int groupidwidth = strlen(groupidbuf);
areawidth = MinV(areawidth, area_width);
markedwidth = MinV(markedwidth, marked_width);
descwidth = MinV(descwidth, desc_width);
countwidth = MinV(countwidth, count_width);
pmarkwidth = MinV(pmarkwidth, pmark_width);
unreadwidth = MinV(unreadwidth, unread_width);
changedwidth = MinV(changedwidth, changed_width);
echoidwidth = MinV(echoidwidth, echoid_width);
groupidwidth = MinV(groupidwidth, groupid_width);
memcpy(buf+area_pos+area_width-areawidth, areabuf, areawidth);
memcpy(buf+marked_pos, markedbuf, markedwidth);
memcpy(buf+desc_pos, descbuf, descwidth);
memcpy(buf+count_pos+count_width-countwidth, countbuf, countwidth);
memcpy(buf+pmark_pos, pmarkbuf, pmarkwidth);
memcpy(buf+unread_pos+unread_width-unreadwidth, unreadbuf, unreadwidth);
memcpy(buf+changed_pos, changedbuf, changedwidth);
memcpy(buf+echoid_pos, echoidbuf, echoidwidth);
memcpy(buf+groupid_pos+groupid_width-groupidwidth, groupidbuf, groupidwidth);
}
// ------------------------------------------------------------------
void GPickArealist::center() {
uint room, toproom, botroom;
toproom = index;
botroom = maximum_index - index;
if(toproom > maximum_position/2) {
if(botroom > maximum_position/2)
room = maximum_position/2;
else if(botroom)
room = maximum_position - botroom;
else
room = maximum_position;
}
else
room = toproom;
position = room;
display_page();
}
// ------------------------------------------------------------------
void GPickArealist::jump_to() {
uint n = index+1;
bool found = false;
// Search for next marked area, wrapping 'round if needed
for(; n<=maximum_index; n++) {
if(not AL[n]->isseparator() and AL[n]->ismarked()) {
found = true;
break;
}
}
if(not found) {
for(n = minimum_index; n <= index; n++) {
if(not AL[n]->isseparator() and AL[n]->ismarked())
break;
}
}
if(n > maximum_index)
n = minimum_index;
while(AL[n]->isseparator()) {
if((++n) > maximum_index)
n = minimum_index;
}
index = n;
center();
}
// ------------------------------------------------------------------
void GPickArealist::jumpmatch() {
uint n = index+1;
bool found = false;
// Search for next marked area, wrapping 'round if needed
for(; n<=maximum_index; n++) {
if(not AL[n]->isseparator() and (strnieql(area_maybe, AL[n]->echoid(), area_fuzidx) or striinc(area_maybe, AL[n]->echoid()))) {
found = true;
break;
}
}
if(not found) {
for(n = minimum_index; n <= index; n++) {
if(not AL[n]->isseparator() and (strnieql(area_maybe, AL[n]->echoid(), area_fuzidx) or striinc(area_maybe, AL[n]->echoid())))
break;
}
}
if(n > maximum_index)
n = minimum_index;
while(AL[n]->isseparator()) {
if((++n) > maximum_index)
n = minimum_index;
}
index = n;
center();
}
// ------------------------------------------------------------------
void GPickArealist::open() {
int active=NO;
#if defined(GUTLOS_FUNCS)
g_set_ostitle_name("Arealist",0);
#endif
if(ypos) {
if(tempwin1) {
tempwin = tempwin1;
areawin = areawin1;
active = YES;
}
}
else {
if(tempwin2) {
tempwin = tempwin2;
areawin = areawin2;
active = YES;
}
}
if(active) {
wunhide(tempwin);
wprints(0,0, wattr, title);
wunhide(areawin);
}
else {
tempwin = wopen_(ypos, xpos, 1, MAXCOL, 5, battr, wattr, sbattr);
wprints(0,0, wattr, title);
areawin = wopen_(ypos+1, xpos, ylen+2, MAXCOL, btype, battr, wattr, sbattr);
if(ypos) {
tempwin1 = tempwin;
areawin1 = areawin;
}
else {
tempwin2 = tempwin;
areawin2 = areawin;
}
if(area_width)
wmessage(LNG->Area, TP_BORD, 1+area_pos+(marked_pos==area_pos+area_width?1:0), tattr);
if(desc_width)
wmessage(LNG->Description, TP_BORD, 1+desc_pos, tattr);
if(count_width)
wmessage(LNG->Msgs, TP_BORD, 1+count_pos+count_width-strlen(LNG->Msgs), tattr);
if(unread_width) {
if(CFG->arealisttype == AL_TOTLST)
wmessage(LNG->Last, TP_BORD, 1+unread_pos+unread_width-strlen(LNG->Last), tattr);
else if(CFG->arealisttype == AL_TOTNEW)
wmessage(LNG->New, TP_BORD, 1+unread_pos+unread_width-strlen(LNG->New), tattr);
}
if(echoid_width)
wmessage(LNG->EchoID, TP_BORD, 1+echoid_pos, tattr);
if(groupid_width) {
char grpbuf[40];
if(groupid_width > 2)
strcpy(grpbuf, LNG->Grp);
else {
*grpbuf = *(LNG->Grp);
grpbuf[1] = NUL;
}
wmessage(grpbuf, TP_BORD, 1+groupid_pos, tattr);
}
}
if(CFG->switches.get(areaautonext) and ypos == 0 and index >= minimum_index and not AL[index]->ismarked()) {
jump_to();
}
else
center();
}
// ------------------------------------------------------------------
void GPickArealist::close() {
whide();
whide();
}
// ------------------------------------------------------------------
void GPickArealist::precursor() {
*area_maybe = 0;
area_fuzidx = 0;
}
// ------------------------------------------------------------------
void GPickArealist::print_line(uint idx, uint pos, bool isbar) {
vchar vbuf[256];
char buf[256];
if(AL[idx]->isseparator()) {
Area* area = AL.AreaNoToPtr(idx);
int sep_pos = (desc_pos != -1) ? desc_pos : echoid_pos;
{for(int c = 0; c < sep_pos; c++)
vbuf[c] = _box_table(btype, 1);}
vbuf[sep_pos] = NUL;
wprintvs(pos, 0, battr|ACSET, vbuf);
wprints(pos, sep_pos, tattr, area->desc());
int l = strlen(area->desc());
int n = MAXCOL-2-sep_pos-l;
{for(int c = 0; c < n; c++)
vbuf[c] = _box_table(btype,1);}
vbuf[n] = NUL;
wprintvs(pos, sep_pos+l, battr|ACSET, vbuf);
}
else {
dispbuf(buf, idx);
wprints(pos, 0, isbar ? sattr : wattr, buf);
if(AL[idx]->ismarked())
wprintc(pos, marked_pos, isbar ? sattr : hattr, marked_char);
}
}
// ------------------------------------------------------------------
void GPickArealist::AreaCatchUp(uint n) {
// Do not do catch up if there's active area
if(AA->isopen())
return;
GMenuAreaCatchup MenuAreaCatchup;
GMsg* msg = (GMsg*)throw_calloc(1, sizeof(GMsg));
int mode = MenuAreaCatchup.Run();
if(mode != SCAN_QUIT) {
for(AL.item = AL.idx.begin(); AL.item != AL.idx.end(); AL.item++) {
if((mode == SCAN_MARKED and (*AL.item)->ismarked()) or mode == SCAN_ALL or (mode == SCAN_CURRENT and (*AL.item) == AL[n])) {
if((*AL.item)->isseparator())
continue;
update_statuslinef("%s ...", "", (*AL.item)->echoid());
AA = (*AL.item);
AA->Open();
if(CFG->switches.get(highlightunread) and CFG->switches.get(areacatchupread)) {
w_info(LNG->Wait);
for(uint i=AA->lastread()+1; i <= AA->Msgn.Count(); i++) {
AA->LoadHdr(msg, AA->Msgn.CvtReln(i), false);
if(msg->timesread++ == 0)
AA->UpdateTimesread(msg);
}
w_info(NULL);
}
AA->set_lastread(AA->Msgn.Count());
AA->isvalidchg = false;
AA->Close();
}
}
}
throw_free(msg);
}
// ------------------------------------------------------------------
void GPickArealist::AreaDropMsgMarks(uint n) {
GMenuAreaDropMarks MenuAreaDropMarks;
uint nummarks = 0;
for(AL.item = AL.idx.begin(); AL.item != AL.idx.end(); AL.item++)
nummarks += (*AL.item)->Mark.Count();
char buf[256];
sprintf(buf, LNG->DropMarksInfo, longdotstr(nummarks));
w_info(buf);
int mode = MenuAreaDropMarks.Run();
w_info(NULL);
if(mode != SCAN_QUIT) {
for(AL.item = AL.idx.begin(); AL.item != AL.idx.end(); AL.item++) {
if((mode == SCAN_MARKED and (*AL.item)->ismarked()) or mode == SCAN_ALL or (mode == SCAN_CURRENT and (*AL.item) == AL[n])) {
if((*AL.item)->isseparator())
continue;
(*AL.item)->Mark.ResetAll();
}
}
}
}
// ------------------------------------------------------------------
bool GPickArealist::handle_key() {
uint n;
uint x;
const char* adesc;
char buf[256], tmp[256];
int mode, changed, currno;
gkey kk;
if(key < KK_Commands) {
key = key_tolower(key);
if((key == Key_Esc) and esc_abort)
key = KK_AreaAbort;
else {
kk = SearchKey(key, AreaKey, AreaKeys);
if(kk)
key = kk;
}
}
switch(key) {
case KK_AreaDropMsgMarks:
AreaDropMsgMarks(index);
break;
case KK_AreaSelectMarks:
AL.Select_Mask();
break;
case KK_AreaAskExit:
{
GMenuQuit MenuQuit;
aborted = gkbd.quitall = (MenuQuit.Run()!=0);
if(gkbd.quitall) {
precursor();
return false;
}
}
break;
case KK_AreaAbort:
aborted = true;
// Drop Through
case KK_AreaSelect:
if(AL[index]->isseparator()) {
if(not PlayMacro(key, KT_A))
SayBibi();
break;
}
precursor();
return false;
case KK_AreaQuitNow:
aborted = gkbd.quitall = true;
precursor();
return false;
case KK_AreaToggle:
AL[index]->set_marked(not AL[index]->ismarked());
display_bar();
precursor();
cursor_down();
break;
case KK_AreaMark:
AL[index]->set_marked(true);
display_bar();
precursor();
cursor_down();
break;
case KK_AreaUnmark:
AL[index]->set_marked(false);
display_bar();
precursor();
cursor_down();
break;
case KK_AreaBoardnos:
CFG->switches.set(arealistnos, not CFG->switches.get(arealistnos));
update();
break;
case KK_AreaCatchUp:
AreaCatchUp(index);
update();
break;
case KK_AreaJumpNextMatch:
jumpmatch();
break;
case KK_AreaJump:
{
precursor();
jump_to();
}
break;
case KK_AreaDosShell:
DosShell();
break;
case KK_AreaGotoPrev: precursor(); cursor_up(); break;
case KK_AreaGotoNext: precursor(); cursor_down(); break;
case KK_AreaGotoFirst: precursor(); cursor_first(); break;
case KK_AreaGotoLast: precursor(); cursor_last(); break;
case KK_AreaSoundkill:
HandleGEvent(EVTT_STOPVOICE);
break;
case KK_AreaTouchNetscan:
TouchNetscan();
break;
case KK_AreaHeat:
{
GMenuAreaHeat MenuAreaHeat;
mode = MenuAreaHeat.Run();
if(mode != SCAN_QUIT) {
for(AL.item = AL.idx.begin(); AL.item != AL.idx.end(); AL.item++) {
if((mode == SCAN_MARKED and (*AL.item)->ismarked()) or mode == SCAN_ALL or (mode == SCAN_CURRENT and (*AL.item) == AL[index-1])) {
update_statuslinef("%s %s", "", 1+LNG->ScanningArea, (*AL.item)->echoid());
(*AL.item)->SetHighwaterMark();
}
}
}
}
break;
case KK_AreaZap:
{
GMenuAreaZap MenuAreaZap;
mode = MenuAreaZap.Run();
if(mode != SCAN_QUIT) {
for(AL.item = AL.idx.begin(); AL.item != AL.idx.end(); AL.item++) {
if((mode == SCAN_MARKED and (*AL.item)->ismarked()) or mode == SCAN_ALL or (mode == SCAN_CURRENT and (*AL.item) == AL[index-1])) {
update_statuslinef("%s %s", "", 1+LNG->ScanningArea, (*AL.item)->echoid());
(*AL.item)->ResetHighwaterMark();
}
}
}
}
break;
case KK_AreaScanPM:
pmscan = true;
pmails = 0;
pmareas = 0;
// DROP THROUGH //
case KK_AreaScan:
{
currno = index;
GMenuAreaScan MenuAreaScan;
mode = MenuAreaScan.Run(pmscan);
if(mode != SCAN_QUIT) {
w_info(LNG->Wait);
strcpy(stecho, AL[index]->echoid());
if(mode == SCAN_IMPORTQWK)
changed = ImportQWK();
else if(mode == SCAN_EXPORTQWK)
changed = ExportQWK();
else if(mode == SCAN_IMPORTSOUP)
changed = ImportSOUP();
else if(mode == SCAN_EXPORTSOUP)
changed = ExportSOUP();
else {
if(cmdlinedebughg)
LOG.printf("- AreaScan from arealist");
changed = AL.AreaScan(mode, currno, pmscan, pmails, pmareas);
}
w_info();
AL.SetActiveAreaNo(currno);
if(changed) {
AL.Sort();
AreasRenumber();
index = AL.AreaEchoToNo(stecho);
center();
}
if(pmscan) {
if(pmails) {
w_infof(LNG->FoundPersonal,
pmails, (pmails==1?"":"s"),
pmareas, (pmareas==1?"":"s")
);
}
else {
w_info(LNG->NoPersonal);
}
waitkeyt(10000);
w_info();
}
}
pmscan = false;
}
break;
case Key_Tick:
CheckTick(KK_AreaQuitNow);
break;
case KK_AreaUndefine:
break;
case KK_AreaWriteGoldlast:
w_info(LNG->Wait);
AL.WriteGoldLast();
w_info();
break;
default:
if(key < KK_Macro) {
n = g_toupper(key & 0xFF);
if((area_fuzidx < area_maxfuz) or (key == Key_BS)) {
// Incremental search in the echoids
if(not iscntrl(n) or (key == Key_BS)) {
if(n == ' ')
n = '_';
if(key != Key_BS)
area_maybe[area_fuzidx++] = (char)n;
else if(area_fuzidx)
area_fuzidx--;
area_maybe[area_fuzidx] = NUL;
strcpy(stpcpy(buf, title), area_maybe);
strsetsz(strcpy(tmp, buf), MAXCOL);
wwprintstr(tempwin, 0, 0, wattr, tmp);
if(area_fuzidx) {
x = atoi(area_maybe);
if(x) {
if(CFG->switches.get(arealistnos) and (isdigit(area_maybe[1]) or (area_maybe[1] == NUL))) {
for(n=0; n<AL.size(); n++) {
if(AL[n]->board() == x) {
x = n;
goto RedrawAreas;
}
}
x = 0; // No match found
}
else {
for(n=0; n<area_fuzidx; n++) {
if(not isdigit(area_maybe[n])) {
x = 0;
break;
}
}
}
}
if(x >= 1 and x<=AL.size()) {
{
for(int a=0, at=AL.size(); a<at; a++) {
if(areanumbers[a] == x) {
x = a;
goto RedrawAreas;
}
}
}
x = (uint)-1;
RedrawAreas:
if(x == (uint)-1)
x = index;
while(AL[x]->isseparator()) {
x++;
if(x > maximum_index)
x = minimum_index;
}
if(x != index)
display_line();
#define _topidx (index-position) // Shorthand..
#define _botidx (index+(maximum_position-position)) // Shorthand..
if((_topidx <= x) and (x <= _botidx)) {
position += (x-index);
index = x;
display_page(); /////////// NEW
}
else {
index = x;
center();
}
break;
}
else {
// Regular search
for(n=0; n<AL.size(); n++) {
adesc = AL[n]->echoid();
if(strnicmp(area_maybe, adesc, area_fuzidx) == 0) {
AL.Sort();
AreasRenumber();
x = AL.AreaEchoToNo(adesc);
goto RedrawAreas;
}
}
// Search inside
for(n=0; n<AL.size(); n++) {
adesc = AL[n]->echoid();
if(striinc(area_maybe, adesc)) {
AL.Sort();
AreasRenumber();
x = AL.AreaEchoToNo(adesc);
goto RedrawAreas;
}
}
}
}
else {
adesc = AL[index]->echoid();
AL.Sort();
AreasRenumber();
index = AL.AreaEchoToNo(adesc);
center();
}
break;
}
}
}
if(not PlayMacro(key, KT_A))
SayBibi();
}
return true;
}
// ------------------------------------------------------------------
int GPickArealist::Run(const char* _title, int wpos, int& idx) {
HandleGEvent(EVTT_AREALIST);
xpos = 0; // Window starting coloumn
ypos = wpos; // Window starting row
xlen = MAXCOL-2; // Window ending coloumn
ylen = MAXROW-wpos-4; // Window ending row
title = _title; // Window title
btype = W_BAREA; // Window border type
battr = C_AREAB; // Window border attributes
wattr = C_AREAW; // Window Color
tattr = C_AREAT; // Window Title Color
sattr = C_AREAS; // Window Selection Bar Color
hattr = C_AREAQ; // Window Highlight Color
sbattr = C_AREAPB; // Window Scrollbar Color
helpcat = H_Area; // Window Help Category
maximum_index = AL.size() - 1; // List Entries - 1
maximum_position = MinV((size_t)ylen-1, AL.size()-1); // Display Pos
index = AL.AreaIdToNo(idx); // List Index
listwrap = CFG->switches.get(displistwrap); // True if wrap-around is supported
esc_abort = (wpos!=0);
area_maxfuz = MinV(sizeof(Echo), MAXCOL-strlen(title)-1);
goldmark = ' ';
areanumbers = (uint*)throw_calloc(AL.size(), sizeof(uint));
AreasRenumber();
run_picker();
throw_release(areanumbers);
if(not aborted)
return AL[index]->areaid();
idx = AL[index]->areaid();
return -1;
}
// ------------------------------------------------------------------
int AreaPick(char* title, int wpos, int* idx) {
GPickArealist p;
int new_area;
if(gkbd.quitall)
return -1;
PickArealist = &p;
in_arealist = true;
new_area = p.Run(title, wpos, *idx);
in_arealist = false;
PickArealist = NULL;
return new_area;
}
// ------------------------------------------------------------------