~ubuntu-branches/ubuntu/vivid/kate/vivid-updates

void KateFileTreeModel::documentModifiedOnDisc(KTextEditor::Document *doc, bool modified, KTextEditor::ModificationInterface::ModifiedOnDiskReason reason )

730

{

731

Q_UNUSED(modified);

732

kDebug(debugArea()) << "BEGIN!";

733

ProxyItem *item = m_docmap[doc];

734

if(!item)

735

return;

736

737

// This didn't do what I thought it did, on an ignore

738

// we'd get !modified causing the warning icons to disappear

739

if(!modified) {

740

item->clearFlag(ProxyItem::ModifiedExternally);

741

item->clearFlag(ProxyItem::DeletedExternally);

742

} else {

743

if(reason == KTextEditor::ModificationInterface::OnDiskDeleted) {

744

item->setFlag(ProxyItem::DeletedExternally);

745

kDebug(debugArea()) << "deleted!";

746

}

747

else if(reason == KTextEditor::ModificationInterface::OnDiskModified) {

748

item->setFlag(ProxyItem::ModifiedExternally);

749

kDebug(debugArea()) << "modified!";

750

}

751

else if(reason == KTextEditor::ModificationInterface::OnDiskCreated) {

752

kDebug(debugArea()) << "created!";

753

// with out this, on "reload" we don't get the icons removed :(

754

item->clearFlag(ProxyItem::ModifiedExternally);

755

item->clearFlag(ProxyItem::DeletedExternally);

756

}

757

}

758

759

setupIcon(item);

760

761

QModelIndex idx = createIndex(item->row(), 0, item);

762

emit dataChanged(idx, idx);

763

kDebug(debugArea()) << "END!";

764

}

765

766

void KateFileTreeModel::documentActivated(KTextEditor::Document *doc)

767

{

768

kDebug(debugArea()) << "BEGIN!";

769

770

if(!m_docmap.contains(doc)) {

771

kDebug(debugArea()) << "invalid doc" << doc;

772

return;

773

}

774

775

ProxyItem *item = m_docmap[doc];

776

kDebug(debugArea()) << "adding viewHistory" << item;

777

m_viewHistory.removeAll(item);

778

m_viewHistory.prepend(item);

779

780

while (m_viewHistory.count() > 10) m_viewHistory.removeLast();

781

782

updateBackgrounds();

783

784

kDebug(debugArea()) << "END!";

785

}

786

787

void KateFileTreeModel::documentEdited(KTextEditor::Document *doc)

788

{

789

kDebug(debugArea()) << "BEGIN!";

790

791

if(!m_docmap.contains(doc)) {

792

kDebug(debugArea()) << "invalid doc" << doc;

793

return;

794

}

795

796

ProxyItem *item = m_docmap[doc];

797

kDebug(debugArea()) << "adding editHistory" << item;

798

m_editHistory.removeAll(item);

799

m_editHistory.prepend(item);

800

while (m_editHistory.count() > 10) m_editHistory.removeLast();

801

802

updateBackgrounds();

803

804

kDebug(debugArea()) << "END!";

805

}

806

807

void KateFileTreeModel::slotAboutToDeleteDocuments(const QList<KTextEditor::Document*> &docs)

808

{

809

foreach (const KTextEditor::Document *doc, docs) {

810

disconnect(doc, SIGNAL(documentNameChanged(KTextEditor::Document*)), this, SLOT(documentNameChanged(KTextEditor::Document*)));

811

disconnect(doc, SIGNAL(documentUrlChanged(KTextEditor::Document*)), this, SLOT(documentNameChanged(KTextEditor::Document*)));

812

disconnect(doc, SIGNAL(modifiedChanged(KTextEditor::Document*)), this, SLOT(documentModifiedChanged(KTextEditor::Document*)));

813

disconnect(doc, SIGNAL(modifiedOnDisk(KTextEditor::Document*,bool,KTextEditor::ModificationInterface::ModifiedOnDiskReason)),

814

this, SLOT(documentModifiedOnDisc(KTextEditor::Document*,bool,KTextEditor::ModificationInterface::ModifiedOnDiskReason)) );

815

}

816

}

817

818

void KateFileTreeModel::slotDocumentsDeleted(const QList<KTextEditor::Document*> &docs)

819

{

820

foreach (const KTextEditor::Document *doc, docs) {

821

connectDocument(doc);

822

}

823

}

824

825

class EditViewCount

826

{

827

public:

828

EditViewCount(): edit(0), view(0)

829

{}

830

int edit;

831

int view;

832

};

