enum request
pager_request(struct view *view, enum request request, struct line *line)
{
int split = 0;
if (request != REQ_ENTER)
return request;
if (line->type == LINE_COMMIT && view_has_flags(view, VIEW_OPEN_DIFF)) {
open_view(view, REQ_VIEW_DIFF, OPEN_SPLIT);
split = 1;
}
/* Always scroll the view even if it was split. That way
* you can use Enter to scroll through the log view and
* split open each commit diff. */
scroll_view(view, REQ_SCROLL_LINE_DOWN);
/* FIXME: A minor workaround. Scrolling the view will call report_clear()
* but if we are scrolling a non-current view this won't properly
* update the view title. */
if (split)
update_view_title(view);
return REQ_NONE;
}
static bool
view_driver(struct view *view, enum request request)
{
int i;
if (request == REQ_NONE)
return true;
if (request >= REQ_RUN_REQUESTS) {
request = open_run_request(view, request);
// exit quickly rather than going through view_request and back
if (request == REQ_QUIT)
return false;
}
request = view_request(view, request);
if (request == REQ_NONE)
return true;
switch (request) {
case REQ_MOVE_UP:
case REQ_MOVE_DOWN:
case REQ_MOVE_PAGE_UP:
case REQ_MOVE_PAGE_DOWN:
case REQ_MOVE_HALF_PAGE_UP:
case REQ_MOVE_HALF_PAGE_DOWN:
case REQ_MOVE_FIRST_LINE:
case REQ_MOVE_LAST_LINE:
move_view(view, request);
break;
case REQ_SCROLL_FIRST_COL:
case REQ_SCROLL_LEFT:
case REQ_SCROLL_RIGHT:
case REQ_SCROLL_LINE_DOWN:
case REQ_SCROLL_LINE_UP:
case REQ_SCROLL_PAGE_DOWN:
case REQ_SCROLL_PAGE_UP:
case REQ_SCROLL_WHEEL_DOWN:
case REQ_SCROLL_WHEEL_UP:
scroll_view(view, request);
break;
case REQ_VIEW_GREP:
open_grep_view(view);
break;
case REQ_VIEW_MAIN:
open_main_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_DIFF:
open_diff_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_LOG:
open_log_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_TREE:
open_tree_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_HELP:
open_help_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_REFS:
open_refs_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_BLAME:
open_blame_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_BLOB:
open_blob_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_STATUS:
open_status_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_STAGE:
open_stage_view(view, NULL, 0, OPEN_DEFAULT);
break;
case REQ_VIEW_PAGER:
open_pager_view(view, OPEN_DEFAULT);
break;
case REQ_VIEW_STASH:
open_stash_view(view, OPEN_DEFAULT);
break;
case REQ_NEXT:
case REQ_PREVIOUS:
if (view->parent) {
int line;
view = view->parent;
line = view->pos.lineno;
view_request(view, request);
move_view(view, request);
if (view_is_displayed(view))
update_view_title(view);
if (line != view->pos.lineno)
view_request(view, REQ_ENTER);
} else {
move_view(view, request);
}
break;
case REQ_VIEW_NEXT:
{
int nviews = displayed_views();
int next_view = nviews ? (current_view + 1) % nviews : current_view;
if (next_view == current_view) {
report("Only one view is displayed");
break;
}
current_view = next_view;
/* Blur out the title of the previous view. */
update_view_title(view);
report_clear();
break;
}
case REQ_REFRESH:
report("Refreshing is not supported by the %s view", view->name);
break;
case REQ_PARENT:
report("Moving to parent is not supported by the %s view", view->name);
break;
case REQ_BACK:
report("Going back is not supported by the %s view", view->name);
break;
case REQ_MAXIMIZE:
if (displayed_views() == 2)
maximize_view(view, true);
break;
case REQ_OPTIONS:
toggle_option(view);
break;
case REQ_SEARCH:
case REQ_SEARCH_BACK:
search_view(view, request);
break;
case REQ_FIND_NEXT:
case REQ_FIND_PREV:
find_next(view, request);
break;
case REQ_MOVE_NEXT_MERGE:
case REQ_MOVE_PREV_MERGE:
report("Moving between merge commits is not supported by the %s view", view->name);
break;
case REQ_STOP_LOADING:
foreach_view(view, i) {
if (view->pipe)
report("Stopped loading the %s view", view->name),
end_update(view, true);
}
break;
case REQ_SHOW_VERSION:
report("tig-%s (built %s)", TIG_VERSION, __DATE__);
return true;
case REQ_SCREEN_REDRAW:
redraw_display(true);
break;
case REQ_EDIT:
report("Nothing to edit");
break;
case REQ_ENTER:
report("Nothing to enter");
break;
case REQ_VIEW_CLOSE:
/* XXX: Mark closed views by letting view->prev point to the
* view itself. Parents to closed view should never be
* followed. */
if (view->prev && view->prev != view) {
maximize_view(view->prev, true);
view->prev = view;
watch_unregister(&view->watch);
view->parent = NULL;
break;
}
/* Fall-through */
case REQ_QUIT:
return false;
default:
report("Unknown key, press %s for help",
get_view_key(view, REQ_VIEW_HELP));
return true;
}
return true;
}
static int
view_driver(struct view *view, enum request request)
{
int i;
if (request == REQ_NONE)
return TRUE;
if (request >= REQ_RUN_REQUESTS) {
request = open_run_request(view, request);
// exit quickly rather than going through view_request and back
if (request == REQ_QUIT)
return FALSE;
}
request = view_request(view, request);
if (request == REQ_NONE)
return TRUE;
switch (request) {
case REQ_MOVE_UP:
case REQ_MOVE_DOWN:
case REQ_MOVE_PAGE_UP:
case REQ_MOVE_PAGE_DOWN:
case REQ_MOVE_FIRST_LINE:
case REQ_MOVE_LAST_LINE:
move_view(view, request);
break;
case REQ_SCROLL_FIRST_COL:
case REQ_SCROLL_LEFT:
case REQ_SCROLL_RIGHT:
case REQ_SCROLL_LINE_DOWN:
case REQ_SCROLL_LINE_UP:
case REQ_SCROLL_PAGE_DOWN:
case REQ_SCROLL_PAGE_UP:
case REQ_SCROLL_WHEEL_DOWN:
case REQ_SCROLL_WHEEL_UP:
scroll_view(view, request);
break;
case REQ_VIEW_GREP:
open_grep_view(view);
break;
case REQ_VIEW_MAIN:
case REQ_VIEW_DIFF:
case REQ_VIEW_LOG:
case REQ_VIEW_TREE:
case REQ_VIEW_HELP:
case REQ_VIEW_BRANCH:
case REQ_VIEW_BLAME:
case REQ_VIEW_BLOB:
case REQ_VIEW_STATUS:
case REQ_VIEW_STAGE:
case REQ_VIEW_PAGER:
case REQ_VIEW_STASH:
open_view(view, request, OPEN_DEFAULT);
break;
case REQ_NEXT:
case REQ_PREVIOUS:
if (view->parent) {
int line;
view = view->parent;
line = view->pos.lineno;
view_request(view, request);
move_view(view, request);
if (view_is_displayed(view))
update_view_title(view);
if (line != view->pos.lineno)
view_request(view, REQ_ENTER);
} else {
move_view(view, request);
}
break;
case REQ_VIEW_NEXT:
{
int nviews = displayed_views();
int next_view = (current_view + 1) % nviews;
if (next_view == current_view) {
report("Only one view is displayed");
break;
}
current_view = next_view;
/* Blur out the title of the previous view. */
update_view_title(view);
report_clear();
break;
}
case REQ_REFRESH:
report("Refreshing is not supported by the %s view", view->name);
break;
case REQ_PARENT:
report("Moving to parent is not supported by the the %s view", view->name);
break;
case REQ_BACK:
report("Going back is not supported for by %s view", view->name);
break;
case REQ_MAXIMIZE:
if (displayed_views() == 2)
maximize_view(view, TRUE);
break;
case REQ_OPTIONS:
case REQ_TOGGLE_LINENO:
case REQ_TOGGLE_DATE:
case REQ_TOGGLE_AUTHOR:
case REQ_TOGGLE_FILENAME:
case REQ_TOGGLE_GRAPHIC:
case REQ_TOGGLE_REV_GRAPH:
case REQ_TOGGLE_REFS:
case REQ_TOGGLE_CHANGES:
case REQ_TOGGLE_IGNORE_SPACE:
case REQ_TOGGLE_ID:
case REQ_TOGGLE_FILES:
case REQ_TOGGLE_TITLE_OVERFLOW:
case REQ_TOGGLE_FILE_SIZE:
case REQ_TOGGLE_UNTRACKED_DIRS:
case REQ_TOGGLE_VERTICAL_SPLIT:
{
char action[SIZEOF_STR] = "";
enum view_flag flags = toggle_option(view, request, action);
if (flags == VIEW_FLAG_RESET_DISPLAY) {
resize_display();
redraw_display(TRUE);
} else {
foreach_displayed_view(view, i) {
if (view_has_flags(view, flags) && !view->unrefreshable)
reload_view(view);
else
redraw_view(view);
}
}
if (*action)
report("%s", action);
}
break;
case REQ_TOGGLE_SORT_FIELD:
case REQ_TOGGLE_SORT_ORDER:
report("Sorting is not yet supported for the %s view", view->name);
break;
case REQ_DIFF_CONTEXT_UP:
case REQ_DIFF_CONTEXT_DOWN:
report("Changing the diff context is not yet supported for the %s view", view->name);
break;
case REQ_SEARCH:
case REQ_SEARCH_BACK:
search_view(view, request);
break;
case REQ_FIND_NEXT:
case REQ_FIND_PREV:
find_next(view, request);
break;
case REQ_STOP_LOADING:
foreach_view(view, i) {
if (view->pipe)
report("Stopped loading the %s view", view->name),
end_update(view, TRUE);
}
break;
case REQ_SHOW_VERSION:
report("tig-%s (built %s)", TIG_VERSION, __DATE__);
return TRUE;
case REQ_SCREEN_REDRAW:
redraw_display(TRUE);
break;
case REQ_EDIT:
report("Nothing to edit");
break;
case REQ_ENTER:
report("Nothing to enter");
break;
case REQ_VIEW_CLOSE:
/* XXX: Mark closed views by letting view->prev point to the
* view itself. Parents to closed view should never be
* followed. */
if (view->prev && view->prev != view) {
maximize_view(view->prev, TRUE);
view->prev = view;
break;
}
/* Fall-through */
case REQ_QUIT:
return FALSE;
default:
report("Unknown key, press %s for help",
get_view_key(view, REQ_VIEW_HELP));
return TRUE;
}
return TRUE;
}
int spline_win_message(SCREEN *sc,HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam)
{
extern SPLINE_EDIT spline_edit;
typedef enum CMDMENU{
CMD_ADDKEY,CMD_DELKEY
};
static int clickx=0,clicky=0,debounce=0;
static PARAM_CONTROL *pcdrag=0;
static HMENU hmenu=0;
static SPLINE_KEY_CONTROL *selected_key=0;
PARAM_CONTROL *p;
p=spline_edit.plist.list;
if(FALSE)
if(msg!=WM_PAINT&&msg!=WM_SETCURSOR&&msg!=WM_NCHITTEST&&msg!=WM_ENTERIDLE)
{
static DWORD tick;
if((GetTickCount()-tick)>500)
printf("--\n");
printf("spl");
print_msg(msg,lparam,wparam,hwnd);
tick=GetTickCount();
}
switch(msg){
case WM_CREATE:
{
hmenu=CreatePopupMenu();
if(hmenu){
InsertMenu(hmenu,0xFFFFFFFF,MF_BYPOSITION,CMD_ADDKEY,"add key");
InsertMenu(hmenu,0xFFFFFFFF,MF_BYPOSITION,CMD_DELKEY,"delete key");
}
}
break;
case WM_CONTEXTMENU:
if(hmenu){
POINT point;
int x,y;
point.x=x=LOWORD(lparam);
point.y=y=HIWORD(lparam);
MapWindowPoints(NULL,hwnd,&point,1);
clickx=x;
clicky=y;
point.x+=spline_edit.plist.si.hscroll;
point.y+=spline_edit.plist.si.vscroll;
if(hittest_param(p,point.x,point.y,0)){
TrackPopupMenu(hmenu,TPM_LEFTALIGN,x,y,0,hwnd,NULL);
}
}
break;
case WM_KEYFIRST:
switch(wparam){
case VK_DELETE:
PostMessage(hwnd,WM_COMMAND,CMD_DELKEY,0);
break;
}
break;
case WM_COMMAND:
{
PARAM_CONTROL *pc=0;
if(p){
find_param_type(&spline_edit.plist,CSPLINE,&pc);
if(pc){
}
}
switch(LOWORD(wparam)){
case CMD_ADDKEY:
{
SPLINE_KEY *sk=0;
POINT p;
p.x=clickx;
p.y=clicky;
MapWindowPoints(NULL,hwnd,&p,1);
p.x+=spline_edit.plist.si.hscroll;
p.y+=spline_edit.plist.si.vscroll;
add_splinekey(pc,&sk,p.x,p.y);
}
break;
case CMD_DELKEY:
del_sel_keys(pc);
break;
}
}
break;
case WM_MOUSEWHEEL:
{
POINT point;
PARAM_CONTROL *pc=0;
point.x=LOWORD(lparam);
point.y=HIWORD(lparam);
MapWindowPoints(NULL,hwnd,&point,1);
point.x+=spline_edit.plist.si.hscroll;
point.y+=spline_edit.plist.si.vscroll;
if(hittest_param(p,point.x,point.y,&pc)
&& pc->control.type==CDROPLIST){
signed short deltay=(HIWORD(wparam));
send_mouse_wheel(pc,deltay);
update_spline_selection(&spline_edit.plist);
}
else{
short w=HIWORD(wparam);
int key=LOWORD(wparam);
int amount=DEFBUTTONH;
int control=0;
if(key&MK_SHIFT)
amount<<=2;
if(key&MK_CONTROL)
control=1;
if(w>0)
amount=-amount;
scroll_view(hwnd,sc,&spline_edit.plist.si,amount,control);
}
}
break;
case WM_MOUSEMOVE:
set_focus(hwnd);
if(pcdrag){
int x,y,deltax,deltay;
int lmb,mmb,rmb,ctrl,shift;
lmb=wparam&MK_LBUTTON;
mmb=wparam&MK_MBUTTON;
rmb=wparam&MK_RBUTTON;
shift=wparam&MK_SHIFT;
ctrl=wparam&MK_CONTROL;
x=LOWORD(lparam);
y=HIWORD(lparam);
deltax=x-clickx;
deltay=y-clicky;
if(debounce==0){
int size=4;
if((deltax<-size) || (deltax>size))
debounce=1;
if((deltay<-size) || (deltay>size))
debounce=1;
if(debounce==0)
break;
else{
if(deltax<0)
deltax+=size;
else
deltax-=size;
if(deltay<0)
deltay+=size;
else
deltay-=size;
}
}
send_mouse_move(pcdrag,deltax,deltay,lmb,mmb,rmb,shift,ctrl);
if(selected_key && pcdrag->control.type==CSPLINE)
handle_spline_key_move(pcdrag->control.data,selected_key,deltax,deltay);
clickx=x;
clicky=y;
}
else{
int x,y;
x=LOWORD(lparam);
y=HIWORD(lparam);
if(!(wparam&MK_LBUTTON)){
spline_edit.plist.si.vscroll_pressed=FALSE;
spline_edit.plist.si.hscroll_pressed=FALSE;
}
if(spline_edit.plist.si.vscroll_pressed){
float delta=y-clicky;
RECT rect={0};
int h,bh,range,d;
GetWindowRect(hwnd,&rect);
h=rect.bottom-rect.top;
range=sc->h-h;
bh=h-(range/3);
if(bh<10){
bh=10;
if(h<10)
bh=h;
}
d=h-bh;
if(d<=0)
d=1;
delta=delta*range/d;
spline_edit.plist.si.vscroll+=(int)delta;
clicky=y;
}
if(spline_edit.plist.si.hscroll_pressed){
float delta=x-clickx;
RECT rect={0};
int w,bw,range,d;
GetWindowRect(hwnd,&rect);
w=rect.right-rect.left;
range=sc->w-w;
bw=w-(range/3);
if(bw<10){
bw=10;
if(w<10)
bw=w;
}
d=w-bw;
if(d<=0)
d=1;
delta=delta*range/d;
spline_edit.plist.si.hscroll+=(int)delta;
clickx=x;
}
{
int x,y;
PARAM_CONTROL *pc=0;
x=LOWORD(lparam);
y=HIWORD(lparam);
if(hittest_param(p,x,y,&pc)){
if(pc->control.type==CPOPUPLIST){
handle_popup_list(&spline_edit.plist,pc,WM_MOUSEMOVE,x,y);
}
}
}
}
break;
case WM_LBUTTONUP:
if(pcdrag && pcdrag->control.type==CBUTTON){
BUTTON *b=pcdrag->control.data;
if(b)
b->pressed=FALSE;
}
spline_edit.plist.si.hscroll_pressed=0;
spline_edit.plist.si.vscroll_pressed=0;
pcdrag=0;
selected_key=0;
break;
case WM_LBUTTONDOWN:
{
int x,y;
PARAM_CONTROL *pc=0;
clickx=x=LOWORD(lparam);
clicky=y=HIWORD(lparam);
x+=spline_edit.plist.si.hscroll;
y+=spline_edit.plist.si.vscroll;
debounce=0;
if(check_scroll_hit(sc,&spline_edit.plist.si,hwnd,x,y))
break;
clear_param_selected(p);
if(hittest_param(p,x,y,&pc)){
int list_handled=FALSE;
if(pc->control.type==CDROPLIST){
DROPLIST *dl=pc->control.data;
handle_drop_list(&spline_edit.plist,pc);
list_handled=TRUE;
}
else if(pc->control.type==CPOPUPLIST){
handle_popup_list(&spline_edit.plist,pc,WM_LBUTTONDOWN,x,y);
update_spline_selection(&spline_edit.plist);
list_handled=TRUE;
}
else if(pc->control.type==CBUTTON){
BUTTON *b=pc->control.data;
if(b)
b->pressed=TRUE;
}
else if(pc->control.type==CSPLINE){
handle_spline_click(pc->control.data,x,y,&selected_key,wparam);
}
if(!list_handled)
remove_popup(&spline_edit.plist);
pc->has_focus=TRUE;
pcdrag=pc;
}
else{
pcdrag=0;
remove_popup(&spline_edit.plist);
}
}
break;
}
return 0;
}
