mirror of
https://gitlab.gnome.org/GNOME/gitg
synced 2024-10-31 04:58:58 +00:00
219 lines
4.3 KiB
Vala
219 lines
4.3 KiB
Vala
/*
|
|
* This file is part of gitg
|
|
*
|
|
* Copyright (C) 2012 - Jesse van den Kieboom
|
|
*
|
|
* gitg is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* gitg is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with gitg. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
namespace GitgGtk
|
|
{
|
|
class DiffViewRequestHandler
|
|
{
|
|
protected DiffView? d_view;
|
|
protected Soup.URI d_uri;
|
|
protected string? d_mimetype;
|
|
protected int64 d_size;
|
|
|
|
public DiffViewRequestHandler(DiffView? view, Soup.URI uri)
|
|
{
|
|
d_view = view;
|
|
d_uri = uri;
|
|
}
|
|
|
|
public virtual InputStream? send(Cancellable? cancellable) throws GLib.Error
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public virtual InputStream? send_async(Cancellable? cancellable) throws GLib.Error
|
|
{
|
|
return send(cancellable);
|
|
}
|
|
|
|
public virtual int64 get_content_length()
|
|
{
|
|
return d_size;
|
|
}
|
|
|
|
public virtual string get_content_type()
|
|
{
|
|
return d_mimetype;
|
|
}
|
|
}
|
|
|
|
class DiffViewRequest : Soup.Request
|
|
{
|
|
private DiffViewRequestHandler? d_handler;
|
|
private string? d_contenttype;
|
|
|
|
static construct
|
|
{
|
|
schemes = new string[] {"gitg-internal"};
|
|
}
|
|
|
|
public override InputStream? send(Cancellable? cancellable) throws GLib.Error
|
|
{
|
|
return d_handler.send(cancellable);
|
|
}
|
|
|
|
private class SendResult : Object, AsyncResult
|
|
{
|
|
public InputStream? stream;
|
|
public Object source;
|
|
|
|
public SendResult(Object source, InputStream? stream)
|
|
{
|
|
this.source = source;
|
|
this.stream = stream;
|
|
}
|
|
|
|
public Object get_source_object()
|
|
{
|
|
return source;
|
|
}
|
|
|
|
public void *get_user_data()
|
|
{
|
|
return (void *)stream;
|
|
}
|
|
|
|
public bool is_tagged(void *source_tag)
|
|
{
|
|
// FIXME: is this right?
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override InputStream? send_finish(AsyncResult result) throws GLib.Error
|
|
{
|
|
var res = result as SendResult;
|
|
|
|
return res.stream;
|
|
}
|
|
|
|
private async InputStream? run_async(Cancellable? cancellable)
|
|
{
|
|
SourceFunc callback = run_async.callback;
|
|
InputStream? ret = null;
|
|
|
|
new Thread<void*>("gitg-gtk-diff-view", () => {
|
|
// Actually do it
|
|
try
|
|
{
|
|
ret = d_handler.send_async(cancellable);
|
|
}
|
|
catch {}
|
|
|
|
// Schedule the callback in idle
|
|
Idle.add((owned)callback);
|
|
|
|
return null;
|
|
});
|
|
|
|
// Wait for it to finish, yield to caller
|
|
yield;
|
|
|
|
// Return the input stream
|
|
return ret;
|
|
}
|
|
|
|
public override void send_async(Cancellable? cancellable,
|
|
AsyncReadyCallback callback) throws GLib.Error
|
|
{
|
|
// run the diff in a thread
|
|
run_async.begin(cancellable, (obj, res) => {
|
|
var r = new SendResult(obj, run_async.end(res));
|
|
|
|
callback(this, r);
|
|
});
|
|
}
|
|
|
|
private Gee.HashMap<string, DiffView> diffmap
|
|
{
|
|
get
|
|
{
|
|
return session.get_data<Gee.HashMap<string, DiffView>>("GitgGtkDiffViewMap");
|
|
}
|
|
}
|
|
|
|
public override bool check_uri(Soup.URI uri)
|
|
{
|
|
var path = uri.get_path();
|
|
var parts = path.split("/", 3);
|
|
|
|
if (parts.length != 3)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
uri.set_scheme(parts[1]);
|
|
uri.set_path("/" + parts[2]);
|
|
d_handler = null;
|
|
|
|
DiffView? view = null;
|
|
|
|
var q = uri.get_query();
|
|
|
|
if (q != null)
|
|
{
|
|
var f = Soup.Form.decode(q);
|
|
var vid = f.lookup("viewid");
|
|
|
|
if (vid != null && diffmap.has_key(vid))
|
|
{
|
|
view = diffmap[vid];
|
|
}
|
|
}
|
|
|
|
switch (parts[1])
|
|
{
|
|
case "resource":
|
|
d_handler = new DiffViewRequestResource(view, uri);
|
|
break;
|
|
case "diff":
|
|
d_handler = new DiffViewRequestDiff(view, uri);
|
|
break;
|
|
}
|
|
|
|
return d_handler != null;
|
|
}
|
|
|
|
public override int64 get_content_length()
|
|
{
|
|
if (d_handler != null)
|
|
{
|
|
return d_handler.get_content_length();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public override unowned string? get_content_type()
|
|
{
|
|
if (d_handler != null)
|
|
{
|
|
d_contenttype = d_handler.get_content_type();
|
|
}
|
|
|
|
if (d_contenttype == null)
|
|
{
|
|
d_contenttype = "application/octet-stream";
|
|
}
|
|
|
|
return d_contenttype;
|
|
}
|
|
}
|
|
}
|
|
|
|
// vi:ts=4
|