833

834

void KateFileTreeModel::updateBackgrounds(bool force)

835

{

836

if (!m_shadingEnabled && !force) return;

837

838

kDebug(debugArea()) << "BEGIN!";

839

840

QMap <ProxyItem *, EditViewCount> helper;

841

int i = 1;

842

843

foreach (ProxyItem *item, m_viewHistory)

844

{

845

helper[item].view = i;

846

if(!m_debugmap.contains(item)) {

847

kDebug(debugArea()) << "m_viewHistory contains an item that doesn't exist?" << item;

848

}

849

i++;

850

}

851

852

i = 1;

853

foreach (ProxyItem *item, m_editHistory)

854

{

855

helper[item].edit = i;

856

if(!m_debugmap.contains(item)) {

857

kDebug(debugArea()) << "m_editHistory contains an item that doesn't exist?" << item;

858

}

859

i++;

860

}

861

862

kDebug(debugArea()) << "m_editHistory contains " << m_editHistory.count()<<" elements";

863

864

QMap<ProxyItem *, QBrush> oldBrushes = m_brushes;

865

m_brushes.clear();

866

867

int hc = m_viewHistory.count();

868

int ec = m_editHistory.count();

869

870

for (QMap<ProxyItem *, EditViewCount>::iterator it = helper.begin();it != helper.end();++it)

871

{

872

QColor shade( m_viewShade );

873

QColor eshade( m_editShade );

874

875

if (it.value().edit > 0)

876

{

877

int v = hc - it.value().view;

878

int e = ec - it.value().edit + 1;

879

880

e = e * e;

881

882

int n = qMax(v + e, 1);

883

884

shade.setRgb(

885

((shade.red()*v) + (eshade.red()*e)) / n,

886

((shade.green()*v) + (eshade.green()*e)) / n,

887

((shade.blue()*v) + (eshade.blue()*e)) / n

888

);

889

}

890

891

// blend in the shade color; latest is most colored.

892

double t = double(hc - it.value().view + 1) / double(hc);

893

894

m_brushes[it.key()] = QBrush(KColorUtils::mix(QPalette().color(QPalette::Base), shade, t));

895

// kdDebug()<<"m_brushes[it.key()]"<<it.key()<<m_brushes[it.key()];

896

}

897

898

foreach(ProxyItem *item, m_brushes.keys())

899

{

900

oldBrushes.remove(item);

901

QModelIndex idx = createIndex(item->row(), 0, item);

902

dataChanged(idx, idx);

903

}

904

905

foreach(ProxyItem *item, oldBrushes.keys())

906

{

907

QModelIndex idx = createIndex(item->row(), 0, item);

908

dataChanged(idx, idx);

909

}

910

911

kDebug(debugArea()) << "END!";

912

}

913

914

void KateFileTreeModel::handleEmptyParents(ProxyItemDir *item)

915

{

916

kDebug(debugArea()) << "BEGIN!";

917

Q_ASSERT(item != 0);

918

919

if(!item || !item->parent()) {

920

kDebug(debugArea()) << "parent" << item << "grandparent" << (item ? item->parent() : 0);

921

return;

922

}

923

924

ProxyItemDir *parent = item->parent();

925

//emit layoutAboutToBeChanged();

926

927

kDebug(debugArea()) << "item" << item << "parent" << parent;

928

while(parent) {

929

930

kDebug(debugArea()) << "item" << item << "parent" << parent;

931

if(!item->childCount()) {

932

QModelIndex parent_index = parent == m_root ? QModelIndex() : createIndex(parent->row(), 0, parent);

933

beginRemoveRows(parent_index, item->row(), item->row());

934

parent->remChild(item);

935

endRemoveRows();

936

kDebug(debugArea()) << "deleted" << item;

937

delete item;

938

}

939

else {

940

// breakout early, if this node isn't empty, theres no use in checking its parents

941

kDebug(debugArea()) << "END!";

942

return;

943

}

944

945

item = parent;

946

parent = item->parent();

947

}

948

949

//emit layoutChanged();

950

kDebug(debugArea()) << "END!";

951

}

952

953

void KateFileTreeModel::documentClosed(KTextEditor::Document *doc)

954

