~ubuntu-branches/ubuntu/vivid/kate/vivid-proposed

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

721

{

722

Q_UNUSED(modified);

723

if (!m_docmap.contains(doc)) {

724

return;

725

}

726

727

ProxyItem *item = m_docmap[doc];

728

729

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

730

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

731

if (!modified) {

732

item->clearFlag(ProxyItem::ModifiedExternally);

733

item->clearFlag(ProxyItem::DeletedExternally);

734

} else {

735

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

736

item->setFlag(ProxyItem::DeletedExternally);

737

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

738

item->setFlag(ProxyItem::ModifiedExternally);

739

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

740

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

741

item->clearFlag(ProxyItem::ModifiedExternally);

742

item->clearFlag(ProxyItem::DeletedExternally);

743

}

744

}

745

746

setupIcon(item);

747

748

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

749

emit dataChanged(idx, idx);

750

}

751

752

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

753

{

754

if (!m_docmap.contains(doc)) {

755

return;

756

}

757

758

ProxyItem *item = m_docmap[doc];

759

m_viewHistory.removeAll(item);

760

m_viewHistory.prepend(item);

761

762

while (m_viewHistory.count() > 10) {

763

m_viewHistory.removeLast();

764

}

765

766

updateBackgrounds();

767

}

768

769

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

770

{

771

if (!m_docmap.contains(doc)) {

772

return;

773

}

774

775

ProxyItem *item = m_docmap[doc];

776

m_editHistory.removeAll(item);

777

m_editHistory.prepend(item);

778

while (m_editHistory.count() > 10) {

779

m_editHistory.removeLast();

780

}

781

782

updateBackgrounds();

783

}

784

785

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

786

{

787

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

788

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

789

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

790

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

791

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

792

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

793

}

794

}

795

796

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

797

{

798

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

799

connectDocument(doc);

800

}

801

}

802

803

class EditViewCount

804

{

805

public:

806

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

807

{}

808

int edit;

809

int view;

810

};

811

812

void KateFileTreeModel::updateBackgrounds(bool force)

813

{

814

if (!m_shadingEnabled && !force) {

815

return;

816

}

817

818

QMap <ProxyItem *, EditViewCount> helper;

819

int i = 1;

820

821

foreach(ProxyItem * item, m_viewHistory) {

822

helper[item].view = i;

823

i++;

824

}

825

826

i = 1;

827

foreach(ProxyItem * item, m_editHistory) {

828

helper[item].edit = i;

829

i++;

830

}

831

832

QMap<ProxyItem *, QBrush> oldBrushes = m_brushes;

833

m_brushes.clear();

834

835

const int hc = m_viewHistory.count();

836

const int ec = m_editHistory.count();

837

838

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

839

QColor shade(m_viewShade);

840

QColor eshade(m_editShade);

841

842

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

843

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

844

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

845

846

e = e * e;

847

848

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

849

850

shade.setRgb(

851

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

852

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

853

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

854

);

855

}

856

857

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

858

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

859

860

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

861

}

862

863

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

864

oldBrushes.remove(item);

865

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

866

dataChanged(idx, idx);

867

}

868

869

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

870

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

871

dataChanged(idx, idx);

872

}

873

}

874

875

void KateFileTreeModel::handleEmptyParents(ProxyItemDir *item)

876

{

877

Q_ASSERT(item != 0);

878

879

if (!item->parent()) {

880

return;

881

}

882

883

ProxyItemDir *parent = item->parent();

884

885

while (parent) {

886

if (!item->childCount()) {

887

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

888

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

889

parent->remChild(item);

890

endRemoveRows();

891

delete item;

892

} else {

893

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

894

return;

895

}

896

897

item = parent;

898

parent = item->parent();

899

}

900

}

901

902

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

903

{

904

if (!m_docmap.contains(doc)) {

905

return;

906

}

907

908

if (m_shadingEnabled) {

909

ProxyItem *toRemove = m_docmap[doc];

910

if (m_brushes.contains(toRemove)) {

911

m_brushes.remove(toRemove);

912

}

913

914

if (m_viewHistory.contains(toRemove)) {

915

m_viewHistory.removeAll(toRemove);

916

}

917

918

if (m_editHistory.contains(toRemove)) {

919

m_editHistory.removeAll(toRemove);

920

}

921

}

922

923

ProxyItem *node = m_docmap[doc];

924

ProxyItemDir *parent = node->parent();

925

926

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

927

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

928

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

929

endRemoveRows();

930

931

delete node;

932

handleEmptyParents(parent);

933

934

m_docmap.remove(doc);

935

}

936

937

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

938

