Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
xxadev
vscode
提交
64f90d11
V
vscode
项目概览
xxadev
/
vscode
与 Fork 源项目一致
从无法访问的项目Fork
通知
2
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
V
vscode
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
64f90d11
编写于
5月 04, 2016
作者:
B
Benjamin Pasero
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
first cut editor stacks model
上级
ac30659f
变更
2
隐藏空白更改
内联
并排
Showing
2 changed file
with
525 addition
and
0 deletion
+525
-0
src/vs/workbench/common/editor/editorStacksModel.ts
src/vs/workbench/common/editor/editorStacksModel.ts
+447
-0
src/vs/workbench/test/common/editorStackModel.test.ts
src/vs/workbench/test/common/editorStackModel.test.ts
+78
-0
未找到文件。
src/vs/workbench/common/editor/editorStacksModel.ts
0 → 100644
浏览文件 @
64f90d11
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'
use strict
'
;
import
Event
,
{
Emitter
}
from
'
vs/base/common/event
'
;
import
{
EditorInput
}
from
'
vs/workbench/common/editor
'
;
/// --- API ----
export
interface
IEditorGroup
{
editors
:
EditorInput
[];
activeEditor
:
EditorInput
;
previewEditor
:
EditorInput
;
onEditorActivated
:
Event
<
EditorInput
>
;
onEditorOpened
:
Event
<
EditorInput
>
;
onEditorClosed
:
Event
<
EditorInput
>
;
onEditorPinned
:
Event
<
EditorInput
>
;
onEditorUnpinned
:
Event
<
EditorInput
>
;
openEditor
(
editor
:
EditorInput
,
options
?:
IEditorOpenOptions
):
void
;
setActive
(
editor
:
EditorInput
):
void
;
isActive
(
editor
:
EditorInput
):
boolean
;
isPreview
(
editor
:
EditorInput
):
boolean
;
isPinned
(
editor
:
EditorInput
):
boolean
;
pin
(
editor
:
EditorInput
):
void
;
unpin
(
editor
:
EditorInput
):
void
;
}
export
interface
IEditorStacksModel
{
onGroupOpened
:
Event
<
IEditorGroup
>
;
onGroupClosed
:
Event
<
IEditorGroup
>
;
onGroupActivated
:
Event
<
IEditorGroup
>
;
groups
:
IEditorGroup
[];
activeGroup
:
IEditorGroup
;
openGroup
(
label
:
string
):
IEditorGroup
;
closeGroup
(
group
:
IEditorGroup
):
void
;
setActive
(
group
:
IEditorGroup
):
void
;
}
export
interface
IEditorOpenOptions
{
pinned
?:
boolean
;
active
?:
boolean
;
}
// N Groups with labels (start with Left, Center, Right)
// Group has a List of editors
// Group can have N editors state pinned and 1 state preview
// Group has 1 active edutir
// Group has MRV(isible) list of editors
// Model has actions to work with inputs
// Open
// To the left / to the right (setting)
// Close
// Reveals from the left / from the right (setting)
// Close Others
// Close Editors to the Right
// Close All
// Close All in Group
// Move Editor
// Move Group
// Pin Editor
// Unpin Editor
// Model has resulting events from operations
// Can be serialized and restored
// TODO what about editor input state (dirty decoration)?
class
List
<
T
>
{
private
elements
:
T
[];
constructor
()
{
this
.
elements
=
[];
}
public
insert
(
entry
:
T
,
index
?:
number
,
dir
?:
Direction
):
void
{
}
}
export
enum
Direction
{
LEFT
,
RIGHT
}
const
DEFAULT_OPEN_EDITOR_DIRECTION
=
Direction
.
RIGHT
;
// open new editors to the right of existing ones
export
class
EditorGroup
implements
IEditorGroup
{
private
_editors
:
EditorInput
[];
private
mru
:
number
[];
// indeces of editors in MRU order
private
preview
:
EditorInput
;
// editor in preview state
private
active
:
EditorInput
;
// editor in active state
private
_onEditorActivated
:
Emitter
<
EditorInput
>
;
private
_onEditorOpened
:
Emitter
<
EditorInput
>
;
private
_onEditorClosed
:
Emitter
<
EditorInput
>
;
private
_onEditorPinned
:
Emitter
<
EditorInput
>
;
private
_onEditorUnpinned
:
Emitter
<
EditorInput
>
;
constructor
(
private
label
:
string
)
{
this
.
_editors
=
[];
this
.
mru
=
[];
this
.
_onEditorActivated
=
new
Emitter
<
EditorInput
>
();
this
.
_onEditorOpened
=
new
Emitter
<
EditorInput
>
();
this
.
_onEditorClosed
=
new
Emitter
<
EditorInput
>
();
this
.
_onEditorPinned
=
new
Emitter
<
EditorInput
>
();
this
.
_onEditorUnpinned
=
new
Emitter
<
EditorInput
>
();
}
public
get
onEditorActivated
():
Event
<
EditorInput
>
{
return
this
.
_onEditorActivated
.
event
;
}
public
get
onEditorOpened
():
Event
<
EditorInput
>
{
return
this
.
_onEditorOpened
.
event
;
}
public
get
onEditorClosed
():
Event
<
EditorInput
>
{
return
this
.
_onEditorClosed
.
event
;
}
public
get
onEditorPinned
():
Event
<
EditorInput
>
{
return
this
.
_onEditorPinned
.
event
;
}
public
get
onEditorUnpinned
():
Event
<
EditorInput
>
{
return
this
.
_onEditorUnpinned
.
event
;
}
public
get
editors
():
EditorInput
[]
{
return
this
.
_editors
.
slice
(
0
);
}
public
get
activeEditor
():
EditorInput
{
return
this
.
active
;
}
public
isActive
(
editor
:
EditorInput
):
boolean
{
return
this
.
active
&&
this
.
active
.
matches
(
editor
);
}
public
get
previewEditor
():
EditorInput
{
return
this
.
preview
;
}
public
isPreview
(
editor
:
EditorInput
):
boolean
{
return
this
.
preview
&&
this
.
preview
.
matches
(
editor
);
}
public
openEditor
(
editor
:
EditorInput
,
options
?:
IEditorOpenOptions
):
void
{
const
index
=
this
.
indexOf
(
editor
);
const
indexOfActive
=
this
.
indexOf
(
this
.
active
);
const
indexOfPreview
=
this
.
indexOf
(
this
.
preview
);
const
makeActive
=
options
&&
options
.
active
;
const
makePinned
=
options
&&
options
.
pinned
;
// New editor
if
(
index
===
-
1
)
{
// Insert into our list of editors if pinned or we are first
if
(
makePinned
||
indexOfPreview
===
-
1
)
{
if
(
indexOfActive
===
-
1
)
{
this
.
_editors
.
push
(
editor
);
// first editor in list
}
else
if
(
DEFAULT_OPEN_EDITOR_DIRECTION
===
Direction
.
LEFT
)
{
if
(
indexOfActive
===
0
)
{
this
.
_editors
.
unshift
(
editor
);
// to the left becoming first editor in list
}
else
{
this
.
_editors
.
splice
(
indexOfActive
-
1
,
0
,
editor
);
// to the left of active editor
}
}
else
{
this
.
_editors
.
splice
(
indexOfActive
,
0
,
editor
);
// to the right of active editor
}
}
// Otherwise replace preview one
else
{
this
.
preview
=
editor
;
this
.
_editors
[
indexOfPreview
]
=
editor
;
}
// Event
this
.
_onEditorOpened
.
fire
(
editor
);
// Make active
if
(
makeActive
)
{
this
.
setActive
(
editor
);
}
}
// Existing editor
else
{
// Pin it
if
(
makePinned
)
{
this
.
pin
(
editor
);
}
// Activate it
if
(
makeActive
)
{
this
.
setActive
(
editor
);
}
}
}
public
closeEditor
(
editor
:
EditorInput
):
void
{
const
index
=
this
.
indexOf
(
editor
);
if
(
index
===
-
1
)
{
return
;
// not found
}
// Active Editor closed
if
(
editor
.
matches
(
this
.
active
))
{
// More than one editor
if
(
this
.
_editors
.
length
>
1
)
{
let
newActiveEditor
:
EditorInput
;
if
(
this
.
_editors
.
length
>
index
+
1
)
{
newActiveEditor
=
this
.
_editors
[
index
+
1
];
// make next editor to the right active
}
else
{
newActiveEditor
=
this
.
_editors
[
index
-
1
];
// make next editor to the left active
}
this
.
setActive
(
newActiveEditor
);
}
// One Editor
else
{
this
.
active
=
null
;
}
}
// Preview Editor closed
if
(
editor
.
matches
(
this
.
preview
))
{
this
.
preview
=
null
;
}
this
.
_editors
.
splice
(
index
,
1
);
// Event
this
.
_onEditorClosed
.
fire
(
editor
);
}
public
setActive
(
editor
:
EditorInput
):
void
{
const
index
=
this
.
indexOf
(
editor
);
if
(
index
===
-
1
)
{
return
;
// not found
}
if
(
this
.
active
&&
this
.
active
.
matches
(
editor
))
{
return
;
// already active
}
this
.
active
=
editor
;
// Event
this
.
_onEditorActivated
.
fire
(
editor
);
}
public
pin
(
editor
:
EditorInput
):
void
{
const
index
=
this
.
indexOf
(
editor
);
if
(
index
===
-
1
)
{
return
;
// editor not found
}
const
previewIndex
=
this
.
indexOf
(
this
.
preview
);
if
(
previewIndex
===
-
1
)
{
return
;
// no editor in preview, cannot pin
}
if
(
previewIndex
!==
index
)
{
return
;
// editor already pinned
}
// Convert the preview editor to be a pinned editor
this
.
preview
=
null
;
// Event
this
.
_onEditorPinned
.
fire
(
editor
);
}
public
isPinned
(
editor
:
EditorInput
):
boolean
{
const
index
=
this
.
indexOf
(
editor
);
if
(
index
===
-
1
)
{
return
false
;
// editor not found
}
if
(
!
this
.
preview
)
{
return
true
;
// no preview editor
}
return
!
this
.
preview
.
matches
(
editor
);
}
public
unpin
(
editor
:
EditorInput
):
void
{
const
index
=
this
.
indexOf
(
editor
);
if
(
index
===
-
1
)
{
return
;
// editor not found
}
if
(
editor
.
matches
(
this
.
preview
))
{
return
;
// editor already unpinned
}
const
previewIndex
=
this
.
indexOf
(
this
.
preview
);
// Make it our preview editor if we have no other
if
(
previewIndex
===
-
1
)
{
this
.
preview
=
editor
;
}
// Otherwise replace our existing one
else
{
this
.
_editors
.
splice
(
previewIndex
,
1
);
this
.
preview
=
editor
;
}
// Event
this
.
_onEditorUnpinned
.
fire
(
editor
);
}
private
indexOf
(
candidate
:
EditorInput
):
number
{
for
(
let
i
=
0
;
i
<
this
.
_editors
.
length
;
i
++
)
{
if
(
this
.
_editors
[
i
].
matches
(
candidate
))
{
return
i
;
}
}
return
-
1
;
}
}
export
class
EditorStacksModel
implements
IEditorStacksModel
{
private
_groups
:
EditorGroup
[];
private
active
:
EditorGroup
;
// index of group with currently active editor
private
_onGroupOpened
:
Emitter
<
EditorGroup
>
;
private
_onGroupClosed
:
Emitter
<
EditorGroup
>
;
private
_onGroupActivated
:
Emitter
<
EditorGroup
>
;
constructor
()
{
this
.
_groups
=
[];
this
.
_onGroupOpened
=
new
Emitter
<
EditorGroup
>
();
this
.
_onGroupClosed
=
new
Emitter
<
EditorGroup
>
();
this
.
_onGroupActivated
=
new
Emitter
<
EditorGroup
>
();
}
public
get
onGroupOpened
():
Event
<
EditorGroup
>
{
return
this
.
_onGroupOpened
.
event
;
}
public
get
onGroupClosed
():
Event
<
EditorGroup
>
{
return
this
.
_onGroupClosed
.
event
;
}
public
get
onGroupActivated
():
Event
<
EditorGroup
>
{
return
this
.
_onGroupActivated
.
event
;
}
public
get
groups
():
EditorGroup
[]
{
return
this
.
_groups
.
slice
(
0
);
}
public
get
activeGroup
():
EditorGroup
{
return
this
.
active
;
}
public
openGroup
(
label
:
string
):
EditorGroup
{
const
group
=
new
EditorGroup
(
label
);
// First group
if
(
!
this
.
active
)
{
this
.
_groups
.
push
(
group
);
}
// Subsequent group (add to the right of active)
else
{
this
.
_groups
.
splice
(
this
.
indexOf
(
this
.
active
),
0
,
group
);
}
// Event
this
.
_onGroupOpened
.
fire
(
group
);
// Make active
this
.
setActive
(
group
);
return
group
;
}
public
closeGroup
(
group
:
EditorGroup
):
void
{
const
index
=
this
.
indexOf
(
group
);
if
(
index
<
0
)
{
return
;
// group does not exist
}
// Active group closed: Find a new active one to the right
if
(
group
===
this
.
active
)
{
// More than one group
if
(
this
.
_groups
.
length
>
1
)
{
let
newActiveGroup
:
EditorGroup
;
if
(
this
.
_groups
.
length
>
index
+
1
)
{
newActiveGroup
=
this
.
_groups
[
index
+
1
];
// make next group to the right active
}
else
{
newActiveGroup
=
this
.
_groups
[
index
-
1
];
// make next group to the left active
}
this
.
setActive
(
newActiveGroup
);
}
// One group
else
{
this
.
active
=
null
;
}
}
// Splice from groups
this
.
_groups
.
splice
(
index
,
1
);
// Event
this
.
_onGroupClosed
.
fire
(
group
);
}
public
setActive
(
group
:
EditorGroup
):
void
{
this
.
active
=
group
;
this
.
_onGroupActivated
.
fire
(
this
.
active
);
}
private
indexOf
(
group
:
EditorGroup
):
number
{
return
this
.
_groups
.
indexOf
(
group
);
}
}
\ No newline at end of file
src/vs/workbench/test/common/editorStackModel.test.ts
0 → 100644
浏览文件 @
64f90d11
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'
use strict
'
;
import
*
as
assert
from
'
assert
'
;
import
{
EditorStacksModel
,
IEditorStacksModel
,
IEditorGroup
}
from
'
vs/workbench/common/editor/editorStacksModel
'
;
function
create
():
IEditorStacksModel
{
return
new
EditorStacksModel
();
}
interface
GroupEvents
{
opened
:
IEditorGroup
[];
activated
:
IEditorGroup
[];
closed
:
IEditorGroup
[];
}
function
groupListener
(
model
:
IEditorStacksModel
):
GroupEvents
{
const
groupEvents
=
{
opened
:
[],
activated
:
[],
closed
:
[]
};
model
.
onGroupOpened
(
g
=>
groupEvents
.
opened
.
push
(
g
));
model
.
onGroupActivated
(
g
=>
groupEvents
.
activated
.
push
(
g
));
model
.
onGroupClosed
(
g
=>
groupEvents
.
closed
.
push
(
g
));
return
groupEvents
;
}
suite
(
'
Editor Stacks Model
'
,
()
=>
{
test
(
'
Groups
'
,
function
()
{
const
model
=
create
();
const
events
=
groupListener
(
model
);
assert
.
equal
(
model
.
groups
.
length
,
0
);
assert
.
ok
(
!
model
.
activeGroup
);
const
first
=
model
.
openGroup
(
'
first
'
);
assert
.
equal
(
events
.
opened
[
0
],
first
);
assert
.
equal
(
events
.
activated
[
0
],
first
);
assert
.
equal
(
model
.
activeGroup
,
first
);
assert
.
equal
(
model
.
groups
.
length
,
1
);
const
second
=
model
.
openGroup
(
'
second
'
);
assert
.
equal
(
events
.
opened
[
1
],
second
);
assert
.
equal
(
events
.
activated
[
1
],
second
);
assert
.
equal
(
model
.
activeGroup
,
second
);
assert
.
equal
(
model
.
groups
.
length
,
2
);
const
third
=
model
.
openGroup
(
'
third
'
);
assert
.
equal
(
events
.
opened
[
2
],
third
);
assert
.
equal
(
events
.
activated
[
2
],
third
);
assert
.
equal
(
model
.
activeGroup
,
third
);
assert
.
equal
(
model
.
groups
.
length
,
3
);
model
.
closeGroup
(
first
);
assert
.
equal
(
events
.
closed
[
0
],
first
);
assert
.
equal
(
model
.
groups
.
length
,
2
);
assert
.
equal
(
model
.
activeGroup
,
third
);
model
.
closeGroup
(
third
);
assert
.
equal
(
events
.
closed
[
1
],
third
);
assert
.
equal
(
events
.
activated
[
3
],
second
);
assert
.
equal
(
model
.
activeGroup
,
second
);
assert
.
equal
(
model
.
groups
.
length
,
1
);
const
fourth
=
model
.
openGroup
(
'
fourth
'
);
assert
.
equal
(
fourth
,
model
.
activeGroup
);
model
.
closeGroup
(
fourth
);
assert
.
equal
(
second
,
model
.
activeGroup
);
});
});
\ No newline at end of file
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录