{

955

QString path = doc->url().path();

956

957

if(!m_docmap.contains(doc)) {

958

kDebug(debugArea()) << "docmap doesn't contain doc" << doc;

959

return;

960

}

961

962

kDebug(debugArea()) << path << m_docmap[doc];

963

964

if(m_shadingEnabled) {

965

ProxyItem *toRemove = m_docmap[doc];

966

if(m_brushes.contains(toRemove)) {

967

m_brushes.remove(toRemove);

968

kDebug(debugArea()) << "removing brush" << toRemove;

969

}

970

971

if(m_viewHistory.contains(toRemove)) {

972

m_viewHistory.removeAll(toRemove);

973

kDebug(debugArea()) << "removing viewHistory" << toRemove;

974

}

975

976

if(m_editHistory.contains(toRemove)) {

977

m_editHistory.removeAll(toRemove);

978

kDebug(debugArea()) << "removing editHistory" << toRemove;

979

}

980

}

981

982

ProxyItem *node = m_docmap[doc];

983

ProxyItemDir *parent = node->parent();

984

985

QModelIndex parent_index = parent == m_root ? QModelIndex() : createIndex(parent->row(), 0, parent);

986

beginRemoveRows(parent_index, node->row(), node->row());

987

node->parent()->remChild(node);

988

endRemoveRows();

989

990

m_debugmap.remove(node);

991

992

delete node;

993

handleEmptyParents(parent);

994

995

m_docmap.remove(doc);

996

}

997

998

void KateFileTreeModel::documentNameChanged(KTextEditor::Document *doc)

999

{

1000

kDebug(debugArea()) << "BEGIN!";

1001

1002

if(!m_docmap.contains(doc)) {

1003

kDebug(debugArea()) << "docmap doesn't contain doc" << doc;

1004

return;

1005

}

1006

1007

ProxyItem *item = m_docmap[doc];

1008

QString path = doc->url().path();

1009

QString host;

1010

if(doc->url().isEmpty()) {

1011

kDebug(debugArea()) << "change to unnamed item";

1012

path = doc->documentName();

1013

item->setFlag(ProxyItem::Empty);

1014

}

1015

else {

1016

item->clearFlag(ProxyItem::Empty);

1017

host=doc->url().host();

1018

if (!host.isEmpty())

1019

path="["+host+"]"+path;

1020

}

1021

1022

kDebug(debugArea()) << item;

1023

kDebug(debugArea()) << item->display() << "->" << path;

1024

1025

1026

if(m_shadingEnabled) {

1027

ProxyItem *toRemove = m_docmap[doc];

1028

if(m_brushes.contains(toRemove)) {

1029

QBrush brush=m_brushes[toRemove];

1030

m_brushes.remove(toRemove);

1031

m_brushes.insert(item,brush);

1032

kDebug(debugArea()) << "removing brush" << toRemove;

1033

}

1034

1035

if(m_viewHistory.contains(toRemove)) {

1036

int idx=m_viewHistory.indexOf(toRemove);

1037

if (idx!=-1)

1038

m_viewHistory.replace(idx,item);

1039

kDebug(debugArea()) << "removing/replacing view history" << toRemove;

1040

}

1041

1042

if(m_editHistory.contains(toRemove)) {

1043

int idx=m_editHistory.indexOf(toRemove);

1044

if (idx!=-1)

1045

m_editHistory.replace(idx,item);

1046

kDebug(debugArea()) << "removing/replacing edit history" << toRemove;

1047

}

1048

}

1049

1050

handleNameChange(item, path, host);

1051

1052

triggerViewChangeAfterNameChange();

1053

1054

kDebug(debugArea()) << "END!";

1055

}

1056

1057

ProxyItemDir *KateFileTreeModel::findRootNode(const QString &name, int r)

1058

{

1059

QString base = name.section(QLatin1Char('/'), 0, -2);

1060

foreach(ProxyItem *item, m_root->children()) {

1061

QString path = item->path().section(QLatin1Char('/'), 0, -r);

1062

if (!item->flag(ProxyItem::Host) && !QFileInfo(path).isAbsolute()) {

1063

continue;

1064

}

1065

1066

// make sure we're actually matching against the right dir,

1067

// previously the check below would match /foo/xy against /foo/x

1068

// and return /foo/x rather than /foo/xy

1069

// this seems a bit hackish, but is the simplest way to solve the

1070

// current issue.

1071

path += QLatin1Char('/');

1072

1073

if(name.startsWith(path) && item->flag(ProxyItem::Dir)) {

1074

return static_cast<ProxyItemDir*>(item);

1075

}

1076

}

1077

1078

return 0;

1079

}

1080

1081

ProxyItemDir *KateFileTreeModel::findChildNode(ProxyItemDir *parent, const QString &name)

1082