{

939

if (!m_docmap.contains(doc)) {

940

return;

941

}

942

943

ProxyItem *item = m_docmap[doc];

944

945

if (m_shadingEnabled) {

946

ProxyItem *toRemove = m_docmap[doc];

947

if (m_brushes.contains(toRemove)) {

948

QBrush brush = m_brushes[toRemove];

949

m_brushes.remove(toRemove);

950

m_brushes.insert(item, brush);

951

}

952

953

if (m_viewHistory.contains(toRemove)) {

954

const int idx = m_viewHistory.indexOf(toRemove);

955

if (idx != -1) {

956

m_viewHistory.replace(idx, item);

957

}

958

}

959

960

if (m_editHistory.contains(toRemove)) {

961

const int idx = m_editHistory.indexOf(toRemove);

962

if (idx != -1) {

963

m_editHistory.replace(idx, item);

964

}

965

}

966

}

967

968

handleNameChange(item);

969

emit triggerViewChangeAfterNameChange(); // FIXME: heh, non-standard signal?

970

}

971

972

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

973

{

974

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

975

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

976

continue;

977

}

978

979

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

980

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

981

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

982

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

983

// current issue.

984

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

985

986

if (name.startsWith(path)) {

987

return static_cast<ProxyItemDir *>(item);

988

}

989

}

990

991

return 0;

992

}

993

994

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

995

{

996

Q_ASSERT(parent != 0);

997

Q_ASSERT(!name.isEmpty());

998

999

if (!parent->childCount()) {

1000

return 0;

1001

}

1002

1003

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

1004

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

1005

continue;

1006

}

1007

1008

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

1009

return static_cast<ProxyItemDir *>(item);

1010

}

1011

}

1012

1013

return 0;

1014

}

1015

1016

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

1017

{

1018

Q_ASSERT(root != 0);

1019

Q_ASSERT(item != 0);

1020

1021

QString tail = item->path();

1022

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

1023

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

1024

ProxyItemDir *ptr = root;

1025

QStringList current_parts;

1026

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

1027

1028

// seems this can be empty, see bug 286191

1029

if (!parts.isEmpty()) {

1030

parts.pop_back();

1031

}

1032

1033

foreach(const QString & part, parts) {

1034

current_parts.append(part);

1035

ProxyItemDir *find = findChildNode(ptr, part);

1036

if (!find) {

1037

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

1038

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

1039

beginInsertRows(parent_index, ptr->childCount(), ptr->childCount());

1040

ptr = new ProxyItemDir(new_name, ptr);

1041

endInsertRows();

1042

} else {

1043

ptr = find;

1044

}

1045

}

1046

1047

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

1048

beginInsertRows(parent_index, ptr->childCount(), ptr->childCount());

1049

ptr->addChild(item);

1050

endInsertRows();

1051

}

1052

1053

void KateFileTreeModel::handleInsert(ProxyItem *item)

1054

{

1055

Q_ASSERT(item != 0);

1056

1057

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

1058

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

1059

m_root->addChild(item);

1060

endInsertRows();

1061

return;

1062

}

1063

1064

// case (item.path > root.path)

1065

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

1066

if (root) {

1067

insertItemInto(root, item);

1068

return;

1069

}

1070

1071

// trim off trailing file and dir

1072

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

1073

1074

// create new root

1075

ProxyItemDir *new_root = new ProxyItemDir(base);

1076

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

1077

1078

// add new root to m_root

1079

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

1080

m_root->addChild(new_root);

1081

endInsertRows();

1082

1083

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

1084

base += QLatin1Char('/');

1085

1086

// try and merge existing roots with the new root node (new_root.path < root.path)

1087

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

1088

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

1089

continue;

1090

}

1091

1092

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

1093

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

1094

m_root->remChild(root);

1095

endRemoveRows();

1096

1097

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

1098

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

1099

insertItemInto(new_root, root);

1100

//endInsertRows();

1101

}

1102

}

1103

1104

// add item to new root

1105

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

1106

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

1107

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

1108

new_root->addChild(item);

1109

endInsertRows();

1110

1111

handleDuplicitRootDisplay(new_root);

1112

}

1113

1114

void KateFileTreeModel::handleDuplicitRootDisplay(ProxyItemDir *init)

1115

