void
CampaignPlanStrategic::BuildGroupList(CombatGroup* g, List<CombatGroup>& groups)
{
if (!g || g->IsReserve())
return;
if (g->IsAssignable())
groups.append(g);
ListIter<CombatGroup> iter = g->GetComponents();
while (++iter)
BuildGroupList(iter.value(), groups);
}
RDCutDialog::RDCutDialog(QString *cutname,QString *filter,QString *group,
QString *schedcode,bool show_clear,bool allow_add,
bool exclude_tracks,QWidget *parent)
: QDialog(parent,"",true)
{
cut_cutname=cutname;
cut_exclude_tracks=exclude_tracks;
cut_group=group;
cut_schedcode=schedcode;
cut_allow_clear=show_clear;
if(filter==NULL) {
cut_filter=new QString();
local_filter=true;
}
else {
cut_filter=filter;
local_filter=false;
}
setCaption(tr("Select Cut"));
//
// Create Icons
//
cut_playout_map=new QPixmap(play_xpm);
cut_macro_map=new QPixmap(rml5_xpm);
//
// Generate Fonts
//
QFont label_font("Helvetica",12,QFont::Bold);
label_font.setPixelSize(12);
QFont progress_font("Helvetica",16,QFont::Bold);
progress_font.setPixelSize(16);
//
// Fix the Window Size
//
setMinimumWidth(sizeHint().width());
setMaximumWidth(sizeHint().width());
setMinimumHeight(sizeHint().height());
setMaximumHeight(sizeHint().height());
//
// Progress Dialog
//
cut_progress_dialog=
new Q3ProgressDialog(tr("Please Wait..."),"Cancel",10,this,
"cut_progress_dialog",false,
Qt::WStyle_Customize|Qt::WStyle_NormalBorder);
cut_progress_dialog->setCaption(" ");
QLabel *label=new QLabel(tr("Please Wait..."),cut_progress_dialog);
label->setAlignment(Qt::AlignCenter);
label->setFont(progress_font);
cut_progress_dialog->setLabel(label);
cut_progress_dialog->setCancelButton(NULL);
cut_progress_dialog->setMinimumDuration(2000);
//
// Filter Selector
//
cut_filter_edit=new QLineEdit(this);
label=new QLabel(cut_filter_edit,tr("Cart Filter:"),this);
label->setGeometry(10,10,85,20);
label->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
label->setFont(label_font);
connect(cut_filter_edit,SIGNAL(textChanged(const QString &)),
this,SLOT(filterChangedData(const QString &)));
//
// Filter Search Button
//
cut_search_button=new QPushButton(this);
cut_search_button->setGeometry(sizeHint().width()-140,8,60,24);
cut_search_button->setText(tr("&Search"));
cut_search_button->setFont(label_font);
connect(cut_search_button,SIGNAL(clicked()),this,SLOT(searchButtonData()));
//
// Filter Clear Button
//
cut_clear_button=new QPushButton(this);
cut_clear_button->setGeometry(sizeHint().width()-70,8,60,24);
cut_clear_button->setFont(label_font);
cut_clear_button->setText(tr("C&lear"));
connect(cut_clear_button,SIGNAL(clicked()),this,SLOT(clearData()));
//
// Group Selector
//
cut_group_box=new QComboBox(this);
cut_group_box->setGeometry(100,40,140,20);
label=new QLabel(cut_filter_edit,tr("Group:"),this);
label->setGeometry(10,40,85,20);
label->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
label->setFont(label_font);
connect(cut_group_box,SIGNAL(activated(const QString &)),
this,SLOT(groupActivatedData(const QString &)));
//
// Scheduler Code Selector
//
cut_schedcode_box=new QComboBox(this);
cut_schedcode_box->setGeometry(380,40,sizeHint().width()-390,20);
cut_schedcode_label=new QLabel(cut_schedcode_box,tr("Scheduler Code:"),this);
cut_schedcode_label->setGeometry(260,40,115,20);
cut_schedcode_label->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
cut_schedcode_label->setFont(label_font);
connect(cut_schedcode_box,SIGNAL(activated(const QString &)),
this,SLOT(groupActivatedData(const QString &)));
//
// Search Limit Checkbox
//
cart_limit_box=new QCheckBox(this);
cart_limit_box->setGeometry(100,72,15,15);
cart_limit_box->setChecked(true);
label=new QLabel(cart_limit_box,tr("Show Only First")+
QString().sprintf(" %d ",
RD_LIMITED_CART_SEARCH_QUANTITY)+tr("Matches"),this);
label->setGeometry(120,70,300,20);
label->setAlignment(Qt::AlignLeft|Qt::AlignVCenter);
label->setFont(label_font);
connect(cart_limit_box,SIGNAL(stateChanged(int)),
this,SLOT(limitChangedData(int)));
//
// Cart List
//
cut_cart_list=new RDListView(this);
cut_cart_list->setGeometry(10,120,300,200);
cut_cart_list->setAllColumnsShowFocus(true);
cut_cart_list->setItemMargin(5);
connect(cut_cart_list,SIGNAL(selectionChanged()),
this,SLOT(selectionChangedData()));
connect(cut_cart_list,SIGNAL(clicked(Q3ListViewItem *)),
this,SLOT(cartClickedData(Q3ListViewItem *)));
label=new QLabel(cut_cart_list,tr("Carts"),this);
label->setGeometry(15,100,100,20);
label->setFont(label_font);
cut_cart_list->addColumn("");
cut_cart_list->setColumnAlignment(0,Qt::AlignHCenter);
cut_cart_list->addColumn(tr("Number"));
cut_cart_list->setColumnAlignment(1,Qt::AlignHCenter);
cut_cart_list->addColumn(tr("Title"));
cut_cart_list->setColumnAlignment(2,Qt::AlignLeft);
cut_cart_list->addColumn(tr("Group"));
cut_cart_list->setColumnAlignment(3,Qt::AlignCenter);
//
// Cut List
//
cut_cut_list=new Q3ListView(this);
cut_cut_list->setGeometry(320,120,sizeHint().width()-330,200);
cut_cut_list->setAllColumnsShowFocus(true);
cut_cut_list->setItemMargin(5);
label=new QLabel(cut_cut_list,tr("Cuts"),this);
label->setGeometry(325,100,100,20);
label->setFont(label_font);
cut_cut_list->addColumn(tr("Description"));
cut_cut_list->setColumnAlignment(0,Qt::AlignLeft);
cut_cut_list->addColumn(tr("Number"));
cut_cut_list->setColumnAlignment(1,Qt::AlignLeft);
QPushButton *button=NULL;
//
// Add Button
//
button=new QPushButton(tr("&Add New\nCart"),this);
button->setGeometry(10,sizeHint().height()-60,80,50);
button->setFont(label_font);
connect(button,SIGNAL(clicked()),this,SLOT(addButtonData()));
if(!allow_add) {
button->hide();
}
//
// Clear Button
//
button=new QPushButton(tr("&Clear"),this);
button->setFont(label_font);
connect(button,SIGNAL(clicked()),this,SLOT(clearButtonData()));
if(!show_clear) {
button->hide();
}
if(allow_add) {
button->setGeometry(100,sizeHint().height()-60,80,50);
}
else {
button->setGeometry(10,sizeHint().height()-60,80,50);
}
//
// OK Button
//
cut_ok_button=new QPushButton(tr("&OK"),this);
cut_ok_button->
setGeometry(sizeHint().width()-180,sizeHint().height()-60,80,50);
cut_ok_button->setFont(label_font);
cut_ok_button->setDefault(true);
connect(cut_ok_button,SIGNAL(clicked()),this,SLOT(okData()));
//
// Cancel Button
//
cut_cancel_button=new QPushButton(tr("&Cancel"),this);
cut_cancel_button->
setGeometry(sizeHint().width()-90,sizeHint().height()-60,80,50);
cut_cancel_button->setFont(label_font);
connect(cut_cancel_button,SIGNAL(clicked()),this,SLOT(cancelData()));
//
// Populate Data
//
if(cut_cutname->isEmpty()) {
cut_ok_button->setDisabled(true);
}
switch(rda->station()->filterMode()) {
case RDStation::FilterAsynchronous:
cut_search_button->setDefault(true);
cut_filter_edit->setGeometry(100,10,sizeHint().width()-250,20);
break;
case RDStation::FilterSynchronous:
cut_ok_button->setDefault(true);
cut_search_button->hide();
cut_filter_edit->setGeometry(100,10,sizeHint().width()-180,20);
}
BuildGroupList();
cut_filter_edit->setText(*cut_filter);
RefreshCarts();
RefreshCuts();
SelectCut(*cut_cutname);
}
void
CampaignPlanStrategic::AssignZones(Combatant* c)
{
// find the list of assignable groups, in priority order:
List<CombatGroup> groups;
BuildGroupList(c->GetForce(), groups);
groups.sort();
// for each group, assign a zone:
ListIter<CombatGroup> g_iter = groups;
// first pass: fighter and attack squadrons assigned to star bases
while (++g_iter) {
CombatGroup* g = g_iter.value();
int gtype = g->Type();
if (gtype == CombatGroup::ATTACK_SQUADRON ||
gtype == CombatGroup::FIGHTER_SQUADRON ||
gtype == CombatGroup::INTERCEPT_SQUADRON) {
CombatGroup* parent = g->GetParent();
if (parent && parent->Type() == CombatGroup::WING)
parent = parent->GetParent();
if (!parent || parent->Type() == CombatGroup::CARRIER_GROUP)
continue;
// these groups are attached to fixed resources,
// so they must be assigned to the parent's zone:
CombatZone* parent_zone = campaign->GetZone(parent->GetRegion());
if (parent_zone) {
ZoneForce* parent_force = parent_zone->FindForce(g->GetIFF());
if (parent_force) {
g->SetAssignedZone(parent_zone);
parent_force->AddNeed(g->Type(), -(g->Value()));
}
}
}
}
// second pass: carrier groups
g_iter.reset();
while (++g_iter) {
CombatGroup* g = g_iter.value();
int gtype = g->Type();
if (gtype == CombatGroup::CARRIER_GROUP) {
int current_zone_need = 0;
int highest_zone_need = 0;
CombatZone* highest_zone = 0;
ZoneForce* highest_force = 0;
CombatZone* current_zone = 0;
ZoneForce* current_force = 0;
List<CombatZone> possible_zones;
if (g->IsZoneLocked()) {
current_zone = g->GetAssignedZone();
current_force = current_zone->FindForce(g->GetIFF());
}
else {
ListIter<CombatZone> z_iter = campaign->GetZones();
while (++z_iter) {
CombatZone* zone = z_iter.value();
ZoneForce* force = zone->FindForce(g->GetIFF());
int need = force->GetNeed(CombatGroup::CARRIER_GROUP) +
force->GetNeed(CombatGroup::ATTACK_SQUADRON) +
force->GetNeed(CombatGroup::FIGHTER_SQUADRON) +
force->GetNeed(CombatGroup::INTERCEPT_SQUADRON);
if (g->IsSystemLocked() && zone->System() != g->GetAssignedSystem())
continue;
possible_zones.append(zone);
if (zone->HasRegion(g->GetRegion())) {
current_zone_need = need;
current_zone = zone;
current_force = force;
}
if (need > highest_zone_need) {
highest_zone_need = need;
highest_zone = zone;
highest_force = force;
}
}
}
CombatZone* assigned_zone = current_zone;
ZoneForce* assigned_force = current_force;
if (highest_zone_need > current_zone_need) {
assigned_zone = highest_zone;
assigned_force = highest_force;
}
// if we couldn't find anything suitable,
// just pick a zone at random:
if (!assigned_zone) {
if (possible_zones.isEmpty())
possible_zones.append(campaign->GetZones());
int nzones = possible_zones.size();
int n = RandomIndex() % nzones;
assigned_zone = possible_zones.at(n);
assigned_force = assigned_zone->FindForce(g->GetIFF());
}
if (assigned_force && assigned_zone) {
Text assigned_rgn;
if (!campaign->GetZone(g->GetRegion())) {
assigned_rgn = *assigned_zone->GetRegions().at(0);
g->AssignRegion(assigned_rgn);
}
g->SetAssignedZone(assigned_zone);
assigned_force->AddNeed(g->Type(), -(g->Value()));
// also assign the carrier's wing and squadrons to the same zone:
ListIter<CombatGroup> squadron = g->GetComponents();
while (++squadron) {
squadron->SetAssignedZone(assigned_zone);
assigned_force->AddNeed(squadron->Type(), -(squadron->Value()));
if (squadron->Type() == CombatGroup::WING) {
ListIter<CombatGroup> s = squadron->GetComponents();
while (++s) {
s->SetAssignedZone(assigned_zone);
assigned_force->AddNeed(s->Type(), -(s->Value()));
}
}
}
}
}
}
// third pass: everything else
g_iter.reset();
while (++g_iter) {
CombatGroup* g = g_iter.value();
int gtype = g->Type();
if (gtype == CombatGroup::BATTLE_GROUP || gtype == CombatGroup::DESTROYER_SQUADRON) {
int current_zone_need = 0;
int highest_zone_need = 0;
CombatZone* highest_zone = 0;
ZoneForce* highest_force = 0;
CombatZone* current_zone = 0;
ZoneForce* current_force = 0;
List<CombatZone> possible_zones;
if (g->IsZoneLocked()) {
current_zone = g->GetAssignedZone();
current_force = current_zone->FindForce(g->GetIFF());
}
else {
ListIter<CombatZone> z_iter = campaign->GetZones();
while (++z_iter) {
CombatZone* zone = z_iter.value();
ZoneForce* force = zone->FindForce(g->GetIFF());
int need = force->GetNeed(g->Type());
if (g->IsSystemLocked() && zone->System() != g->GetAssignedSystem())
continue;
possible_zones.append(zone);
// battle groups can do double-duty:
if (gtype == CombatGroup::BATTLE_GROUP)
need += force->GetNeed(CombatGroup::DESTROYER_SQUADRON);
if (zone->HasRegion(g->GetRegion())) {
current_zone_need = need;
current_zone = zone;
current_force = force;
}
if (need > highest_zone_need) {
highest_zone_need = need;
highest_zone = zone;
highest_force = force;
}
}
}
if (highest_zone_need > current_zone_need) {
g->SetAssignedZone(highest_zone);
if (highest_force)
highest_force->AddNeed(g->Type(), -(g->Value()));
}
else {
if (!current_zone) {
if (possible_zones.isEmpty())
possible_zones.append(campaign->GetZones());
int nzones = possible_zones.size();
int n = RandomIndex() % nzones;
current_zone = possible_zones.at(n);
current_force = current_zone->FindForce(g->GetIFF());
}
g->SetAssignedZone(current_zone);
if (current_force)
current_force->AddNeed(g->Type(), -(g->Value()));
Text assigned_rgn;
if (!campaign->GetZone(g->GetRegion())) {
assigned_rgn = *current_zone->GetRegions().at(0);
g->AssignRegion(assigned_rgn);
}
}
}
}
}
void QueueEditor::AlignAffectedGroups(DownloadQueue* pDownloadQueue, IDList* pIDList, bool bSmartOrder, int iOffset)
{
// Build list of all groups; List contains first file of each group
FileList cGroupList;
BuildGroupList(pDownloadQueue, &cGroupList);
// Find affected groups. It includes groups being moved and groups directly
// above or under of these groups (those order is also changed)
FileList cAffectedGroupList;
cAffectedGroupList.clear();
ItemList cItemList;
PrepareList(pDownloadQueue, &cItemList, pIDList, bSmartOrder, eaFileMoveOffset, iOffset);
for (ItemList::iterator it = cItemList.begin(); it != cItemList.end(); it++)
{
EditItem* pItem = *it;
unsigned int iNum = 0;
for (FileList::iterator it = cGroupList.begin(); it != cGroupList.end(); it++, iNum++)
{
FileInfo* pFileInfo = *it;
if (pItem->m_pFileInfo->GetNZBInfo() == pFileInfo->GetNZBInfo())
{
if (!ItemExists(&cAffectedGroupList, pFileInfo))
{
cAffectedGroupList.push_back(pFileInfo);
}
if (iOffset < 0)
{
for (int i = iNum - 1; i >= -iOffset-1; i--)
{
if (!ItemExists(&cAffectedGroupList, cGroupList[i]))
{
cAffectedGroupList.push_back(cGroupList[i]);
}
}
}
if (iOffset > 0)
{
for (unsigned int i = iNum + 1; i <= cGroupList.size() - iOffset; i++)
{
if (!ItemExists(&cAffectedGroupList, cGroupList[i]))
{
cAffectedGroupList.push_back(cGroupList[i]);
}
}
if (iNum + 1 < cGroupList.size())
{
cAffectedGroupList.push_back(cGroupList[iNum + 1]);
}
}
break;
}
}
delete pItem;
}
cGroupList.clear();
// Aligning groups
for (FileList::iterator it = cAffectedGroupList.begin(); it != cAffectedGroupList.end(); it++)
{
FileInfo* pFileInfo = *it;
AlignGroup(pDownloadQueue, pFileInfo->GetNZBInfo());
}
}
bool QueueEditor::EditGroup(DownloadQueue* pDownloadQueue, FileInfo* pFileInfo, EEditAction eAction, int iOffset, const char* szText)
{
IDList cIDList;
cIDList.clear();
// collecting files belonging to group
for (FileQueue::iterator it = pDownloadQueue->GetFileQueue()->begin(); it != pDownloadQueue->GetFileQueue()->end(); it++)
{
FileInfo* pFileInfo2 = *it;
if (pFileInfo2->GetNZBInfo() == pFileInfo->GetNZBInfo())
{
cIDList.push_back(pFileInfo2->GetID());
}
}
if (eAction == eaGroupMoveOffset)
{
// calculating offset in terms of files
FileList cGroupList;
BuildGroupList(pDownloadQueue, &cGroupList);
unsigned int iNum = 0;
for (FileList::iterator it = cGroupList.begin(); it != cGroupList.end(); it++, iNum++)
{
FileInfo* pGroupInfo = *it;
if (pGroupInfo->GetNZBInfo() == pFileInfo->GetNZBInfo())
{
break;
}
}
int iFileOffset = 0;
if (iOffset > 0)
{
if (iNum + iOffset >= cGroupList.size() - 1)
{
eAction = eaGroupMoveBottom;
}
else
{
for (unsigned int i = iNum + 2; i < cGroupList.size() && iOffset > 0; i++, iOffset--)
{
iFileOffset += FindFileInfoEntry(pDownloadQueue, cGroupList[i]) - FindFileInfoEntry(pDownloadQueue, cGroupList[i-1]);
}
}
}
else
{
if (iNum + iOffset <= 0)
{
eAction = eaGroupMoveTop;
}
else
{
for (unsigned int i = iNum; i > 0 && iOffset < 0; i--, iOffset++)
{
iFileOffset -= FindFileInfoEntry(pDownloadQueue, cGroupList[i]) - FindFileInfoEntry(pDownloadQueue, cGroupList[i-1]);
}
}
}
iOffset = iFileOffset;
}
else if (eAction == eaGroupDelete)
{
pFileInfo->GetNZBInfo()->SetDeleted(true);
pFileInfo->GetNZBInfo()->SetCleanupDisk(CanCleanupDisk(pDownloadQueue, pFileInfo->GetNZBInfo()));
}
EEditAction GroupToFileMap[] = { (EEditAction)0, eaFileMoveOffset, eaFileMoveTop, eaFileMoveBottom,
eaFilePause, eaFileResume, eaFileDelete, eaFilePauseAllPars, eaFilePauseExtraPars, eaFileSetPriority, eaFileReorder,
eaFileMoveOffset, eaFileMoveTop, eaFileMoveBottom, eaFilePause, eaFileResume, eaFileDelete,
eaFilePauseAllPars, eaFilePauseExtraPars, eaFileSetPriority,
(EEditAction)0, (EEditAction)0, (EEditAction)0 };
return InternEditList(pDownloadQueue, &cIDList, true, GroupToFileMap[eAction], iOffset, szText);
}
int RDCartDialog::exec(int *cartnum,RDCart::Type type,QString *svcname,
int svc_quan,const QString &username,
const QString &passwd,bool *temp_allowed)
{
LoadState();
cart_cartnum=cartnum;
cart_type=type;
cart_service=svcname;
cart_service_quan=svc_quan;
cart_user_name=username;
cart_user_password=passwd;
cart_temp_allowed=temp_allowed;
switch(cart_type) {
case RDCart::All:
case RDCart::Audio:
if(rda->station()->editorPath().isEmpty()) {
cart_editor_button->hide();
}
else {
cart_editor_button->show();
}
if(temp_allowed==NULL) {
cart_file_button->hide();
}
else {
cart_file_button->show();
}
#ifndef WIN32
if(cart_player!=NULL) {
cart_player->playButton()->show();
cart_player->stopButton()->show();
}
#endif // WIN32
break;
case RDCart::Macro:
cart_editor_button->hide();
#ifndef WIN32
if(cart_player!=NULL) {
cart_player->playButton()->hide();
cart_player->stopButton()->hide();
}
#endif // WIN32
break;
}
if(*cart_cartnum==0) {
cart_ok_button->setDisabled(true);
}
switch(cart_filter_mode) {
case RDStation::FilterAsynchronous:
cart_search_button->setDefault(true);
break;
case RDStation::FilterSynchronous:
cart_ok_button->setDefault(true);
cart_search_button->hide();
}
BuildGroupList();
cart_filter_edit->setText(*cart_filter);
RefreshCarts();
RDListViewItem *item=(RDListViewItem *)cart_cart_list->firstChild();
while(item!=NULL) {
if(item->text(1).toInt()==*cartnum) {
cart_cart_list->setSelected(item,true);
cart_cart_list->ensureItemVisible(item);
clickedData(item);
return QDialog::exec();
}
item=(RDListViewItem *)item->nextSibling();
}
return QDialog::exec();
}