{

1083

Q_ASSERT(parent != 0);

1084

1085

if(!parent || !parent->childCount()) {

1086

kDebug(debugArea()) << "invalid parent or no children" << parent;

1087

return 0;

1088

}

1089

1090

foreach(ProxyItem *item, parent->children()) {

1091

if(item->display() == name) {

1092

if(!item->flag(ProxyItem::Dir)) {

1093

kDebug(debugArea()) << "found" << item << "but its not a dir?";

1094

return 0;

1095

}

1096

1097

kDebug(debugArea()) << "found" << item;

1098

return static_cast<ProxyItemDir*>(item);

1099

}

1100

}

1101

1102

kDebug(debugArea()) << "!found:" << name;

1103

return 0;

1104

}

1105

1106

void KateFileTreeModel::insertItemInto(ProxyItemDir *root, ProxyItem *item)

1107

{

1108

kDebug(debugArea()) << "BEGIN!";

1109

1110

Q_ASSERT(root != 0);

1111

Q_ASSERT(item != 0);

1112

1113

QString sep;

1114

QString tail = item->path();

1115

tail.remove(0, root->path().length());

1116

QStringList parts = tail.split(QLatin1Char('/'), QString::SkipEmptyParts);

1117

ProxyItemDir *ptr = root;

1118

QStringList current_parts;

1119

current_parts.append(root->path());

1120

1121

// seems this can be empty, see bug 286191

1122

if (!parts.isEmpty())

1123

parts.pop_back();

1124

1125

kDebug(debugArea()) << "creating tree for" << item;

1126

foreach(const QString &part, parts) {

1127

current_parts.append(part);

1128

ProxyItemDir *find = findChildNode(ptr, part);

1129

if(!find) {

1130

QString new_name = current_parts.join(QLatin1String("/"));

1131

QModelIndex parent_index = createIndex(ptr->row(), 0, ptr);

1132

kDebug(debugArea()) << "adding" << part << "to" << ptr;

1133

beginInsertRows(ptr == m_root ? QModelIndex() : parent_index, ptr->childCount(), ptr->childCount());

1134

ptr = new ProxyItemDir(new_name, ptr);

1135

endInsertRows();

1136

}

1137

else {

1138

ptr = find;

1139

}

1140

}

1141

1142

kDebug(debugArea()) << "adding" << item << "to" << ptr;

1143

QModelIndex parent_index = createIndex(ptr->row(), 0, ptr);

1144

beginInsertRows(ptr == m_root ? QModelIndex() : parent_index, ptr->childCount(), ptr->childCount());

1145

ptr->addChild(item);

1146

endInsertRows();

1147

1148

kDebug(debugArea()) << "END!";

1149

}

1150

1151

void KateFileTreeModel::handleInsert(ProxyItem *item)

1152

{

1153

kDebug(debugArea()) << "BEGIN!";

1154

1155

Q_ASSERT(item != 0);

1156

1157

if(m_listMode) {

1158

kDebug(debugArea()) << "list mode, inserting into m_root";

1159

beginInsertRows(QModelIndex(), m_root->childCount(), m_root->childCount());

1160

m_root->addChild(item);

1161

endInsertRows();

1162

return;

1163

}

1164

1165

if(item->flag(ProxyItem::Empty)) {

1166

kDebug(debugArea()) << "empty item";

1167

beginInsertRows(QModelIndex(), m_root->childCount(), m_root->childCount());

1168

m_root->addChild(item);

1169

endInsertRows();

1170

return;

1171

}

1172

1173

ProxyItemDir *root = findRootNode(item->path());

1174

if(root) {

1175

kDebug(debugArea()) << "got a root, inserting into it";

1176

insertItemInto(root, item);

1177

} else {

1178

kDebug(debugArea()) << "creating a new root";

1179

1180

// trim off trailing file and dir

1181

QString base = item->path().section(QLatin1Char('/'), 0, -2);

1182

1183

// create new root

1184

ProxyItemDir *new_root = new ProxyItemDir(base, 0);

1185

new_root->setHost(item->host());

1186

1187

// add new root to m_root

1188

kDebug(debugArea()) << "add" << new_root << "to m_root";

1189

beginInsertRows(QModelIndex(), m_root->childCount(), m_root->childCount());

1190

m_root->addChild(new_root);

1191

endInsertRows();

1192

1193

// same fix as in findRootNode, try to match a full dir, instead of a partial path

1194

base += QLatin1Char('/');

1195

1196

// try and merge existing roots with the new root node.

1197

kDebug(debugArea()) << "attempting to merge some existing roots";

1198

foreach(ProxyItem *root, m_root->children()) {

1199

if(root == new_root || !root->flag(ProxyItem::Dir))

1200

continue;

1201

1202

if(root->path().startsWith(base)) {

1203

kDebug(debugArea()) << "removing" << root << "from m_root";

1204

beginRemoveRows(QModelIndex(), root->row(), root->row());

1205

m_root->remChild(root);

1206

endRemoveRows();

1207

1208

kDebug(debugArea()) << "adding" << root << "to" << new_root;

1209

//beginInsertRows(new_root_index, new_root->childCount(), new_root->childCount());

1210

// this can't use new_root->addChild directly, or it'll potentially miss a bunch of subdirs

1211

insertItemInto(new_root, root);

1212

//endInsertRows();

1213

}

1214

}

1215

1216

// add item to new root

1217

kDebug(debugArea()) << "adding" << item << "to" << new_root;

1218

// have to call begin/endInsertRows here, or the new item won't show up.

1219

QModelIndex new_root_index = createIndex(new_root->row(), 0, new_root);

1220

beginInsertRows(new_root_index, new_root->childCount(), new_root->childCount());

1221

new_root->addChild(item);

1222

endInsertRows();

1223

1224

}

1225

1226

kDebug(debugArea()) << "END!";

1227

}