{

1116

QStack<ProxyItemDir *> rootsToCheck;

1117

rootsToCheck.push(init);

1118

1119

// make sure the roots don't match (recursively)

1120

while (!rootsToCheck.isEmpty()) {

1121

ProxyItemDir *check_root = rootsToCheck.pop();

1122

1123

if (check_root->parent() != m_root) {

1124

continue;

1125

}

1126

1127

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

1128

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

1129

continue;

1130

}

1131

1132

if (check_root->display() == root->display()) {

1133

bool changed = false;

1134

1135

const QString rdir = root->path().section(QLatin1Char('/'), 0, -2);

1136

if (!rdir.isEmpty()) {

1137

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

1138

m_root->remChild(root);

1139

endRemoveRows();

1140

1141

ProxyItemDir *irdir = new ProxyItemDir(rdir);

1142

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

1143

m_root->addChild(irdir);

1144

endInsertRows();

1145

1146

insertItemInto(irdir, root);

1147

1148

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

1149

if (node == irdir || !root->flag(ProxyItem::Dir)) {

1150

continue;

1151

}

1152

1153

const QString xy = rdir + QLatin1Char('/');

1154

if (node->path().startsWith(xy)) {

1155

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

1156

m_root->remChild(node);

1157

endRemoveRows();

1158

insertItemInto(irdir, node);

1159

}

1160

}

1161

1162

rootsToCheck.push(irdir);

1163

changed = true;

1164

}

1165

1166

const QString nrdir = check_root->path().section(QLatin1Char('/'), 0, -2);

1167

if (!nrdir.isEmpty()) {

1168

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

1169

m_root->remChild(check_root);

1170

endRemoveRows();

1171

1172

ProxyItemDir *irdir = new ProxyItemDir(nrdir);

1173

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

1174

m_root->addChild(irdir);

1175

endInsertRows();

1176

1177

insertItemInto(irdir, check_root);

1178

1179

rootsToCheck.push(irdir);

1180

changed = true;

1181

}

1182

1183

if (changed) {

1184

break; // restart

1185

}

1186

}

1187

} // foreach root

1188

1189

}

1190

1191

}

1192

1193

void KateFileTreeModel::handleNameChange(ProxyItem *item)

1194

{

1195

Q_ASSERT(item != 0);

1196

Q_ASSERT(item->parent());

1197

1198

updateItemPathAndHost(item);

1199

1200

if (m_listMode) {

1201

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

1202

setupIcon(item);

1203

emit dataChanged(idx, idx);

1204

return;

1205

}

1206

1207

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

1208

ProxyItemDir *parent = item->parent();

1209

1210

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

1211

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

1212

parent->remChild(item);

1213

endRemoveRows();

1214

1215

handleEmptyParents(parent);

1216

1217

// clear all but Empty flag

1218

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

1219

item->setFlags(ProxyItem::Empty);

1220

} else {

1221

item->setFlags(ProxyItem::None);

1222

}

1223

1224

setupIcon(item);

1225

handleInsert(item);

1226

}

1227

1228

void KateFileTreeModel::updateItemPathAndHost(ProxyItem *item) const

1229

{

1230

const KTextEditor::Document *doc = item->doc();

1231

Q_ASSERT(doc); // this method should not be called at directory items

1232

1233

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

1234

QString host;

1235

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

1236

path = doc->documentName();

1237

item->setFlag(ProxyItem::Empty);

1238

} else {

1239

item->clearFlag(ProxyItem::Empty);

1240

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

1241

if (!host.isEmpty()) {

1242

path = QString::fromLatin1("[%1]%2").arg(host).arg(path);

1243

}

1244

}

1245

1246

// for some reason we get useless name changes [should be fixed in 5.0]

1247

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

1248

return;

1249

}

1250

1251

item->setPath(path);

1252

item->setHost(host);

1253

}

1254

1255

void KateFileTreeModel::setupIcon(ProxyItem *item) const

1256

{

1257

Q_ASSERT(item != 0);

1258

1259

QString icon_name;

1260

1261

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

1262

icon_name = QLatin1String("document-save");

1263

} else {

1264

const QUrl url(item->path());

1265

icon_name = QMimeDatabase().mimeTypeForFile(url.path(), QMimeDatabase::MatchExtension).iconName();

1266

}

1267

1268

QIcon icon = QIcon::fromTheme(icon_name);

1269

1270

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

1271

icon = KIconUtils::addOverlay(icon, QIcon(QLatin1String("emblem-important")), Qt::TopLeftCorner);

1272

}

1273

1274

item->setIcon(icon);

1275

}

1276

1277

void KateFileTreeModel::resetHistory()

1278

{

1279

QSet<ProxyItem *> list = QSet<ProxyItem *>::fromList(m_viewHistory);

1280

list += QSet<ProxyItem *>::fromList(m_editHistory);

1281

1282

m_viewHistory.clear();

1283

m_editHistory.clear();

1284

m_brushes.clear();

1285

1286

foreach(ProxyItem * item, list) {

1287

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

1288

dataChanged(idx, idx, QVector<int>(1, Qt::BackgroundRole));

1289

}

1290

}

1291

Older »