1228

1229

void KateFileTreeModel::handleNameChange(ProxyItem *item, const QString &new_name, const QString& new_host)

1230

{

1231

kDebug(debugArea()) << "BEGIN!";

1232

1233

Q_ASSERT(item != 0);

1234

1235

if(m_listMode) {

1236

item->setPath(new_name);

1237

item->setHost(new_host);

1238

QModelIndex idx = createIndex(item->row(), 0, item);

1239

setupIcon(item);

1240

emit dataChanged(idx, idx);

1241

kDebug(debugArea()) << "list mode, short circuit";

1242

return;

1243

}

1244

1245

// for some reason we get useless name changes

1246

if(item->path() == new_name) {

1247

kDebug(debugArea()) << "bogus name change";

1248

return;

1249

}

1250

1251

// in either case (new/change) we want to remove the item from its parent

1252

1253

ProxyItemDir *parent = item->parent();

1254

if(!parent) {

1255

item->setPath(new_name);

1256

item->setHost(new_host);

1257

kDebug(debugArea()) << "ERROR: item" << item << "does not have a parent?";

1258

return;

1259

}

1260

1261

item->setPath(new_name);

1262

item->setHost(new_host);

1263

1264

kDebug(debugArea()) << "removing" << item << "from" << parent;

1265

QModelIndex parent_index = parent == m_root ? QModelIndex() : createIndex(parent->row(), 0, parent);

1266

beginRemoveRows(parent_index, item->row(), item->row());

1267

parent->remChild(item);

1268

endRemoveRows();

1269

1270

// remove empty parent nodes here, recursively.

1271

handleEmptyParents(parent);

1272

1273

// set new path

1274

//item->setPath(new_name);

1275

1276

// clear all but Empty flag

1277

if(item->flag(ProxyItem::Empty))

1278

item->setFlags(ProxyItem::Empty);

1279

else

1280

item->setFlags(ProxyItem::None);

1281

1282

setupIcon(item);

1283

1284

// new item

1285

kDebug(debugArea()) << "inserting" << item;

1286

handleInsert(item);

1287

1288

kDebug(debugArea()) << "END!";

1289

}

1290

1291

void KateFileTreeModel::setupIcon(ProxyItem *item)

1292

{

1293

kDebug(debugArea()) << "BEGIN!";

1294

1295

Q_ASSERT(item != 0);

1296

1297

QStringList emblems;

1298

QString icon_name;

1299

1300

if(item->flag(ProxyItem::Modified)) {

1301

icon_name = "document-save";

1302

}

1303

else {

1304

KUrl url = item->path();

1305

icon_name = KMimeType::findByUrl(url, 0, true, true)->iconName();

1306

}

1307

1308

if(item->flag(ProxyItem::ModifiedExternally) || item->flag(ProxyItem::DeletedExternally)) {

1309

emblems << "emblem-important";

1310

kDebug(debugArea()) << "modified!";

1311

}

1312

1313

item->setIcon(KIcon(icon_name, 0, emblems));

1314

1315

kDebug(debugArea()) << "END!";

1316

}

1317

1318

// kate: space-indent on; indent-width 2; replace-tabs on; mixed-indent off;

Older »