~ubuntu-branches/ubuntu/precise/simple-scan/precise : revision 40

1

/* scanner.c generated by valac 0.13.0, the Vala compiler

2

* generated from scanner.vala, do not modify */

3

1

4

/*

2

5

3

6

* Author: Robert Ancell <robert.ancell@canonical.com>

4

*

7

*

5

8

* This program is free software: you can redistribute it and/or modify it under

6

9

* the terms of the GNU General Public License as published by the Free Software

7

10

* Foundation, either version 3 of the License, or (at your option) any later

8

11

* version. See http://www.gnu.org/copyleft/gpl.html the full text of the

9

12

* license.

10

13

*/

14

/* TODO: Could indicate the start of the next page immediately after the last page is received (i.e. before the sane_cancel()) */

11

15

16

#include <glib.h>

17

#include <glib-object.h>

12

18

#include <stdlib.h>

13

19

#include <string.h>

20

#include <float.h>

14

21

#include <math.h>

15

22

#include <sane/sane.h>

23

#include <glib/gi18n-lib.h>

16

24

#include <sane/saneopts.h>

17

#include <glib/gi18n.h>

18

19

#include "scanner.h"

20

21

/* TODO: Could indicate the start of the next page immediately after the last page is received (i.e. before the sane_cancel()) */

22

23

enum {

24

UPDATE_DEVICES,

25

AUTHORIZE,

26

EXPECT_PAGE,

27

GOT_PAGE_INFO,

28

GOT_LINE,

29

SCAN_FAILED,

30

PAGE_DONE,

31

DOCUMENT_DONE,

32

SCANNING_CHANGED,

33

LAST_SIGNAL

34

};

35

static guint signals[LAST_SIGNAL] = { 0, };

36

37

typedef struct

38

{

39

Scanner *instance;

40

guint sig;

41

gpointer data;

42

} SignalInfo;

43

44

typedef struct

45

{

46

gchar *device;

47

gdouble dpi;

48

ScanMode scan_mode;

49

gint depth;

50

gboolean type;

51

gint page_width, page_height;

52

} ScanJob;

53

54

typedef struct

55

{

56

enum

57

{

58

REQUEST_CANCEL,

59

REQUEST_REDETECT,

60

REQUEST_START_SCAN,

61

REQUEST_QUIT

62

} type;

63

ScanJob *job;

64

} ScanRequest;

65

66

typedef struct

67

{

68

gchar *username, *password;

69

} Credentials;

70

71

typedef enum

72

{

73

STATE_IDLE = 0,

74

STATE_REDETECT,

75

STATE_OPEN,

76

STATE_GET_OPTION,

77

STATE_START,

78

STATE_GET_PARAMETERS,

79

STATE_READ

25

#include <gobject/gvaluecollector.h>

26

27

28

#define TYPE_SCAN_DEVICE (scan_device_get_type ())

29

#define SCAN_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCAN_DEVICE, ScanDevice))

30

#define SCAN_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCAN_DEVICE, ScanDeviceClass))

31

#define IS_SCAN_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCAN_DEVICE))

32

#define IS_SCAN_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCAN_DEVICE))

33

#define SCAN_DEVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCAN_DEVICE, ScanDeviceClass))

34

35

typedef struct _ScanDevice ScanDevice;

36

typedef struct _ScanDeviceClass ScanDeviceClass;

37

typedef struct _ScanDevicePrivate ScanDevicePrivate;

38

#define _g_free0(var) (var = (g_free (var), NULL))

39

typedef struct _ParamSpecScanDevice ParamSpecScanDevice;

40

41

#define TYPE_SCAN_PAGE_INFO (scan_page_info_get_type ())

42

#define SCAN_PAGE_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCAN_PAGE_INFO, ScanPageInfo))

43

#define SCAN_PAGE_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCAN_PAGE_INFO, ScanPageInfoClass))

44

#define IS_SCAN_PAGE_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCAN_PAGE_INFO))

45

#define IS_SCAN_PAGE_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCAN_PAGE_INFO))

46

#define SCAN_PAGE_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCAN_PAGE_INFO, ScanPageInfoClass))

47

48

typedef struct _ScanPageInfo ScanPageInfo;

49

typedef struct _ScanPageInfoClass ScanPageInfoClass;

50

typedef struct _ScanPageInfoPrivate ScanPageInfoPrivate;

51

typedef struct _ParamSpecScanPageInfo ParamSpecScanPageInfo;

52

53

#define TYPE_SCAN_LINE (scan_line_get_type ())

54

#define SCAN_LINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCAN_LINE, ScanLine))

55

#define SCAN_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCAN_LINE, ScanLineClass))

56

#define IS_SCAN_LINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCAN_LINE))

57

#define IS_SCAN_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCAN_LINE))

58

#define SCAN_LINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCAN_LINE, ScanLineClass))

59

60

typedef struct _ScanLine ScanLine;

61

typedef struct _ScanLineClass ScanLineClass;

62

typedef struct _ScanLinePrivate ScanLinePrivate;

63

typedef struct _ParamSpecScanLine ParamSpecScanLine;

64

65

#define TYPE_SCAN_MODE (scan_mode_get_type ())

66

67

#define TYPE_SCAN_TYPE (scan_type_get_type ())

68

69

#define TYPE_SCAN_OPTIONS (scan_options_get_type ())

70

#define SCAN_OPTIONS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCAN_OPTIONS, ScanOptions))

71

#define SCAN_OPTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCAN_OPTIONS, ScanOptionsClass))

72

#define IS_SCAN_OPTIONS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCAN_OPTIONS))

73

#define IS_SCAN_OPTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCAN_OPTIONS))

74

#define SCAN_OPTIONS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCAN_OPTIONS, ScanOptionsClass))

75

76

typedef struct _ScanOptions ScanOptions;

77

typedef struct _ScanOptionsClass ScanOptionsClass;

78

typedef struct _ScanOptionsPrivate ScanOptionsPrivate;

79

typedef struct _ParamSpecScanOptions ParamSpecScanOptions;

80

81

#define TYPE_SCAN_JOB (scan_job_get_type ())

82

#define SCAN_JOB(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCAN_JOB, ScanJob))

83

#define SCAN_JOB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCAN_JOB, ScanJobClass))

84

#define IS_SCAN_JOB(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCAN_JOB))

85

#define IS_SCAN_JOB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCAN_JOB))

86

#define SCAN_JOB_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCAN_JOB, ScanJobClass))

87

88

typedef struct _ScanJob ScanJob;

89

typedef struct _ScanJobClass ScanJobClass;

90

typedef struct _ScanJobPrivate ScanJobPrivate;

91

typedef struct _ParamSpecScanJob ParamSpecScanJob;

92

93

#define TYPE_REQUEST (request_get_type ())

94

#define REQUEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_REQUEST, Request))

95

#define REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_REQUEST, RequestClass))

96

#define IS_REQUEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_REQUEST))

97

#define IS_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_REQUEST))

98

#define REQUEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_REQUEST, RequestClass))

99

100

typedef struct _Request Request;

101

typedef struct _RequestClass RequestClass;

102

typedef struct _RequestPrivate RequestPrivate;

103

typedef struct _ParamSpecRequest ParamSpecRequest;

104

105

#define TYPE_REQUEST_REDETECT (request_redetect_get_type ())

106

#define REQUEST_REDETECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_REQUEST_REDETECT, RequestRedetect))

107

#define REQUEST_REDETECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_REQUEST_REDETECT, RequestRedetectClass))

108

#define IS_REQUEST_REDETECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_REQUEST_REDETECT))

109

#define IS_REQUEST_REDETECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_REQUEST_REDETECT))

110

#define REQUEST_REDETECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_REQUEST_REDETECT, RequestRedetectClass))

111

112

typedef struct _RequestRedetect RequestRedetect;

113

typedef struct _RequestRedetectClass RequestRedetectClass;

114

typedef struct _RequestRedetectPrivate RequestRedetectPrivate;

115

116

#define TYPE_REQUEST_CANCEL (request_cancel_get_type ())

117

#define REQUEST_CANCEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_REQUEST_CANCEL, RequestCancel))

118

#define REQUEST_CANCEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_REQUEST_CANCEL, RequestCancelClass))

119

#define IS_REQUEST_CANCEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_REQUEST_CANCEL))

120

#define IS_REQUEST_CANCEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_REQUEST_CANCEL))

121

#define REQUEST_CANCEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_REQUEST_CANCEL, RequestCancelClass))

122

123

typedef struct _RequestCancel RequestCancel;

124

typedef struct _RequestCancelClass RequestCancelClass;

125

typedef struct _RequestCancelPrivate RequestCancelPrivate;

126

127

#define TYPE_REQUEST_START_SCAN (request_start_scan_get_type ())

128

#define REQUEST_START_SCAN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_REQUEST_START_SCAN, RequestStartScan))

129

#define REQUEST_START_SCAN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_REQUEST_START_SCAN, RequestStartScanClass))

130

#define IS_REQUEST_START_SCAN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_REQUEST_START_SCAN))

131

#define IS_REQUEST_START_SCAN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_REQUEST_START_SCAN))

132

#define REQUEST_START_SCAN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_REQUEST_START_SCAN, RequestStartScanClass))

133

134

typedef struct _RequestStartScan RequestStartScan;

135

typedef struct _RequestStartScanClass RequestStartScanClass;

136

typedef struct _RequestStartScanPrivate RequestStartScanPrivate;

137

#define _scan_job_unref0(var) ((var == NULL) ? NULL : (var = (scan_job_unref (var), NULL)))

138

139

#define TYPE_REQUEST_QUIT (request_quit_get_type ())

140

#define REQUEST_QUIT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_REQUEST_QUIT, RequestQuit))

141

#define REQUEST_QUIT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_REQUEST_QUIT, RequestQuitClass))

142

#define IS_REQUEST_QUIT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_REQUEST_QUIT))

143

#define IS_REQUEST_QUIT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_REQUEST_QUIT))

144

#define REQUEST_QUIT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_REQUEST_QUIT, RequestQuitClass))

145

146

typedef struct _RequestQuit RequestQuit;

147

typedef struct _RequestQuitClass RequestQuitClass;

148

typedef struct _RequestQuitPrivate RequestQuitPrivate;

149

150

#define TYPE_CREDENTIALS (credentials_get_type ())

151

#define CREDENTIALS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CREDENTIALS, Credentials))

152

#define CREDENTIALS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CREDENTIALS, CredentialsClass))

153

#define IS_CREDENTIALS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CREDENTIALS))

154

#define IS_CREDENTIALS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CREDENTIALS))

155

#define CREDENTIALS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CREDENTIALS, CredentialsClass))

156

157

typedef struct _Credentials Credentials;

158

typedef struct _CredentialsClass CredentialsClass;

159

typedef struct _CredentialsPrivate CredentialsPrivate;

160

typedef struct _ParamSpecCredentials ParamSpecCredentials;

161

162

#define TYPE_SCAN_STATE (scan_state_get_type ())

163

164

#define TYPE_NOTIFY (notify_get_type ())

165

#define NOTIFY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY, Notify))

166

#define NOTIFY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY, NotifyClass))

167

#define IS_NOTIFY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY))

168

#define IS_NOTIFY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY))

169

#define NOTIFY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY, NotifyClass))

170

171

typedef struct _Notify Notify;

172

typedef struct _NotifyClass NotifyClass;

173

typedef struct _NotifyPrivate NotifyPrivate;

174

175

#define TYPE_SCANNER (scanner_get_type ())

176

#define SCANNER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SCANNER, Scanner))

177

#define SCANNER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SCANNER, ScannerClass))

178

#define IS_SCANNER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SCANNER))

179

#define IS_SCANNER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SCANNER))

180

#define SCANNER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SCANNER, ScannerClass))

181

182

typedef struct _Scanner Scanner;

183

typedef struct _ScannerClass ScannerClass;

184

typedef struct _ParamSpecNotify ParamSpecNotify;

185

186

#define TYPE_NOTIFY_SCANNING_CHANGED (notify_scanning_changed_get_type ())

187

#define NOTIFY_SCANNING_CHANGED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY_SCANNING_CHANGED, NotifyScanningChanged))

188

#define NOTIFY_SCANNING_CHANGED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY_SCANNING_CHANGED, NotifyScanningChangedClass))

189

#define IS_NOTIFY_SCANNING_CHANGED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY_SCANNING_CHANGED))

190

#define IS_NOTIFY_SCANNING_CHANGED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY_SCANNING_CHANGED))

191

#define NOTIFY_SCANNING_CHANGED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY_SCANNING_CHANGED, NotifyScanningChangedClass))

192

193

typedef struct _NotifyScanningChanged NotifyScanningChanged;

194

typedef struct _NotifyScanningChangedClass NotifyScanningChangedClass;

195

typedef struct _NotifyScanningChangedPrivate NotifyScanningChangedPrivate;

196

197

#define TYPE_NOTIFY_UPDATE_DEVICES (notify_update_devices_get_type ())

198

#define NOTIFY_UPDATE_DEVICES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY_UPDATE_DEVICES, NotifyUpdateDevices))

199

#define NOTIFY_UPDATE_DEVICES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY_UPDATE_DEVICES, NotifyUpdateDevicesClass))

200

#define IS_NOTIFY_UPDATE_DEVICES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY_UPDATE_DEVICES))

201

#define IS_NOTIFY_UPDATE_DEVICES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY_UPDATE_DEVICES))

202

#define NOTIFY_UPDATE_DEVICES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY_UPDATE_DEVICES, NotifyUpdateDevicesClass))

203

204

typedef struct _NotifyUpdateDevices NotifyUpdateDevices;

205

typedef struct _NotifyUpdateDevicesClass NotifyUpdateDevicesClass;

206

typedef struct _NotifyUpdateDevicesPrivate NotifyUpdateDevicesPrivate;

207

#define __g_list_free__scan_device_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__scan_device_unref0_ (var), NULL)))

208

209

#define TYPE_NOTIFY_REQUEST_AUTHORIZATION (notify_request_authorization_get_type ())

210

#define NOTIFY_REQUEST_AUTHORIZATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY_REQUEST_AUTHORIZATION, NotifyRequestAuthorization))

211

#define NOTIFY_REQUEST_AUTHORIZATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY_REQUEST_AUTHORIZATION, NotifyRequestAuthorizationClass))

212

#define IS_NOTIFY_REQUEST_AUTHORIZATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY_REQUEST_AUTHORIZATION))

213

#define IS_NOTIFY_REQUEST_AUTHORIZATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY_REQUEST_AUTHORIZATION))

214

#define NOTIFY_REQUEST_AUTHORIZATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY_REQUEST_AUTHORIZATION, NotifyRequestAuthorizationClass))

215

216

typedef struct _NotifyRequestAuthorization NotifyRequestAuthorization;

217

typedef struct _NotifyRequestAuthorizationClass NotifyRequestAuthorizationClass;

218

typedef struct _NotifyRequestAuthorizationPrivate NotifyRequestAuthorizationPrivate;

219

220

#define TYPE_NOTIFY_SCAN_FAILED (notify_scan_failed_get_type ())

221

#define NOTIFY_SCAN_FAILED(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY_SCAN_FAILED, NotifyScanFailed))

222

#define NOTIFY_SCAN_FAILED_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY_SCAN_FAILED, NotifyScanFailedClass))

223

#define IS_NOTIFY_SCAN_FAILED(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY_SCAN_FAILED))

224

#define IS_NOTIFY_SCAN_FAILED_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY_SCAN_FAILED))

225

#define NOTIFY_SCAN_FAILED_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY_SCAN_FAILED, NotifyScanFailedClass))

226

227

typedef struct _NotifyScanFailed NotifyScanFailed;

228

typedef struct _NotifyScanFailedClass NotifyScanFailedClass;

229

typedef struct _NotifyScanFailedPrivate NotifyScanFailedPrivate;

230

231

#define TYPE_NOTIFY_DOCUMENT_DONE (notify_document_done_get_type ())

232

#define NOTIFY_DOCUMENT_DONE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY_DOCUMENT_DONE, NotifyDocumentDone))

233

#define NOTIFY_DOCUMENT_DONE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY_DOCUMENT_DONE, NotifyDocumentDoneClass))

234

#define IS_NOTIFY_DOCUMENT_DONE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY_DOCUMENT_DONE))

235

#define IS_NOTIFY_DOCUMENT_DONE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY_DOCUMENT_DONE))

236

#define NOTIFY_DOCUMENT_DONE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY_DOCUMENT_DONE, NotifyDocumentDoneClass))

237

238

typedef struct _NotifyDocumentDone NotifyDocumentDone;

239

typedef struct _NotifyDocumentDoneClass NotifyDocumentDoneClass;

240

typedef struct _NotifyDocumentDonePrivate NotifyDocumentDonePrivate;

241

242

#define TYPE_NOTIFY_EXPECT_PAGE (notify_expect_page_get_type ())

243

#define NOTIFY_EXPECT_PAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY_EXPECT_PAGE, NotifyExpectPage))

244

#define NOTIFY_EXPECT_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY_EXPECT_PAGE, NotifyExpectPageClass))

245

#define IS_NOTIFY_EXPECT_PAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY_EXPECT_PAGE))

246

#define IS_NOTIFY_EXPECT_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY_EXPECT_PAGE))

247

#define NOTIFY_EXPECT_PAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY_EXPECT_PAGE, NotifyExpectPageClass))

248

249

typedef struct _NotifyExpectPage NotifyExpectPage;

250

typedef struct _NotifyExpectPageClass NotifyExpectPageClass;

251

typedef struct _NotifyExpectPagePrivate NotifyExpectPagePrivate;

252

253

#define TYPE_NOTIFY_GOT_PAGE_INFO (notify_got_page_info_get_type ())

254

#define NOTIFY_GOT_PAGE_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY_GOT_PAGE_INFO, NotifyGotPageInfo))

255

#define NOTIFY_GOT_PAGE_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY_GOT_PAGE_INFO, NotifyGotPageInfoClass))

256

#define IS_NOTIFY_GOT_PAGE_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY_GOT_PAGE_INFO))

257

#define IS_NOTIFY_GOT_PAGE_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY_GOT_PAGE_INFO))

258

#define NOTIFY_GOT_PAGE_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY_GOT_PAGE_INFO, NotifyGotPageInfoClass))

259

260

typedef struct _NotifyGotPageInfo NotifyGotPageInfo;

261

typedef struct _NotifyGotPageInfoClass NotifyGotPageInfoClass;

262

typedef struct _NotifyGotPageInfoPrivate NotifyGotPageInfoPrivate;

263

#define _scan_page_info_unref0(var) ((var == NULL) ? NULL : (var = (scan_page_info_unref (var), NULL)))

264

265

#define TYPE_NOTIFY_PAGE_DONE (notify_page_done_get_type ())

266

#define NOTIFY_PAGE_DONE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY_PAGE_DONE, NotifyPageDone))

267

#define NOTIFY_PAGE_DONE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY_PAGE_DONE, NotifyPageDoneClass))

268

#define IS_NOTIFY_PAGE_DONE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY_PAGE_DONE))

269

#define IS_NOTIFY_PAGE_DONE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY_PAGE_DONE))

270

#define NOTIFY_PAGE_DONE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY_PAGE_DONE, NotifyPageDoneClass))

271

272

typedef struct _NotifyPageDone NotifyPageDone;

273

typedef struct _NotifyPageDoneClass NotifyPageDoneClass;

274

typedef struct _NotifyPageDonePrivate NotifyPageDonePrivate;

275

276

#define TYPE_NOTIFY_GOT_LINE (notify_got_line_get_type ())

277

#define NOTIFY_GOT_LINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOTIFY_GOT_LINE, NotifyGotLine))

278

#define NOTIFY_GOT_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOTIFY_GOT_LINE, NotifyGotLineClass))

279

#define IS_NOTIFY_GOT_LINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOTIFY_GOT_LINE))

280

#define IS_NOTIFY_GOT_LINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOTIFY_GOT_LINE))

281

#define NOTIFY_GOT_LINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOTIFY_GOT_LINE, NotifyGotLineClass))

282

283

typedef struct _NotifyGotLine NotifyGotLine;

284

typedef struct _NotifyGotLineClass NotifyGotLineClass;

285

typedef struct _NotifyGotLinePrivate NotifyGotLinePrivate;

286

#define _scan_line_unref0(var) ((var == NULL) ? NULL : (var = (scan_line_unref (var), NULL)))

287

typedef struct _ScannerPrivate ScannerPrivate;

288

#define _g_async_queue_unref0(var) ((var == NULL) ? NULL : (var = (g_async_queue_unref (var), NULL)))

289

#define __g_list_free__scan_job_unref0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__scan_job_unref0_ (var), NULL)))

290

#define _scanner_unref0(var) ((var == NULL) ? NULL : (var = (scanner_unref (var), NULL)))

291

#define _notify_unref0(var) ((var == NULL) ? NULL : (var = (notify_unref (var), NULL)))

292

#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))

293

#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))

294

#define _scan_device_unref0(var) ((var == NULL) ? NULL : (var = (scan_device_unref (var), NULL)))

295

#define _credentials_unref0(var) ((var == NULL) ? NULL : (var = (credentials_unref (var), NULL)))

296

#define _request_unref0(var) ((var == NULL) ? NULL : (var = (request_unref (var), NULL)))

297

typedef struct _ParamSpecScanner ParamSpecScanner;

298

299

struct _ScanDevice {

300

GTypeInstance parent_instance;

301

volatile int ref_count;

302

ScanDevicePrivate * priv;

303

gchar* name;

304

gchar* label;

305

};

306

307

struct _ScanDeviceClass {

308

GTypeClass parent_class;

309

void (*finalize) (ScanDevice *self);

310

};

311

312

struct _ParamSpecScanDevice {

313

GParamSpec parent_instance;

314

};

315

316

struct _ScanPageInfo {

317

GTypeInstance parent_instance;

318

volatile int ref_count;

319

ScanPageInfoPrivate * priv;

320

gint width;

321

gint height;

322

gint depth;

323

gint n_channels;

324

gdouble dpi;

325

gchar* device;

326

};

327

328

struct _ScanPageInfoClass {

329

GTypeClass parent_class;

330

void (*finalize) (ScanPageInfo *self);

331

};

332

333

struct _ParamSpecScanPageInfo {

334

GParamSpec parent_instance;

335

};

336

337

struct _ScanLine {

338

GTypeInstance parent_instance;

339

volatile int ref_count;

340

ScanLinePrivate * priv;

341

gint number;

342

gint n_lines;

343

gint width;

344

gint depth;

345

gint channel;

346

guchar* data;

347

gint data_length1;

348

gint data_length;

349

};

350

351

struct _ScanLineClass {

352

GTypeClass parent_class;

353

void (*finalize) (ScanLine *self);

354

};

355

356

struct _ParamSpecScanLine {

357

GParamSpec parent_instance;

358

};

359

360

typedef enum {

361

SCAN_MODE_DEFAULT,

362

SCAN_MODE_COLOR,

363

SCAN_MODE_GRAY,

364

SCAN_MODE_LINEART

365

} ScanMode;

366

367

typedef enum {

368

SCAN_TYPE_SINGLE,

369

SCAN_TYPE_ADF_FRONT,

370

SCAN_TYPE_ADF_BACK,

371

SCAN_TYPE_ADF_BOTH

372

} ScanType;

373

374

struct _ScanOptions {

375

GTypeInstance parent_instance;

376

volatile int ref_count;

377

ScanOptionsPrivate * priv;

378

gint dpi;

379

ScanMode scan_mode;

380

gint depth;

381

ScanType type;

382

gint paper_width;

383

gint paper_height;

384

};

385

386

struct _ScanOptionsClass {

387

GTypeClass parent_class;

388

void (*finalize) (ScanOptions *self);

389

};

390

391

struct _ParamSpecScanOptions {

392

GParamSpec parent_instance;

393

};

394

395

struct _ScanJob {

396

GTypeInstance parent_instance;

397

volatile int ref_count;

398

ScanJobPrivate * priv;

399

gchar* device;

400

gdouble dpi;

401

ScanMode scan_mode;

402

gint depth;

403

ScanType type;

404

gint page_width;

405

gint page_height;

406

};

407

408

struct _ScanJobClass {

409

GTypeClass parent_class;

410

void (*finalize) (ScanJob *self);

411

};

412

413

struct _ParamSpecScanJob {

414

GParamSpec parent_instance;

415

};

416

417

struct _Request {

418

GTypeInstance parent_instance;

419

volatile int ref_count;

420

RequestPrivate * priv;

421

};

422

423

struct _RequestClass {

424

GTypeClass parent_class;

425

void (*finalize) (Request *self);

426

};

427

428

struct _ParamSpecRequest {

429

GParamSpec parent_instance;

430

};

431

432

struct _RequestRedetect {

433

Request parent_instance;

434

RequestRedetectPrivate * priv;

435

};

436

437

struct _RequestRedetectClass {

438

RequestClass parent_class;

439

};

440

441

struct _RequestCancel {

442

Request parent_instance;

443

RequestCancelPrivate * priv;

444

};

445

446

struct _RequestCancelClass {

447

RequestClass parent_class;

448

};

449

450

struct _RequestStartScan {

451

Request parent_instance;

452

RequestStartScanPrivate * priv;

453

ScanJob* job;

454

};

455

456

struct _RequestStartScanClass {

457

RequestClass parent_class;

458

};

459

460

struct _RequestQuit {

461

Request parent_instance;

462

RequestQuitPrivate * priv;

463

};

464

465

struct _RequestQuitClass {

466

RequestClass parent_class;

467

};

468

469

struct _Credentials {

470

GTypeInstance parent_instance;

471

volatile int ref_count;

472

CredentialsPrivate * priv;

473

gchar* username;

474

gchar* password;

475

};

476

477

struct _CredentialsClass {

478

GTypeClass parent_class;

479

void (*finalize) (Credentials *self);

480

};

481

482

struct _ParamSpecCredentials {

483

GParamSpec parent_instance;

484

};

485

486

typedef enum {

487

SCAN_STATE_IDLE = 0,

488

SCAN_STATE_REDETECT,

489

SCAN_STATE_OPEN,

490

SCAN_STATE_GET_OPTION,

491

SCAN_STATE_START,

492

SCAN_STATE_GET_PARAMETERS,

493

SCAN_STATE_READ

80

494

} ScanState;

81

495

82

struct ScannerPrivate

83

{

84

GAsyncQueue *scan_queue, *authorize_queue;

85

GThread *thread;

86

87

gchar *default_device;

88

89

ScanState state;

90

gboolean redetect;

91

92

GList *job_queue;

93

94

/* Handle to SANE device */

95

SANE_Handle handle;

96

gchar *current_device;

97

98

SANE_Parameters parameters;

99

100

/* Last option read */

101

SANE_Int option_index;

102

103

/* Option index for scan area */

104

SANE_Int br_x_option_index, br_y_option_index;

105

106

/* Buffer for received line */

107

SANE_Byte *buffer;

108

SANE_Int buffer_size, n_used;

109

110

SANE_Int bytes_remaining, line_count, pass_number, page_number, notified_page;

111

112

gboolean scanning;

113

};

114

115

G_DEFINE_TYPE (Scanner, scanner, G_TYPE_OBJECT);

116

117

118

/* Table of scanner objects for each thread (required for authorization callback) */

119

static GHashTable *scanners;

120

121

122

static gboolean

123

send_signal (SignalInfo *info)

124

{

125

g_signal_emit (info->instance, signals[info->sig], 0, info->data);

126

127

switch (info->sig) {

128

case UPDATE_DEVICES:

129

{

130

GList *iter, *devices = info->data;

131

for (iter = devices; iter; iter = iter->next) {

132

ScanDevice *device = iter->data;

133

g_free (device->name);

134

g_free (device->label);

135

g_free (device);

136

}

137

g_list_free (devices);

138

}

139

break;

140

case AUTHORIZE:

141

{

142

gchar *resource = info->data;

143

g_free (resource);

144

}

145

break;

146

case GOT_PAGE_INFO:

147

{

148

ScanPageInfo *page_info = info->data;

149

g_free (page_info);

150

}

151

break;

152

case GOT_LINE:

153

{

154

ScanLine *line = info->data;

155

g_free(line->data);

156

g_free(line);

157

}

158

break;

159

case SCAN_FAILED:

160

{

161

GError *error = info->data;

162

g_error_free (error);

163

}

164

break;

165

default:

166

case EXPECT_PAGE:

167

case PAGE_DONE:

168

case DOCUMENT_DONE:

169

case LAST_SIGNAL:

170

g_assert (info->data == NULL);

171

break;

172

}

173

g_free (info);

174

175

return FALSE;

176

}

177

178

179

/* Emit signals in main loop */

180

static void

181

emit_signal (Scanner *scanner, guint sig, gpointer data)

182

{

183

SignalInfo *info;

184

185

info = g_malloc(sizeof(SignalInfo));

186

info->instance = scanner;

187

info->sig = sig;

188

info->data = data;

189

g_idle_add ((GSourceFunc) send_signal, info);

190

}

191

192

193

static void

194

set_scanning (Scanner *scanner, gboolean is_scanning)

195

{

196

if ((scanner->priv->scanning && !is_scanning) || (!scanner->priv->scanning && is_scanning)) {

197

scanner->priv->scanning = is_scanning;

198

emit_signal (scanner, SCANNING_CHANGED, NULL);

199

}

200

}

201

202

203

static gint

204

get_device_weight (const gchar *device)

205

{

206

/* NOTE: This is using trends in the naming of SANE devices, SANE should be able to provide this information better */

207

208

/* Use webcams as a last resort */

209

if (g_str_has_prefix (device, "vfl:"))

210

return 2;

211

212

/* Use locally connected devices first */

213

if (strstr (device, "usb"))

214

return 0;

215

216

return 1;

217

}

218

219

220

static gint

221

compare_devices (ScanDevice *device1, ScanDevice *device2)

222

{

223

gint weight1, weight2;

224

225

/* TODO: Should do some fuzzy matching on the last selected device and set that to the default */

226

227

weight1 = get_device_weight (device1->name);

228

weight2 = get_device_weight (device2->name);

229

if (weight1 != weight2)

230

return weight1 - weight2;

231

232

return strcmp (device1->label, device2->label);

233

}

234

235

236

static const char *

237

get_status_string (SANE_Status status)

238

{

239

struct {

240

SANE_Status status;

241

const char *name;

242

} status_names[] = {

243

{ SANE_STATUS_GOOD, "SANE_STATUS_GOOD"},

244

{ SANE_STATUS_UNSUPPORTED, "SANE_STATUS_UNSUPPORTED"},

245

{ SANE_STATUS_CANCELLED, "SANE_STATUS_CANCELLED"},

246

{ SANE_STATUS_DEVICE_BUSY, "SANE_STATUS_DEVICE_BUSY"},

247

{ SANE_STATUS_INVAL, "SANE_STATUS_INVAL"},

248

{ SANE_STATUS_EOF, "SANE_STATUS_EOF"},

249

{ SANE_STATUS_JAMMED, "SANE_STATUS_JAMMED"},

250

{ SANE_STATUS_NO_DOCS, "SANE_STATUS_NO_DOCS"},

251

{ SANE_STATUS_COVER_OPEN, "SANE_STATUS_COVER_OPEN"},

252

{ SANE_STATUS_IO_ERROR, "SANE_STATUS_IO_ERROR"},

253

{ SANE_STATUS_NO_MEM, "SANE_STATUS_NO_MEM"},

254

{ SANE_STATUS_ACCESS_DENIED, "SANE_STATUS_ACCESS_DENIED"},

255

{ -1, NULL}

256

};

257

static char *unknown_string = NULL;

258

int i;

259

260

for (i = 0; status_names[i].name != NULL && status_names[i].status != status; i++);

261

262

if (status_names[i].name == NULL) {

263

g_free (unknown_string);

264

unknown_string = g_strdup_printf ("SANE_STATUS(%d)", status);

265

return unknown_string; /* Note result is undefined on second call to this function */

266

}

267

268

return status_names[i].name;

269

}

270

271

272

static const char *

273

get_action_string (SANE_Action action)

274

{

275

struct {

276

SANE_Action action;

277

const char *name;

278

} action_names[] = {

279

{ SANE_ACTION_GET_VALUE, "SANE_ACTION_GET_VALUE" },

280

{ SANE_ACTION_SET_VALUE, "SANE_ACTION_SET_VALUE" },

281

{ SANE_ACTION_SET_AUTO, "SANE_ACTION_SET_AUTO" },

282

{ -1, NULL}

283

};

284

static char *unknown_string = NULL;

285

int i;

286

287

for (i = 0; action_names[i].name != NULL && action_names[i].action != action; i++);

288

289

if (action_names[i].name == NULL) {

290

g_free (unknown_string);

291

unknown_string = g_strdup_printf ("SANE_ACTION(%d)", action);

292

return unknown_string; /* Note result is undefined on second call to this function */

293

}

294

295

return action_names[i].name;

296

}

297

298

299

static const char *

300

get_frame_string (SANE_Frame frame)

301

{

302

struct {

303

SANE_Frame frame;

304

const char *name;

305

} frame_names[] = {

306

{ SANE_FRAME_GRAY, "SANE_FRAME_GRAY" },

307

{ SANE_FRAME_RGB, "SANE_FRAME_RGB" },

308

{ SANE_FRAME_RED, "SANE_FRAME_RED" },

309

{ SANE_FRAME_GREEN, "SANE_FRAME_GREEN" },

310

{ SANE_FRAME_BLUE, "SANE_FRAME_BLUE" },

311

{ -1, NULL}

312

};

313

static char *unknown_string = NULL;

314

int i;

315

316

for (i = 0; frame_names[i].name != NULL && frame_names[i].frame != frame; i++);

317

318

if (frame_names[i].name == NULL) {

319

g_free (unknown_string);

320

unknown_string = g_strdup_printf ("SANE_FRAME(%d)", frame);

321

return unknown_string; /* Note result is undefined on second call to this function */

322

}

323

324

return frame_names[i].name;

325

}

326

327

328

static void

329

do_redetect (Scanner *scanner)

330

{

331

const SANE_Device **device_list, **device_iter;

332

SANE_Status status;

333

GList *devices = NULL;

334

335

status = sane_get_devices (&device_list, SANE_FALSE);

336

g_debug ("sane_get_devices () -> %s", get_status_string (status));

337

if (status != SANE_STATUS_GOOD) {

338

g_warning ("Unable to get SANE devices: %s", sane_strstatus(status));

339

scanner->priv->state = STATE_IDLE;

340

return;

341

}

342

343

for (device_iter = device_list; *device_iter; device_iter++) {

344

const SANE_Device *device = *device_iter;

345

ScanDevice *scan_device;

346

gchar *c, *label;

347

348

g_debug ("Device: name=\"%s\" vendor=\"%s\" model=\"%s\" type=\"%s\"",

349

device->name, device->vendor, device->model, device->type);

350

351

scan_device = g_malloc0 (sizeof (ScanDevice));

352

353

scan_device->name = g_strdup (device->name);

354

355

/* Abbreviate HP as it is a long string and does not match what is on the physical scanner */

356

if (strcmp (device->vendor, "Hewlett-Packard") == 0)

357

label = g_strdup_printf ("HP %s", device->model);

358

else

359

label = g_strdup_printf ("%s %s", device->vendor, device->model);

360

361

/* Replace underscored in name */

362

for (c = label; *c; c++)

363

if (*c == '_')

364

*c = ' ';

365

366

scan_device->label = label;

367

368

devices = g_list_append (devices, scan_device);

369

}

370

371

/* Sort devices by priority */

372

devices = g_list_sort (devices, (GCompareFunc) compare_devices);

373

374

scanner->priv->redetect = FALSE;

375

scanner->priv->state = STATE_IDLE;

376

377

g_free (scanner->priv->default_device);

378

if (devices) {

379

ScanDevice *device = g_list_nth_data (devices, 0);

380

scanner->priv->default_device = g_strdup (device->name);

381

}

382

else

383

scanner->priv->default_device = NULL;

384

385

emit_signal (scanner, UPDATE_DEVICES, devices);

386

}

387

388

389

static gboolean

390

control_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int index, SANE_Action action, void *value)

391

{

392

SANE_Status status;

393

gchar *old_value;

394

395

switch (option->type) {

396

case SANE_TYPE_BOOL:

397

old_value = g_strdup_printf (*((SANE_Bool *) value) ? "SANE_TRUE" : "SANE_FALSE");

398

break;

399

case SANE_TYPE_INT:

400

old_value = g_strdup_printf ("%d", *((SANE_Int *) value));

401

break;

402

case SANE_TYPE_FIXED:

403

old_value = g_strdup_printf ("%f", SANE_UNFIX (*((SANE_Fixed *) value)));

404

break;

405

case SANE_TYPE_STRING:

406

old_value = g_strdup_printf ("\"%s\"", (char *) value);

407

break;

408

default:

409

old_value = g_strdup ("?");

410

break;

411

}

412

413

status = sane_control_option (handle, index, action, value, NULL);

414

switch (option->type) {

415

case SANE_TYPE_BOOL:

416

g_debug ("sane_control_option (%d, %s, %s) -> (%s, %s)",

417

index, get_action_string (action),

418

*((SANE_Bool *) value) ? "SANE_TRUE" : "SANE_FALSE",

419

get_status_string (status),

420

old_value);

421

break;

422

case SANE_TYPE_INT:

423

g_debug ("sane_control_option (%d, %s, %d) -> (%s, %s)",

424

index, get_action_string (action),

425

*((SANE_Int *) value),

426

get_status_string (status),

427

old_value);

428

break;

429

case SANE_TYPE_FIXED:

430

g_debug ("sane_control_option (%d, %s, %f) -> (%s, %s)",

431

index, get_action_string (action),

432

SANE_UNFIX (*((SANE_Fixed *) value)),

433

get_status_string (status),

434

old_value);

435

break;

436

case SANE_TYPE_STRING:

437

g_debug ("sane_control_option (%d, %s, \"%s\") -> (%s, %s)",

438

index, get_action_string (action),

439

(char *) value,

440

get_status_string (status),

441

old_value);

442

break;

443

default:

444

break;

445

}

446

g_free (old_value);

447

448

if (status != SANE_STATUS_GOOD)

449

g_warning ("Error setting option %s: %s", option->name, sane_strstatus(status));

450

451

return status == SANE_STATUS_GOOD;

452

}

453

454

455

static gboolean

456

set_default_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index)

457

{

458

SANE_Status status;

459

460

/* Check if supports automatic option */

461

if ((option->cap & SANE_CAP_AUTOMATIC) == 0)

462

return FALSE;

463

464

status = sane_control_option (handle, option_index, SANE_ACTION_SET_AUTO, NULL, NULL);

465

g_debug ("sane_control_option (%d, SANE_ACTION_SET_AUTO) -> %s",

466

option_index, get_status_string (status));

467

if (status != SANE_STATUS_GOOD)

468

g_warning ("Error setting default option %s: %s", option->name, sane_strstatus(status));

469

470

return status == SANE_STATUS_GOOD;

471

}

472

473

474

static void

475

set_bool_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, SANE_Bool value, SANE_Bool *result)

476

{

477

SANE_Bool v = value;

478

g_return_if_fail (option->type == SANE_TYPE_BOOL);

479

control_option (handle, option, option_index, SANE_ACTION_SET_VALUE, &v);

480

if (result)

481

*result = v;

482

}

483

484

485

static void

486

set_int_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, SANE_Int value, SANE_Int *result)

487

{

488

SANE_Int v = value;

489

490

g_return_if_fail (option->type == SANE_TYPE_INT);

491

492

if (option->constraint_type == SANE_CONSTRAINT_RANGE) {

493

if (option->constraint.range->quant)

494

v *= option->constraint.range->quant;

495

if (v < option->constraint.range->min)

496

v = option->constraint.range->min;

497

if (v > option->constraint.range->max)

498

v = option->constraint.range->max;

499

}

500

else if (option->constraint_type == SANE_CONSTRAINT_WORD_LIST) {

501

int i;

502

SANE_Int distance = INT_MAX, nearest = 0;

503

504

/* Find nearest value to requested */

505

for (i = 0; i < option->constraint.word_list[0]; i++) {

506

SANE_Int x = option->constraint.word_list[i+1];

507

if (abs (x - v) < distance) {

508

distance = abs (x - v);

509

nearest = x;

510

}

511

}

512

v = nearest;

513

}

514

515

control_option (handle, option, option_index, SANE_ACTION_SET_VALUE, &v);

516

if (result)

517

*result = v;

518

}

519

520

521

static void

522

set_fixed_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, gdouble value, gdouble *result)

523

{

524

gdouble v = value;

525

SANE_Fixed v_fixed;

526

527

g_return_if_fail (option->type == SANE_TYPE_FIXED);

528

529

if (option->constraint_type == SANE_CONSTRAINT_RANGE) {

530

double min = SANE_UNFIX (option->constraint.range->min);

531

double max = SANE_UNFIX (option->constraint.range->max);

532

533

if (v < min)

534

v = min;

535

if (v > max)

536

v = max;

537

}

538

else if (option->constraint_type == SANE_CONSTRAINT_WORD_LIST) {

539

int i;

540

double distance = DBL_MAX, nearest = 0.0;

541

542

/* Find nearest value to requested */

543

for (i = 0; i < option->constraint.word_list[0]; i++) {

544

double x = SANE_UNFIX (option->constraint.word_list[i+1]);

545

if (fabs (x - v) < distance) {

546

distance = fabs (x - v);

547

nearest = x;

548

}

549

}

550

v = nearest;

551

}

552

553

v_fixed = SANE_FIX (v);

554

control_option (handle, option, option_index, SANE_ACTION_SET_VALUE, &v_fixed);

555

if (result)

556

*result = SANE_UNFIX (v_fixed);

557

}

558

559

560

static gboolean

561

set_string_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, const char *value, char **result)

562

{

563

char *string;

564

gsize value_size, size;

565

gboolean error;

566

567

g_return_val_if_fail (option->type == SANE_TYPE_STRING, FALSE);

568

569

value_size = strlen (value) + 1;

570

size = option->size > value_size ? option->size : value_size;

571

string = g_malloc(sizeof(char) * size);

572

strcpy (string, value);

573

error = control_option (handle, option, option_index, SANE_ACTION_SET_VALUE, string);

574

if (result)

575

*result = string;

576

else

577

g_free (string);

578

579

return error;

580

}

581

582

583

static gboolean

584

set_constrained_string_option (SANE_Handle handle, const SANE_Option_Descriptor *option, SANE_Int option_index, const char *values[], char **result)

585

{

586

gint i, j;

587

588

g_return_val_if_fail (option->type == SANE_TYPE_STRING, FALSE);

589

g_return_val_if_fail (option->constraint_type == SANE_CONSTRAINT_STRING_LIST, FALSE);

590

591

for (i = 0; values[i] != NULL; i++) {

592

for (j = 0; option->constraint.string_list[j]; j++) {

593

if (strcmp (values[i], option->constraint.string_list[j]) == 0)

594

break;

595

}

596

597

if (option->constraint.string_list[j] != NULL)

598

return set_string_option (handle, option, option_index, values[i], result);

599

}

600

601

return FALSE;

602

}

603

604

605

static void

606

log_option (SANE_Int index, const SANE_Option_Descriptor *option)

607

{

608

GString *string;

609

SANE_Word i;

610

SANE_Int cap;

611

612

string = g_string_new ("");

613

614

g_string_append_printf (string, "Option %d:", index);

615

616

if (option->name)

617

g_string_append_printf (string, " name='%s'", option->name);

618

619

if (option->title)

620

g_string_append_printf (string, " title='%s'", option->title);

621

622

switch (option->type) {

623

case SANE_TYPE_BOOL:

624

g_string_append (string, " type=bool");

625

break;

626

case SANE_TYPE_INT:

627

g_string_append (string, " type=int");

628

break;

629

case SANE_TYPE_FIXED:

630

g_string_append (string, " type=fixed");

631

break;

632

case SANE_TYPE_STRING:

633

g_string_append (string, " type=string");

634

break;

635

case SANE_TYPE_BUTTON:

636

g_string_append (string, " type=button");

637

break;

638

case SANE_TYPE_GROUP:

639

g_string_append (string, " type=group");

640

break;

641

default:

642

g_string_append_printf (string, " type=%d", option->type);

643

break;

644

}

645

646

g_string_append_printf (string, " size=%d", option->size);

647

648

switch (option->unit) {

649

case SANE_UNIT_NONE:

650

break;

651

case SANE_UNIT_PIXEL:

652

g_string_append (string, " unit=pixels");

653

break;

654

case SANE_UNIT_BIT:

655

g_string_append (string, " unit=bits");

656

break;

657

case SANE_UNIT_MM:

658

g_string_append (string, " unit=mm");

659

break;

660

case SANE_UNIT_DPI:

661

g_string_append (string, " unit=dpi");

662

break;

663

case SANE_UNIT_PERCENT:

664

g_string_append (string, " unit=percent");

665

break;

666

case SANE_UNIT_MICROSECOND:

667

g_string_append (string, " unit=microseconds");

668

break;

669

default:

670

g_string_append_printf (string, " unit=%d", option->unit);

671

break;

672

}

673

674

switch (option->constraint_type) {

675

case SANE_CONSTRAINT_RANGE:

676

if (option->type == SANE_TYPE_FIXED)

677

g_string_append_printf (string, " min=%f, max=%f, quant=%d",

678

SANE_UNFIX (option->constraint.range->min), SANE_UNFIX (option->constraint.range->max),

679

option->constraint.range->quant);

680

else

681

g_string_append_printf (string, " min=%d, max=%d, quant=%d",

682

option->constraint.range->min, option->constraint.range->max,

683

option->constraint.range->quant);

684

break;

685

case SANE_CONSTRAINT_WORD_LIST:

686

g_string_append (string, " values=[");

687

for (i = 0; i < option->constraint.word_list[0]; i++) {

688

if (i != 0)

689

g_string_append (string, ", ");

690

if (option->type == SANE_TYPE_INT)

691

g_string_append_printf (string, "%d", option->constraint.word_list[i+1]);

692

else

693

g_string_append_printf (string, "%f", SANE_UNFIX (option->constraint.word_list[i+1]));

694

}

695

g_string_append (string, "]");

696

break;

697

case SANE_CONSTRAINT_STRING_LIST:

698

g_string_append (string, " values=[");

699

for (i = 0; option->constraint.string_list[i]; i++) {

700

if (i != 0)

701

g_string_append (string, ", ");

702

g_string_append_printf (string, "\"%s\"", option->constraint.string_list[i]);

703

}

704

g_string_append (string, "]");

705

break;

706

default:

707

break;

708

}

709

710

cap = option->cap;

711

if (cap) {

712

struct {

713

SANE_Int cap;

714

const char *name;

715

} caps[] = {

716

{ SANE_CAP_SOFT_SELECT, "soft-select"},

717

{ SANE_CAP_HARD_SELECT, "hard-select"},

718

{ SANE_CAP_SOFT_DETECT, "soft-detect"},

719

{ SANE_CAP_EMULATED, "emulated"},

720

{ SANE_CAP_AUTOMATIC, "automatic"},

721

{ SANE_CAP_INACTIVE, "inactive"},

722

{ SANE_CAP_ADVANCED, "advanced"},

723

{ 0, NULL}

724

};

725

int i, n = 0;

726

727

g_string_append (string, " cap=");

728

for (i = 0; caps[i].cap > 0; i++) {

729

if (cap & caps[i].cap) {

730

cap &= ~caps[i].cap;

731

if (n != 0)

732

g_string_append (string, ",");

733

g_string_append (string, caps[i].name);

734

n++;

735

}

736

}

737

/* Unknown capabilities */

738

if (cap) {

739

if (n != 0)

740

g_string_append (string, ",");

741

g_string_append_printf (string, "%x", cap);

742

}

743

}

744

745

g_debug ("%s", string->str);

746

g_string_free (string, TRUE);

747

748

if (option->desc)

749

g_debug (" Description: %s", option->desc);

750

}

751

752

753

static void

754

authorization_cb (SANE_String_Const resource, SANE_Char username[SANE_MAX_USERNAME_LEN], SANE_Char password[SANE_MAX_PASSWORD_LEN])

755

{

756

Scanner *scanner;

757

Credentials *credentials;

758

759

scanner = g_hash_table_lookup (scanners, g_thread_self ());

760

761

emit_signal (scanner, AUTHORIZE, g_strdup (resource));

762

763

credentials = g_async_queue_pop (scanner->priv->authorize_queue);

764

strncpy (username, credentials->username, SANE_MAX_USERNAME_LEN);

765

strncpy (password, credentials->password, SANE_MAX_PASSWORD_LEN);

766

g_free (credentials);

767

}

768

769

770

void

771

scanner_authorize (Scanner *scanner, const gchar *username, const gchar *password)

772

{

773

Credentials *credentials;

774

775

credentials = g_malloc (sizeof (Credentials));

776

credentials->username = g_strdup (username);

777

credentials->password = g_strdup (password);

778

g_async_queue_push (scanner->priv->authorize_queue, credentials);

779

}

780

781

782

static void

783

close_device (Scanner *scanner)

784

{

785

GList *iter;

786

787

if (scanner->priv->handle) {

788

sane_cancel (scanner->priv->handle);

789

g_debug ("sane_cancel ()");

790

791

sane_close (scanner->priv->handle);

792

g_debug ("sane_close ()");

793

scanner->priv->handle = NULL;

794

}

795

796

g_free (scanner->priv->buffer);

797

scanner->priv->buffer = NULL;

798

799

for (iter = scanner->priv->job_queue; iter; iter = iter->next) {

800

ScanJob *job = (ScanJob *) iter->data;

801

g_free (job->device);

802

g_free (job);

803

}

804

g_list_free (scanner->priv->job_queue);

805

scanner->priv->job_queue = NULL;

806

807

set_scanning (scanner, FALSE);

808

}

809

810

static void

811

fail_scan (Scanner *scanner, gint error_code, const gchar *error_string)

812

{

813

close_device (scanner);

814

scanner->priv->state = STATE_IDLE;

815

emit_signal (scanner, SCAN_FAILED, g_error_new (SCANNER_TYPE, error_code, "%s", error_string));

816

}

817

818

819

static gboolean

820

handle_requests (Scanner *scanner)

821

{

822

gint request_count = 0;

823

824

/* Redetect when idle */

825

if (scanner->priv->state == STATE_IDLE && scanner->priv->redetect)

826

scanner->priv->state = STATE_REDETECT;

827

828

/* Process all requests */

829

while (TRUE) {

830

ScanRequest *request = NULL;

831

832

if ((scanner->priv->state == STATE_IDLE && request_count == 0) ||

833

g_async_queue_length (scanner->priv->scan_queue) > 0)

834

request = g_async_queue_pop (scanner->priv->scan_queue);

835

else

836

return TRUE;

837

838

g_debug ("Processing request");

839

request_count++;

840

841

switch (request->type) {

842

case REQUEST_REDETECT:

843

break;

844

845

case REQUEST_START_SCAN:

846

scanner->priv->job_queue = g_list_append (scanner->priv->job_queue, request->job);

847

break;

848

849

case REQUEST_CANCEL:

850

fail_scan (scanner, SANE_STATUS_CANCELLED, "Scan cancelled - do not report this error");

851

break;

852

853

case REQUEST_QUIT:

854

close_device (scanner);

855

g_free (request);

856

return FALSE;

857

}

858

859

g_free (request);

860

}

861

862

return TRUE;

863

}

864

865

866

static void

867

do_open (Scanner *scanner)

868

{

869

SANE_Status status;

870

ScanJob *job;

871

872

job = (ScanJob *) scanner->priv->job_queue->data;

873

874

scanner->priv->line_count = 0;

875

scanner->priv->pass_number = 0;

876

scanner->priv->page_number = 0;

877

scanner->priv->notified_page = -1;

878

scanner->priv->option_index = 0;

879

scanner->priv->br_x_option_index = 0;

880

scanner->priv->br_y_option_index = 0;

881

882

if (!job->device && scanner->priv->default_device)

883

job->device = g_strdup (scanner->priv->default_device);

884

885

if (!job->device) {

886

g_warning ("No scan device available");

887

fail_scan (scanner, 0,

888

/* Error displayed when no scanners to scan with */

889

_("No scanners available. Please connect a scanner."));

890

return;

891

}

892

893

/* See if we can use the already open device */

894

if (scanner->priv->handle) {

895

if (strcmp (scanner->priv->current_device, job->device) == 0) {

896

scanner->priv->state = STATE_GET_OPTION;

897

return;

898

}

899

900

sane_close (scanner->priv->handle);

901

g_debug ("sane_close ()");

902

scanner->priv->handle = NULL;

903

}

904

905

g_free (scanner->priv->current_device);

906

scanner->priv->current_device = NULL;

907

908

status = sane_open (job->device, &scanner->priv->handle);

909

g_debug ("sane_open (\"%s\") -> %s", job->device, get_status_string (status));

910

911

if (status != SANE_STATUS_GOOD) {

912

g_warning ("Unable to get open device: %s", sane_strstatus (status));

913

scanner->priv->handle = NULL;

914

fail_scan (scanner, status,

915

/* Error displayed when cannot connect to scanner */

916

_("Unable to connect to scanner"));

917

return;

918

}

919

920

scanner->priv->current_device = g_strdup (job->device);

921

scanner->priv->state = STATE_GET_OPTION;

922

}

923

924

925

static void

926

do_get_option (Scanner *scanner)

927

{

928

const SANE_Option_Descriptor *option;

929

SANE_Int option_index;

930

ScanJob *job;

931

932

job = (ScanJob *) scanner->priv->job_queue->data;

933

934

option = sane_get_option_descriptor (scanner->priv->handle, scanner->priv->option_index);

935

g_debug ("sane_get_option_descriptor (%d)", scanner->priv->option_index);

936

option_index = scanner->priv->option_index;

937

scanner->priv->option_index++;

938

939

if (!option) {

940

/* Always use maximum scan area - some scanners default to using partial areas. This should be patched in sane-backends */

941

if (scanner->priv->br_x_option_index) {

942

option = sane_get_option_descriptor (scanner->priv->handle, scanner->priv->br_x_option_index);

943

g_debug ("sane_get_option_descriptor (%d)", scanner->priv->br_x_option_index);

944

if (option->constraint_type == SANE_CONSTRAINT_RANGE) {

945

if (option->type == SANE_TYPE_FIXED)

946

set_fixed_option (scanner->priv->handle, option, scanner->priv->br_x_option_index, SANE_UNFIX (option->constraint.range->max), NULL);

947

else

948

set_int_option (scanner->priv->handle, option, scanner->priv->br_x_option_index, option->constraint.range->max, NULL);

949

}

950

}

951

if (scanner->priv->br_y_option_index) {

952

option = sane_get_option_descriptor (scanner->priv->handle, scanner->priv->br_y_option_index);

953

g_debug ("sane_get_option_descriptor (%d)", scanner->priv->br_y_option_index);

954

if (option->constraint_type == SANE_CONSTRAINT_RANGE) {

955

if (option->type == SANE_TYPE_FIXED)

956

set_fixed_option (scanner->priv->handle, option, scanner->priv->br_y_option_index, SANE_UNFIX (option->constraint.range->max), NULL);

957

else

958

set_int_option (scanner->priv->handle, option, scanner->priv->br_y_option_index, option->constraint.range->max, NULL);

959

}

960

}

961

962

scanner->priv->state = STATE_START;

963

return;

964

}

965

966

log_option (option_index, option);

967

968

/* Ignore groups */

969

if (option->type == SANE_TYPE_GROUP)

970

return;

971

972

/* Option disabled */

973

if (option->cap & SANE_CAP_INACTIVE)

974

return;

975

976

/* Some options are unnammed (e.g. Option 0) */

977

if (option->name == NULL)

978

return;

979

980

if (strcmp (option->name, SANE_NAME_SCAN_RESOLUTION) == 0) {

981

if (option->type == SANE_TYPE_FIXED) {

982

set_fixed_option (scanner->priv->handle, option, option_index, job->dpi, &job->dpi);

983

}

984

else {

985

SANE_Int dpi;

986

set_int_option (scanner->priv->handle, option, option_index, job->dpi, &dpi);

987

job->dpi = dpi;

988

}

989

}

990

else if (strcmp (option->name, SANE_NAME_SCAN_SOURCE) == 0) {

991

const char *flatbed_sources[] =

992

{

993

"Auto",

994

SANE_I18N ("Auto"),

995

"Flatbed",

996

SANE_I18N ("Flatbed"),

997

"FlatBed",

998

"Normal",

999

SANE_I18N ("Normal"),

1000

NULL

1001

};

1002

1003

const char *adf_sources[] =

1004

{

1005

"Automatic Document Feeder",

1006

SANE_I18N ("Automatic Document Feeder"),

1007

"ADF",

1008

"Automatic Document Feeder(left aligned)", /* Seen in the proprietary brother3 driver */

1009

"Automatic Document Feeder(centrally aligned)", /* Seen in the proprietary brother3 driver */

1010

NULL

1011

};

1012

1013

const char *adf_front_sources[] =

1014

{

1015

"ADF Front",

1016

SANE_I18N ("ADF Front"),

1017

NULL

1018

};

1019

1020

const char *adf_back_sources[] =

1021

{

1022

"ADF Back",

1023

SANE_I18N ("ADF Back"),

1024

NULL

1025

};

1026

1027

const char *adf_duplex_sources[] =

1028

{

1029

"ADF Duplex",

1030

SANE_I18N ("ADF Duplex"),

1031

NULL

1032

};

1033

1034

switch (job->type) {

1035

case SCAN_SINGLE:

1036

if (!set_default_option (scanner->priv->handle, option, option_index))

1037

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, flatbed_sources, NULL))

1038

g_warning ("Unable to set single page source, please file a bug");

1039

break;

1040

case SCAN_ADF_FRONT:

1041

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_front_sources, NULL))

1042

if (!!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_sources, NULL))

1043

g_warning ("Unable to set front ADF source, please file a bug");

1044

break;

1045

case SCAN_ADF_BACK:

1046

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_back_sources, NULL))

1047

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_sources, NULL))

1048

g_warning ("Unable to set back ADF source, please file a bug");

1049

break;

1050

case SCAN_ADF_BOTH:

1051

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_duplex_sources, NULL))

1052

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, adf_sources, NULL))

1053

g_warning ("Unable to set duplex ADF source, please file a bug");

1054

break;

1055

}

1056

}

1057

else if (strcmp (option->name, "duplex") == 0) {

1058

if (option->type == SANE_TYPE_BOOL)

1059

set_bool_option (scanner->priv->handle, option, option_index, job->type == SCAN_ADF_BOTH, NULL);

1060

}

1061

else if (strcmp (option->name, "batch-scan") == 0) {

1062

if (option->type == SANE_TYPE_BOOL)

1063

set_bool_option (scanner->priv->handle, option, option_index, job->type != SCAN_SINGLE, NULL);

1064

}

1065

else if (strcmp (option->name, SANE_NAME_BIT_DEPTH) == 0) {

1066

if (job->depth > 0)

1067

set_int_option (scanner->priv->handle, option, option_index, job->depth, NULL);

1068

}

1069

else if (strcmp (option->name, SANE_NAME_SCAN_MODE) == 0) {

1070

/* The names of scan modes often used in drivers, as taken from the sane-backends source */

1071

const char *color_scan_modes[] =

1072

{

1073

SANE_VALUE_SCAN_MODE_COLOR,

1074

"Color",

1075

"24bit Color", /* Seen in the proprietary brother3 driver */

1076

NULL

1077

};

1078

const char *gray_scan_modes[] =

1079

{

1080

SANE_VALUE_SCAN_MODE_GRAY,

1081

"Gray",

1082

"Grayscale",

1083

SANE_I18N ("Grayscale"),

1084

"True Gray", /* Seen in the proprietary brother3 driver */

1085

NULL

1086

};

1087

const char *lineart_scan_modes[] =

1088

{

1089

SANE_VALUE_SCAN_MODE_LINEART,

1090

"Lineart",

1091

"LineArt",

1092

SANE_I18N ("LineArt"),

1093

"Black & White",

1094

SANE_I18N ("Black & White"),

1095

"Binary",

1096

SANE_I18N ("Binary"),

1097

"Thresholded",

1098

SANE_VALUE_SCAN_MODE_GRAY,

1099

"Gray",

1100

"Grayscale",

1101

SANE_I18N ("Grayscale"),

1102

"True Gray", /* Seen in the proprietary brother3 driver */

1103

NULL

1104

};

1105

1106

switch (job->scan_mode) {

1107

case SCAN_MODE_COLOR:

1108

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, color_scan_modes, NULL))

1109

g_warning ("Unable to set Color mode, please file a bug");

1110

break;

1111

case SCAN_MODE_GRAY:

1112

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, gray_scan_modes, NULL))

1113

g_warning ("Unable to set Gray mode, please file a bug");

1114

break;

1115

case SCAN_MODE_LINEART:

1116

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, lineart_scan_modes, NULL))

1117

g_warning ("Unable to set Lineart mode, please file a bug");

1118

break;

1119

default:

1120

break;

1121

}

1122

}

1123

/* Disable compression, we will compress after scanning */

1124

else if (strcmp (option->name, "compression") == 0) {

1125

const char *disable_compression_names[] =

1126

{

1127

SANE_I18N ("None"),

1128

SANE_I18N ("none"),

1129

"None",

1130

"none",

1131

NULL

1132

};

1133

1134

if (!set_constrained_string_option (scanner->priv->handle, option, option_index, disable_compression_names, NULL))

1135

g_warning ("Unable to disable compression, please file a bug");

1136

}

1137

else if (strcmp (option->name, SANE_NAME_SCAN_BR_X) == 0)

1138

scanner->priv->br_x_option_index = option_index;

1139

else if (strcmp (option->name, SANE_NAME_SCAN_BR_Y) == 0)

1140

scanner->priv->br_y_option_index = option_index;

1141

else if (strcmp (option->name, SANE_NAME_PAGE_WIDTH) == 0) {

1142

if (job->page_width > 0.0) {

1143

if (option->type == SANE_TYPE_FIXED)

1144

set_fixed_option (scanner->priv->handle, option, option_index, job->page_width / 10.0, NULL);

1145

else

1146

set_int_option (scanner->priv->handle, option, option_index, job->page_width / 10, NULL);

1147

}

1148

}

1149

else if (strcmp (option->name, SANE_NAME_PAGE_HEIGHT) == 0) {

1150

if (job->page_height > 0.0) {

1151

if (option->type == SANE_TYPE_FIXED)

1152

set_fixed_option (scanner->priv->handle, option, option_index, job->page_height / 10.0, NULL);

1153

else

1154

set_int_option (scanner->priv->handle, option, option_index, job->page_height / 10, NULL);

1155

}

1156

}

1157

1158

/* Test scanner options (hoping will not effect other scanners...) */

1159

if (strcmp (scanner->priv->current_device, "test") == 0) {

1160

if (strcmp (option->name, "hand-scanner") == 0) {

1161

set_bool_option (scanner->priv->handle, option, option_index, FALSE, NULL);

1162

}

1163

else if (strcmp (option->name, "three-pass") == 0) {

1164

set_bool_option (scanner->priv->handle, option, option_index, FALSE, NULL);

1165

}

1166

else if (strcmp (option->name, "test-picture") == 0) {

1167

set_string_option (scanner->priv->handle, option, option_index, "Color pattern", NULL);

1168

}

1169

else if (strcmp (option->name, "read-delay") == 0) {

1170

set_bool_option (scanner->priv->handle, option, option_index, TRUE, NULL);

1171

}

1172

else if (strcmp (option->name, "read-delay-duration") == 0) {

1173

set_int_option (scanner->priv->handle, option, option_index, 200000, NULL);

1174

}

1175

}

1176

}

1177

1178

1179

static void

1180

do_complete_document (Scanner *scanner)

1181

{

1182

ScanJob *job;

1183

1184

job = (ScanJob *) scanner->priv->job_queue->data;

1185

g_free (job->device);

1186

g_free (job);

1187

scanner->priv->job_queue = g_list_remove_link (scanner->priv->job_queue, scanner->priv->job_queue);

1188

1189

scanner->priv->state = STATE_IDLE;

1190

1191

/* Continue onto the next job */

1192

if (scanner->priv->job_queue) {

1193

scanner->priv->state = STATE_OPEN;

1194

return;

1195

}

1196

1197

/* Trigger timeout to close */

1198

// TODO

1199

1200

emit_signal (scanner, DOCUMENT_DONE, NULL);

1201

set_scanning (scanner, FALSE);

1202

}

1203

1204

1205

static void

1206

do_start (Scanner *scanner)

1207

{

1208

SANE_Status status;

1209

1210

emit_signal (scanner, EXPECT_PAGE, NULL);

1211

1212

status = sane_start (scanner->priv->handle);

1213

g_debug ("sane_start (page=%d, pass=%d) -> %s", scanner->priv->page_number, scanner->priv->pass_number, get_status_string (status));

1214

if (status == SANE_STATUS_GOOD) {

1215

scanner->priv->state = STATE_GET_PARAMETERS;

1216

}

1217

else if (status == SANE_STATUS_NO_DOCS) {

1218

do_complete_document (scanner);

1219

}

1220

else {

1221

g_warning ("Unable to start device: %s", sane_strstatus (status));

1222

fail_scan (scanner, status,

1223

/* Error display when unable to start scan */

1224

_("Unable to start scan"));

1225

}

1226

}

1227

1228

1229

static void

1230

do_get_parameters (Scanner *scanner)

1231

{

1232

SANE_Status status;

1233

ScanPageInfo *info;

1234

ScanJob *job;

1235

1236

status = sane_get_parameters (scanner->priv->handle, &scanner->priv->parameters);

1237

g_debug ("sane_get_parameters () -> %s", get_status_string (status));

1238

if (status != SANE_STATUS_GOOD) {

1239

g_warning ("Unable to get device parameters: %s", sane_strstatus (status));

1240

fail_scan (scanner, status,

1241

/* Error displayed when communication with scanner broken */

1242

_("Error communicating with scanner"));

1243

return;

1244

}

1245

1246

job = (ScanJob *) scanner->priv->job_queue->data;

1247

1248

g_debug ("Parameters: format=%s last_frame=%s bytes_per_line=%d pixels_per_line=%d lines=%d depth=%d",

1249

get_frame_string (scanner->priv->parameters.format),

1250

scanner->priv->parameters.last_frame ? "SANE_TRUE" : "SANE_FALSE",

1251

scanner->priv->parameters.bytes_per_line,

1252

scanner->priv->parameters.pixels_per_line,

1253

scanner->priv->parameters.lines,

1254

scanner->priv->parameters.depth);

1255

1256

info = g_malloc(sizeof(ScanPageInfo));

1257

info->width = scanner->priv->parameters.pixels_per_line;

1258

info->height = scanner->priv->parameters.lines;

1259

info->depth = scanner->priv->parameters.depth;

1260

/* Reduce bit depth if requested lower than received */

1261

// FIXME: This a hack and only works on 8 bit gray to 2 bit gray

1262

if (scanner->priv->parameters.depth == 8 && scanner->priv->parameters.format == SANE_FRAME_GRAY && job->depth == 2 && job->scan_mode == SCAN_MODE_GRAY)

1263

info->depth = job->depth;

1264

info->n_channels = scanner->priv->parameters.format == SANE_FRAME_GRAY ? 1 : 3;

1265

info->dpi = job->dpi; // FIXME: This is the requested DPI, not the actual DPI

1266

info->device = g_strdup (scanner->priv->current_device);

1267

1268

if (scanner->priv->page_number != scanner->priv->notified_page) {

1269

emit_signal (scanner, GOT_PAGE_INFO, info);

1270

scanner->priv->notified_page = scanner->priv->page_number;

1271

}

1272

1273

/* Prepare for read */

1274

scanner->priv->buffer_size = scanner->priv->parameters.bytes_per_line + 1; /* Use +1 so buffer is not resized if driver returns one line per read */

1275

scanner->priv->buffer = g_malloc (sizeof(SANE_Byte) * scanner->priv->buffer_size);

1276

scanner->priv->n_used = 0;

1277

scanner->priv->line_count = 0;

1278

scanner->priv->pass_number = 0;

1279

scanner->priv->state = STATE_READ;

1280

}

1281

1282

1283

static void

1284

do_complete_page (Scanner *scanner)

1285

{

1286

ScanJob *job;

1287

1288

emit_signal (scanner, PAGE_DONE, NULL);

1289

1290

job = (ScanJob *) scanner->priv->job_queue->data;

1291

1292

/* If multi-pass then scan another page */

1293

if (!scanner->priv->parameters.last_frame) {

1294

scanner->priv->pass_number++;

1295

scanner->priv->state = STATE_START;

1296

return;

1297

}

1298

1299

/* Go back for another page */

1300

if (job->type != SCAN_SINGLE) {

1301

scanner->priv->page_number++;

1302

scanner->priv->pass_number = 0;

1303

emit_signal (scanner, PAGE_DONE, NULL);

1304

scanner->priv->state = STATE_START;

1305

return;

1306

}

1307

1308

sane_cancel (scanner->priv->handle);

1309

g_debug ("sane_cancel ()");

1310

1311

do_complete_document (scanner);

1312

}

1313

1314

1315

static void

1316

do_read (Scanner *scanner)

1317

{

1318

ScanJob *job;

1319

SANE_Status status;

1320

SANE_Int n_to_read, n_read;

1321

gboolean full_read = FALSE;

1322

1323

job = (ScanJob *) scanner->priv->job_queue->data;

1324

1325

/* Read as many bytes as we expect */

1326

n_to_read = scanner->priv->buffer_size - scanner->priv->n_used;

1327

1328

status = sane_read (scanner->priv->handle,

1329

scanner->priv->buffer + scanner->priv->n_used,

1330

n_to_read, &n_read);

1331

g_debug ("sane_read (%d) -> (%s, %d)", n_to_read, get_status_string (status), n_read);

1332

1333

/* Completed read */

1334

if (status == SANE_STATUS_EOF) {

1335

if (scanner->priv->parameters.lines > 0 && scanner->priv->line_count != scanner->priv->parameters.lines)

1336

g_warning ("Scan completed with %d lines, expected %d lines", scanner->priv->parameters.lines, scanner->priv->parameters.lines);

1337

if (scanner->priv->n_used > 0)

1338

g_warning ("Scan complete with %d bytes of unused data", scanner->priv->n_used);

1339

do_complete_page (scanner);

1340

return;

1341

}

1342

1343

/* Communication error */

1344

if (status != SANE_STATUS_GOOD) {

1345

g_warning ("Unable to read frame from device: %s", sane_strstatus (status));

1346

fail_scan (scanner, status,

1347

/* Error displayed when communication with scanner broken */

1348

_("Error communicating with scanner"));

1349

return;

1350

}

1351

1352

if (scanner->priv->n_used == 0 && n_read == scanner->priv->buffer_size)

1353

full_read = TRUE;

1354

scanner->priv->n_used += n_read;

1355

1356

/* Feed out lines */

1357

if (scanner->priv->n_used >= scanner->priv->parameters.bytes_per_line) {

1358

ScanLine *line;

1359

int i, n_remaining;

1360

1361

line = g_malloc(sizeof(ScanLine));

1362

switch (scanner->priv->parameters.format) {

1363

case SANE_FRAME_GRAY:

1364

line->channel = 0;

1365

break;

1366

case SANE_FRAME_RGB:

1367

line->channel = -1;

1368

break;

1369

case SANE_FRAME_RED:

1370

line->channel = 0;

1371

break;

1372

case SANE_FRAME_GREEN:

1373

line->channel = 1;

1374

break;

1375

case SANE_FRAME_BLUE:

1376

line->channel = 2;

1377

break;

1378

}

1379

line->width = scanner->priv->parameters.pixels_per_line;

1380

line->depth = scanner->priv->parameters.depth;

1381

line->data = scanner->priv->buffer;

1382

line->data_length = scanner->priv->parameters.bytes_per_line;

1383

line->number = scanner->priv->line_count;

1384

line->n_lines = scanner->priv->n_used / line->data_length;

1385

1386

scanner->priv->buffer = NULL;

1387

scanner->priv->line_count += line->n_lines;

1388

1389

/* Increase buffer size if did full read */

1390

if (full_read)

1391

scanner->priv->buffer_size += scanner->priv->parameters.bytes_per_line;

1392

1393

scanner->priv->buffer = g_malloc(sizeof(SANE_Byte) * scanner->priv->buffer_size);

1394

n_remaining = scanner->priv->n_used - (line->n_lines * line->data_length);

1395

scanner->priv->n_used = 0;

1396

for (i = 0; i < n_remaining; i++) {

1397

scanner->priv->buffer[i] = line->data[i + (line->n_lines * line->data_length)];

1398

scanner->priv->n_used++;

1399

}

1400

1401

/* Reduce bit depth if requested lower than received */

1402

// FIXME: This a hack and only works on 8 bit gray to 2 bit gray

1403

if (scanner->priv->parameters.depth == 8 && scanner->priv->parameters.format == SANE_FRAME_GRAY &&

1404

job->depth == 2 && job->scan_mode == SCAN_MODE_GRAY) {

1405

gint block_shift = 6;

1406

guchar block = 0;

1407

guchar *write_ptr = line->data;

1408

1409

for (i = 0; i < line->n_lines; i++) {

1410

guchar *in_line = line->data + i * line->data_length;

1411

gint x;

1412

1413

for (x = 0; x < line->width; x++) {

1414

guchar *p = in_line + x;

1415

guchar sample;

1416

1417

if (p[0] >= 192)

1418

sample = 3;

1419

else if (p[0] >= 128)

1420

sample = 2;

1421

else if (p[0] >= 64)

1422

sample = 1;

1423

else

1424

sample = 0;

1425

1426

block |= sample << block_shift;

1427

if (block_shift == 0) {

1428

*write_ptr = block;

1429

write_ptr++;

1430

block = 0;

1431

block_shift = 6;

1432

}

1433

else {

1434

block_shift -= 2;

1435

}

1436

}

1437

1438

/* Finish each line on a byte boundary */

1439

if (block_shift != 6) {

1440

*write_ptr = block;

1441

write_ptr++;

1442

block = 0;

1443

block_shift = 6;

1444

}

1445

}

1446

1447

line->data_length = (line->width * 2 + 7) / 8;

1448

}

1449

1450

emit_signal (scanner, GOT_LINE, line);

1451

}

1452

}

1453

1454

1455

static gpointer

1456

scan_thread (Scanner *scanner)

1457

{

1458

SANE_Status status;

1459

SANE_Int version_code;

1460

1461

g_hash_table_insert (scanners, g_thread_self (), scanner);

1462

1463

scanner->priv->state = STATE_IDLE;

1464

1465

status = sane_init (&version_code, authorization_cb);

1466

g_debug ("sane_init () -> %s", get_status_string (status));

1467

if (status != SANE_STATUS_GOOD) {

1468

g_warning ("Unable to initialize SANE backend: %s", sane_strstatus(status));

1469

return FALSE;

1470

}

1471

g_debug ("SANE version %d.%d.%d",

1472

SANE_VERSION_MAJOR(version_code),

1473

SANE_VERSION_MINOR(version_code),

1474

SANE_VERSION_BUILD(version_code));

1475

1476

/* Scan for devices on first start */

1477

scanner_redetect (scanner);

1478

1479

while (handle_requests (scanner)) {

1480

switch (scanner->priv->state) {

1481

case STATE_IDLE:

1482

if (scanner->priv->job_queue) {

1483

set_scanning (scanner, TRUE);

1484

scanner->priv->state = STATE_OPEN;

1485

}

1486

break;

1487

case STATE_REDETECT:

1488

do_redetect (scanner);

1489

break;

1490

case STATE_OPEN:

1491

do_open (scanner);

1492

break;

1493

case STATE_GET_OPTION:

1494

do_get_option (scanner);

1495

break;

1496

case STATE_START:

1497

do_start (scanner);

1498

break;

1499

case STATE_GET_PARAMETERS:

1500

do_get_parameters (scanner);

1501

break;

1502

case STATE_READ:

1503

do_read (scanner);

1504

break;

1505

}

1506

}

1507

1508

return NULL;

1509

}

1510

1511

1512

Scanner *

1513

scanner_new ()

1514

{

1515

return g_object_new (SCANNER_TYPE, NULL);

1516

}

1517

1518

1519

void

1520

scanner_start (Scanner *scanner)

1521

{

1522

GError *error = NULL;

1523

scanner->priv->thread = g_thread_create ((GThreadFunc) scan_thread, scanner, TRUE, &error);

1524

if (error) {

1525

g_critical ("Unable to create thread: %s", error->message);

1526

g_error_free (error);

1527

}

1528

}

1529

1530

1531

void

1532

scanner_redetect (Scanner *scanner)

1533

{

1534

ScanRequest *request;

1535

1536

if (scanner->priv->redetect)

1537

return;

1538

scanner->priv->redetect = TRUE;

1539

1540

g_debug ("Requesting redetection of scan devices");

1541

1542

request = g_malloc0 (sizeof (ScanRequest));

1543

request->type = REQUEST_REDETECT;

1544

g_async_queue_push (scanner->priv->scan_queue, request);

1545

}

1546

1547

1548

gboolean

1549

scanner_is_scanning (Scanner *scanner)

1550

{

1551

return scanner->priv->scanning;

1552

}

1553

1554

1555

void

1556

scanner_scan (Scanner *scanner, const char *device, ScanOptions *options)

1557

{

1558

ScanRequest *request;

1559

const gchar *type_string;

1560

1561

switch (options->type) {

1562

case SCAN_SINGLE:

1563

type_string = "SCAN_SINGLE";

1564

break;

1565

case SCAN_ADF_FRONT:

1566

type_string = "SCAN_ADF_FRONT";

1567

break;

1568

case SCAN_ADF_BACK:

1569

type_string = "SCAN_ADF_BACK";

1570

break;

1571

case SCAN_ADF_BOTH:

1572

type_string = "SCAN_ADF_BOTH";

1573

break;

1574

default:

1575

g_assert (FALSE);

1576

return;

1577

}

1578

1579

g_debug ("scanner_scan (\"%s\", %d, %s)", device ? device : "(null)", options->dpi, type_string);

1580

request = g_malloc0 (sizeof (ScanRequest));

1581

request->type = REQUEST_START_SCAN;

1582

request->job = g_malloc0 (sizeof (ScanJob));

1583

request->job->device = g_strdup (device);

1584

request->job->dpi = options->dpi;

1585

request->job->scan_mode = options->scan_mode;

1586

request->job->depth = options->depth;

1587

request->job->type = options->type;

1588

request->job->page_width = options->paper_width;

1589

request->job->page_height = options->paper_height;

1590

g_async_queue_push (scanner->priv->scan_queue, request);

1591

}

1592

1593

1594

void

1595

scanner_cancel (Scanner *scanner)

1596

{

1597

ScanRequest *request;

1598

1599

request = g_malloc0 (sizeof (ScanRequest));

1600

request->type = REQUEST_CANCEL;

1601

g_async_queue_push (scanner->priv->scan_queue, request);

1602

}

1603

1604

1605

void scanner_free (Scanner *scanner)

1606

{

1607

ScanRequest *request;

1608

1609

g_debug ("Stopping scan thread");

1610

1611

request = g_malloc0 (sizeof (ScanRequest));

1612

request->type = REQUEST_QUIT;

1613

g_async_queue_push (scanner->priv->scan_queue, request);

1614

1615

if (scanner->priv->thread)

1616

g_thread_join (scanner->priv->thread);

1617

1618

g_async_queue_unref (scanner->priv->scan_queue);

1619

g_object_unref (scanner);

1620

1621

sane_exit ();

1622

g_debug ("sane_exit ()");

1623

}

1624

1625

1626

static void

1627

scanner_class_init (ScannerClass *klass)

1628

{

1629

signals[AUTHORIZE] =

1630

g_signal_new ("authorize",

1631

G_TYPE_FROM_CLASS (klass),

1632

G_SIGNAL_RUN_LAST,

1633

G_STRUCT_OFFSET (ScannerClass, authorize),

1634

NULL, NULL,

1635

g_cclosure_marshal_VOID__STRING,

1636

G_TYPE_NONE, 1, G_TYPE_STRING);

1637

signals[UPDATE_DEVICES] =

1638

g_signal_new ("update-devices",

1639

G_TYPE_FROM_CLASS (klass),

1640

G_SIGNAL_RUN_LAST,

1641

G_STRUCT_OFFSET (ScannerClass, update_devices),

1642

NULL, NULL,

1643

g_cclosure_marshal_VOID__POINTER,

1644

G_TYPE_NONE, 1, G_TYPE_POINTER);

1645

signals[EXPECT_PAGE] =

1646

g_signal_new ("expect-page",

1647

G_TYPE_FROM_CLASS (klass),

1648

G_SIGNAL_RUN_LAST,

1649

G_STRUCT_OFFSET (ScannerClass, expect_page),

1650

NULL, NULL,

1651

g_cclosure_marshal_VOID__VOID,

1652

G_TYPE_NONE, 0);

1653

signals[GOT_PAGE_INFO] =

1654

g_signal_new ("got-page-info",

1655

G_TYPE_FROM_CLASS (klass),

1656

G_SIGNAL_RUN_LAST,

1657

G_STRUCT_OFFSET (ScannerClass, got_page_info),

1658

NULL, NULL,

1659

g_cclosure_marshal_VOID__POINTER,

1660

G_TYPE_NONE, 1, G_TYPE_POINTER);

1661

signals[GOT_LINE] =

1662

g_signal_new ("got-line",

1663

G_TYPE_FROM_CLASS (klass),

1664

G_SIGNAL_RUN_LAST,

1665

G_STRUCT_OFFSET (ScannerClass, got_line),

1666

NULL, NULL,

1667

g_cclosure_marshal_VOID__POINTER,

1668

G_TYPE_NONE, 1, G_TYPE_POINTER);

1669

signals[SCAN_FAILED] =

1670

g_signal_new ("scan-failed",

1671

G_TYPE_FROM_CLASS (klass),

1672

G_SIGNAL_RUN_LAST,

1673

G_STRUCT_OFFSET (ScannerClass, scan_failed),

1674

NULL, NULL,

1675

g_cclosure_marshal_VOID__POINTER,

1676

G_TYPE_NONE, 1, G_TYPE_POINTER);

1677

signals[PAGE_DONE] =

1678

g_signal_new ("page-done",

1679

G_TYPE_FROM_CLASS (klass),

1680

G_SIGNAL_RUN_LAST,

1681

G_STRUCT_OFFSET (ScannerClass, page_done),

1682

NULL, NULL,

1683

g_cclosure_marshal_VOID__VOID,

1684

G_TYPE_NONE, 0);

1685

signals[DOCUMENT_DONE] =

1686

g_signal_new ("document-done",

1687

G_TYPE_FROM_CLASS (klass),

1688

G_SIGNAL_RUN_LAST,

1689

G_STRUCT_OFFSET (ScannerClass, document_done),

1690

NULL, NULL,

1691

g_cclosure_marshal_VOID__VOID,

1692

G_TYPE_NONE, 0);

1693

signals[SCANNING_CHANGED] =

1694

g_signal_new ("scanning-changed",

1695

G_TYPE_FROM_CLASS (klass),

1696

G_SIGNAL_RUN_LAST,

1697

G_STRUCT_OFFSET (ScannerClass, scanning_changed),

1698

NULL, NULL,

1699

g_cclosure_marshal_VOID__VOID,

1700

G_TYPE_NONE, 0);

1701

1702

g_type_class_add_private (klass, sizeof (ScannerPrivate));

1703

1704

scanners = g_hash_table_new (g_direct_hash, g_direct_equal);

1705

}

1706

1707

1708

static void

1709

scanner_init (Scanner *scanner)

1710

{

1711

scanner->priv = G_TYPE_INSTANCE_GET_PRIVATE (scanner, SCANNER_TYPE, ScannerPrivate);

1712

scanner->priv->scan_queue = g_async_queue_new ();

1713

scanner->priv->authorize_queue = g_async_queue_new ();

1714

}

496

struct _Notify {

497

GTypeInstance parent_instance;

498

volatile int ref_count;

499

NotifyPrivate * priv;

500

};

501

502

struct _NotifyClass {

503

GTypeClass parent_class;

504

void (*finalize) (Notify *self);

505

void (*run) (Notify* self, Scanner* scanner);

506

};

507

508

struct _ParamSpecNotify {

509

GParamSpec parent_instance;

510

};

511

512

struct _NotifyScanningChanged {

513

Notify parent_instance;

514

NotifyScanningChangedPrivate * priv;

515

};

516

517

struct _NotifyScanningChangedClass {

518

NotifyClass parent_class;

519

};

520

521

struct _NotifyUpdateDevices {

522

Notify parent_instance;

523

NotifyUpdateDevicesPrivate * priv;

524

};

525

526

struct _NotifyUpdateDevicesClass {

527

NotifyClass parent_class;

528

};

529

530

struct _NotifyUpdateDevicesPrivate {

531

GList* devices;

532

};

533

534

struct _NotifyRequestAuthorization {

535

Notify parent_instance;

536

NotifyRequestAuthorizationPrivate * priv;

537

};

538

539

struct _NotifyRequestAuthorizationClass {

540

NotifyClass parent_class;

541

};

542

543

struct _NotifyRequestAuthorizationPrivate {

544

gchar* resource;

545

};

546

547

struct _NotifyScanFailed {

548

Notify parent_instance;

549

NotifyScanFailedPrivate * priv;

550

};

551

552

struct _NotifyScanFailedClass {

553

NotifyClass parent_class;

554

};

555

556

struct _NotifyScanFailedPrivate {

557

gint error_code;

558

gchar* error_string;

559

};

560

561

struct _NotifyDocumentDone {

562

Notify parent_instance;

563

NotifyDocumentDonePrivate * priv;

564

};

565

566

struct _NotifyDocumentDoneClass {

567

NotifyClass parent_class;

568

};

569

570

struct _NotifyExpectPage {

571

Notify parent_instance;

572

NotifyExpectPagePrivate * priv;

573

};

574

575

struct _NotifyExpectPageClass {

576

NotifyClass parent_class;

577

};

578

579

struct _NotifyGotPageInfo {

580

Notify parent_instance;

581

NotifyGotPageInfoPrivate * priv;

582

};

583

584

struct _NotifyGotPageInfoClass {

585

NotifyClass parent_class;

586

};

587

588

struct _NotifyGotPageInfoPrivate {

589

ScanPageInfo* info;

590

};

591

592

struct _NotifyPageDone {

593

Notify parent_instance;

594

NotifyPageDonePrivate * priv;

595

};

596

597

struct _NotifyPageDoneClass {

598

NotifyClass parent_class;

599

};

600

601

struct _NotifyGotLine {

602

Notify parent_instance;

603

NotifyGotLinePrivate * priv;

604

};

605

606

struct _NotifyGotLineClass {

607

NotifyClass parent_class;

608

};

609

610

struct _NotifyGotLinePrivate {

611

ScanLine* line;

612

};

613

614

struct _Scanner {

615

GTypeInstance parent_instance;

616

volatile int ref_count;

617

ScannerPrivate * priv;

618

};

619

620

struct _ScannerClass {

621

GTypeClass parent_class;

622

void (*finalize) (Scanner *self);

623

};

624

625

struct _ScannerPrivate {

626

GThread* thread;

627

GAsyncQueue* request_queue;

628

GAsyncQueue* notify_queue;

629

GAsyncQueue* authorize_queue;

630

gchar* default_device;

631

ScanState state;

632

gboolean need_redetect;

633

GList* job_queue;

634

SANE_Handle handle;

635

gboolean have_handle;

636

gchar* current_device;

637

SANE_Parameters parameters;

638

SANE_Int option_index;

639

SANE_Int br_x_option_index;

640

SANE_Int br_y_option_index;

641

guchar* buffer;

642

gint buffer_length1;

643

gint _buffer_size_;

644

gint n_used;

645

gint line_count;

646

gint pass_number;

647

gint page_number;

648

gint notified_page;

649

gboolean scanning;

650

};

651

652

struct _ParamSpecScanner {

653

GParamSpec parent_instance;

654

};

655

656

657

static gpointer scan_device_parent_class = NULL;

658

static gpointer scan_page_info_parent_class = NULL;

659

static gpointer scan_line_parent_class = NULL;

660

static gpointer scan_options_parent_class = NULL;

661

static gpointer scan_job_parent_class = NULL;

662

static gpointer request_parent_class = NULL;

663

static gpointer request_redetect_parent_class = NULL;

664

static gpointer request_cancel_parent_class = NULL;

665

static gpointer request_start_scan_parent_class = NULL;

666

static gpointer request_quit_parent_class = NULL;

667

static gpointer credentials_parent_class = NULL;

668

static gpointer notify_parent_class = NULL;

669

static gpointer notify_scanning_changed_parent_class = NULL;

670

static gpointer notify_update_devices_parent_class = NULL;

671

static gpointer notify_request_authorization_parent_class = NULL;

672

static gpointer notify_scan_failed_parent_class = NULL;

673

static gpointer notify_document_done_parent_class = NULL;

674

static gpointer notify_expect_page_parent_class = NULL;

675

static gpointer notify_got_page_info_parent_class = NULL;

676

static gpointer notify_page_done_parent_class = NULL;

677

static gpointer notify_got_line_parent_class = NULL;

678

static gpointer scanner_parent_class = NULL;

679

static Scanner* scanner_scanner_object;

680

static Scanner* scanner_scanner_object = NULL;

681

682

gpointer scan_device_ref (gpointer instance);

683

void scan_device_unref (gpointer instance);

684

GParamSpec* param_spec_scan_device (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

685

void value_set_scan_device (GValue* value, gpointer v_object);

686

void value_take_scan_device (GValue* value, gpointer v_object);

687

gpointer value_get_scan_device (const GValue* value);

688

GType scan_device_get_type (void) G_GNUC_CONST;

689

enum {

690

SCAN_DEVICE_DUMMY_PROPERTY

691

};

692

ScanDevice* scan_device_new (void);

693

ScanDevice* scan_device_construct (GType object_type);

694

static void scan_device_finalize (ScanDevice* obj);

695

gpointer scan_page_info_ref (gpointer instance);

696

void scan_page_info_unref (gpointer instance);

697

GParamSpec* param_spec_scan_page_info (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

698

void value_set_scan_page_info (GValue* value, gpointer v_object);

699

void value_take_scan_page_info (GValue* value, gpointer v_object);

700

gpointer value_get_scan_page_info (const GValue* value);

701

GType scan_page_info_get_type (void) G_GNUC_CONST;

702

enum {

703

SCAN_PAGE_INFO_DUMMY_PROPERTY

704

};

705

ScanPageInfo* scan_page_info_new (void);

706

ScanPageInfo* scan_page_info_construct (GType object_type);

707

static void scan_page_info_finalize (ScanPageInfo* obj);

708

gpointer scan_line_ref (gpointer instance);

709

void scan_line_unref (gpointer instance);

710

GParamSpec* param_spec_scan_line (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

711

void value_set_scan_line (GValue* value, gpointer v_object);

712

void value_take_scan_line (GValue* value, gpointer v_object);

713

gpointer value_get_scan_line (const GValue* value);

714

GType scan_line_get_type (void) G_GNUC_CONST;

715

enum {

716

SCAN_LINE_DUMMY_PROPERTY

717

};

718

ScanLine* scan_line_new (void);

719

ScanLine* scan_line_construct (GType object_type);

720

static void scan_line_finalize (ScanLine* obj);

721

GType scan_mode_get_type (void) G_GNUC_CONST;

722

GType scan_type_get_type (void) G_GNUC_CONST;

723

gpointer scan_options_ref (gpointer instance);

724

void scan_options_unref (gpointer instance);

725

GParamSpec* param_spec_scan_options (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

726

void value_set_scan_options (GValue* value, gpointer v_object);

727

void value_take_scan_options (GValue* value, gpointer v_object);

728

gpointer value_get_scan_options (const GValue* value);

729

GType scan_options_get_type (void) G_GNUC_CONST;

730

enum {

731

SCAN_OPTIONS_DUMMY_PROPERTY

732

};

733

ScanOptions* scan_options_new (void);

734

ScanOptions* scan_options_construct (GType object_type);

735

static void scan_options_finalize (ScanOptions* obj);

736

gpointer scan_job_ref (gpointer instance);

737

void scan_job_unref (gpointer instance);

738

GParamSpec* param_spec_scan_job (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

739

void value_set_scan_job (GValue* value, gpointer v_object);

740

void value_take_scan_job (GValue* value, gpointer v_object);

741

gpointer value_get_scan_job (const GValue* value);

742

GType scan_job_get_type (void) G_GNUC_CONST;

743

enum {

744

SCAN_JOB_DUMMY_PROPERTY

745

};

746

ScanJob* scan_job_new (void);

747

ScanJob* scan_job_construct (GType object_type);

748

static void scan_job_finalize (ScanJob* obj);

749

gpointer request_ref (gpointer instance);

750

void request_unref (gpointer instance);

751

GParamSpec* param_spec_request (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

752

void value_set_request (GValue* value, gpointer v_object);

753

void value_take_request (GValue* value, gpointer v_object);

754

gpointer value_get_request (const GValue* value);

755

GType request_get_type (void) G_GNUC_CONST;

756

enum {

757

REQUEST_DUMMY_PROPERTY

758

};

759

Request* request_new (void);

760

Request* request_construct (GType object_type);

761

static void request_finalize (Request* obj);

762

GType request_redetect_get_type (void) G_GNUC_CONST;

763

enum {

764

REQUEST_REDETECT_DUMMY_PROPERTY

765

};

766

RequestRedetect* request_redetect_new (void);

767

RequestRedetect* request_redetect_construct (GType object_type);

768

GType request_cancel_get_type (void) G_GNUC_CONST;

769

enum {

770

REQUEST_CANCEL_DUMMY_PROPERTY

771

};

772

RequestCancel* request_cancel_new (void);

773

RequestCancel* request_cancel_construct (GType object_type);

774

GType request_start_scan_get_type (void) G_GNUC_CONST;

775

enum {

776

REQUEST_START_SCAN_DUMMY_PROPERTY

777

};

778

RequestStartScan* request_start_scan_new (void);

779

RequestStartScan* request_start_scan_construct (GType object_type);

780

static void request_start_scan_finalize (Request* obj);

781

GType request_quit_get_type (void) G_GNUC_CONST;

782

enum {

783

REQUEST_QUIT_DUMMY_PROPERTY

784

};

785

RequestQuit* request_quit_new (void);

786

RequestQuit* request_quit_construct (GType object_type);

787

gpointer credentials_ref (gpointer instance);

788

void credentials_unref (gpointer instance);

789

GParamSpec* param_spec_credentials (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

790

void value_set_credentials (GValue* value, gpointer v_object);

791

void value_take_credentials (GValue* value, gpointer v_object);

792

gpointer value_get_credentials (const GValue* value);

793

GType credentials_get_type (void) G_GNUC_CONST;

794

enum {

795

CREDENTIALS_DUMMY_PROPERTY

796

};

797

Credentials* credentials_new (void);

798

Credentials* credentials_construct (GType object_type);

799

static void credentials_finalize (Credentials* obj);

800

GType scan_state_get_type (void) G_GNUC_CONST;

801

gpointer notify_ref (gpointer instance);

802

void notify_unref (gpointer instance);

803

GParamSpec* param_spec_notify (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

804

void value_set_notify (GValue* value, gpointer v_object);

805

void value_take_notify (GValue* value, gpointer v_object);

806

gpointer value_get_notify (const GValue* value);

807

GType notify_get_type (void) G_GNUC_CONST;

808

gpointer scanner_ref (gpointer instance);

809

void scanner_unref (gpointer instance);

810

GParamSpec* param_spec_scanner (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);

811

void value_set_scanner (GValue* value, gpointer v_object);

812

void value_take_scanner (GValue* value, gpointer v_object);

813

gpointer value_get_scanner (const GValue* value);

814

GType scanner_get_type (void) G_GNUC_CONST;

815

enum {

816

NOTIFY_DUMMY_PROPERTY

817

};

818

void notify_run (Notify* self, Scanner* scanner);

819

static void notify_real_run (Notify* self, Scanner* scanner);

820

Notify* notify_new (void);

821

Notify* notify_construct (GType object_type);

822

static void notify_finalize (Notify* obj);

823

GType notify_scanning_changed_get_type (void) G_GNUC_CONST;

824

enum {

825

NOTIFY_SCANNING_CHANGED_DUMMY_PROPERTY

826

};

827

static void notify_scanning_changed_real_run (Notify* base, Scanner* scanner);

828

NotifyScanningChanged* notify_scanning_changed_new (void);

829

NotifyScanningChanged* notify_scanning_changed_construct (GType object_type);

830

GType notify_update_devices_get_type (void) G_GNUC_CONST;

831

#define NOTIFY_UPDATE_DEVICES_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_NOTIFY_UPDATE_DEVICES, NotifyUpdateDevicesPrivate))

832

enum {

833

NOTIFY_UPDATE_DEVICES_DUMMY_PROPERTY

834

};

835

static void _scan_device_unref0_ (gpointer var);

836

static void _g_list_free__scan_device_unref0_ (GList* self);

837

NotifyUpdateDevices* notify_update_devices_new (GList* devices);

838

NotifyUpdateDevices* notify_update_devices_construct (GType object_type, GList* devices);

839

static void notify_update_devices_real_run (Notify* base, Scanner* scanner);

840

static void notify_update_devices_finalize (Notify* obj);

841

GType notify_request_authorization_get_type (void) G_GNUC_CONST;

842

#define NOTIFY_REQUEST_AUTHORIZATION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_NOTIFY_REQUEST_AUTHORIZATION, NotifyRequestAuthorizationPrivate))

843

enum {

844

NOTIFY_REQUEST_AUTHORIZATION_DUMMY_PROPERTY

845

};

846

NotifyRequestAuthorization* notify_request_authorization_new (const gchar* resource);

847

NotifyRequestAuthorization* notify_request_authorization_construct (GType object_type, const gchar* resource);

848

static void notify_request_authorization_real_run (Notify* base, Scanner* scanner);

849

static void notify_request_authorization_finalize (Notify* obj);

850

GType notify_scan_failed_get_type (void) G_GNUC_CONST;

851

#define NOTIFY_SCAN_FAILED_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_NOTIFY_SCAN_FAILED, NotifyScanFailedPrivate))

852

enum {

853

NOTIFY_SCAN_FAILED_DUMMY_PROPERTY

854

};

855

NotifyScanFailed* notify_scan_failed_new (gint error_code, const gchar* error_string);

856

NotifyScanFailed* notify_scan_failed_construct (GType object_type, gint error_code, const gchar* error_string);

857

static void notify_scan_failed_real_run (Notify* base, Scanner* scanner);

858

static void notify_scan_failed_finalize (Notify* obj);

859

GType notify_document_done_get_type (void) G_GNUC_CONST;

860

enum {

861

NOTIFY_DOCUMENT_DONE_DUMMY_PROPERTY

862

};

863

static void notify_document_done_real_run (Notify* base, Scanner* scanner);

864

NotifyDocumentDone* notify_document_done_new (void);

865

NotifyDocumentDone* notify_document_done_construct (GType object_type);

866

GType notify_expect_page_get_type (void) G_GNUC_CONST;

867

enum {

868

NOTIFY_EXPECT_PAGE_DUMMY_PROPERTY

869

};

870

static void notify_expect_page_real_run (Notify* base, Scanner* scanner);

871

NotifyExpectPage* notify_expect_page_new (void);

872

NotifyExpectPage* notify_expect_page_construct (GType object_type);

873

GType notify_got_page_info_get_type (void) G_GNUC_CONST;

874

#define NOTIFY_GOT_PAGE_INFO_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_NOTIFY_GOT_PAGE_INFO, NotifyGotPageInfoPrivate))

875

enum {

876

NOTIFY_GOT_PAGE_INFO_DUMMY_PROPERTY

877

};

878

NotifyGotPageInfo* notify_got_page_info_new (ScanPageInfo* info);

879

NotifyGotPageInfo* notify_got_page_info_construct (GType object_type, ScanPageInfo* info);

880

static void notify_got_page_info_real_run (Notify* base, Scanner* scanner);

881

static void notify_got_page_info_finalize (Notify* obj);

882

GType notify_page_done_get_type (void) G_GNUC_CONST;

883

enum {

884

NOTIFY_PAGE_DONE_DUMMY_PROPERTY

885

};

886

static void notify_page_done_real_run (Notify* base, Scanner* scanner);

887

NotifyPageDone* notify_page_done_new (void);

888

NotifyPageDone* notify_page_done_construct (GType object_type);

889

GType notify_got_line_get_type (void) G_GNUC_CONST;

890

#define NOTIFY_GOT_LINE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_NOTIFY_GOT_LINE, NotifyGotLinePrivate))

891

enum {

892

NOTIFY_GOT_LINE_DUMMY_PROPERTY

893

};

894

NotifyGotLine* notify_got_line_new (ScanLine* line);

895

NotifyGotLine* notify_got_line_construct (GType object_type, ScanLine* line);

896

static void notify_got_line_real_run (Notify* base, Scanner* scanner);

897

static void notify_got_line_finalize (Notify* obj);

898

#define SCANNER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TYPE_SCANNER, ScannerPrivate))

899

enum {

900

SCANNER_DUMMY_PROPERTY

901

};

902

static void _scan_job_unref0_ (gpointer var);

903

static void _g_list_free__scan_job_unref0_ (GList* self);

904

static Scanner* scanner_new (void);

905

static Scanner* scanner_construct (GType object_type);

906

Scanner* scanner_get_instance (void);

907

static gboolean scanner_notify_idle_cb (Scanner* self);

908

static void scanner_notify (Scanner* self, Notify* notification);

909

static gboolean _scanner_notify_idle_cb_gsource_func (gpointer self);

910

static void scanner_set_scanning (Scanner* self, gboolean is_scanning);

911

static gint scanner_get_device_weight (const gchar* device);

912

static gint scanner_compare_devices (ScanDevice* device1, ScanDevice* device2);

913

static void scanner_do_redetect (Scanner* self);

914

static gint _scanner_compare_devices_gcompare_func (gconstpointer a, gconstpointer b);

915

static gboolean scanner_set_default_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index);

916

static void scanner_set_bool_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, gboolean value, gboolean* _result_);

917

static void scanner_set_int_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, gint value, gint* _result_);

918

static void scanner_set_fixed_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, gdouble value, gdouble* _result_);

919

static gboolean scanner_set_string_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, const gchar* value, gchar** _result_);

920

static gboolean scanner_set_constrained_string_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, gchar** values, int values_length1, gchar** _result_);

921

static void scanner_log_option (Scanner* self, SANE_Int index, const SANE_Option_Descriptor* option);

922

static void scanner_authorization_cb (const gchar* resource, gchar* username, int username_length1, gchar* password, int password_length1);

923

void scanner_authorize (Scanner* self, const gchar* username, const gchar* password);

924

static void scanner_close_device (Scanner* self);

925

static void scanner_fail_scan (Scanner* self, gint error_code, const gchar* error_string);

926

static gboolean scanner_handle_requests (Scanner* self);

927

static void scanner_do_open (Scanner* self);

928

static void scanner_do_get_option (Scanner* self);

929

static void scanner_do_complete_document (Scanner* self);

930

static void scanner_do_start (Scanner* self);

931

static void scanner_do_get_parameters (Scanner* self);

932

static void scanner_do_complete_page (Scanner* self);

933

static void scanner_do_read (Scanner* self);

934

static gboolean scanner_scan_thread (Scanner* self);

935

static void _scanner_authorization_cb_sane_authcallback (const gchar* resource, gchar* username, gchar* password);

936

void scanner_redetect (Scanner* self);

937

void scanner_start (Scanner* self);

938

static gpointer _scanner_scan_thread_gthread_func (gpointer self);

939

gboolean scanner_is_scanning (Scanner* self);

940

static gchar* scanner_get_scan_mode_string (Scanner* self, ScanMode mode);

941

static gchar* scanner_get_scan_type_string (Scanner* self, ScanType type);

942

void scanner_scan (Scanner* self, const gchar* device, ScanOptions* options);

943

void scanner_cancel (Scanner* self);

944

void scanner_free (Scanner* self);

945

static void g_cclosure_user_marshal_VOID__SCAN_PAGE_INFO (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);

946

static void g_cclosure_user_marshal_VOID__SCAN_LINE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);

947

static void g_cclosure_user_marshal_VOID__INT_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);

948

static void scanner_finalize (Scanner* obj);

949

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);

950

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);

951

952

953

ScanDevice* scan_device_construct (GType object_type) {

954

ScanDevice* self = NULL;

955

self = (ScanDevice*) g_type_create_instance (object_type);

956

return self;

957

}

958

959

960

ScanDevice* scan_device_new (void) {

961

return scan_device_construct (TYPE_SCAN_DEVICE);

962

}

963

964

965

static void value_scan_device_init (GValue* value) {

966

value->data[0].v_pointer = NULL;

967

}

968

969

970

static void value_scan_device_free_value (GValue* value) {

971

if (value->data[0].v_pointer) {

972

scan_device_unref (value->data[0].v_pointer);

973

}

974

}

975

976

977

static void value_scan_device_copy_value (const GValue* src_value, GValue* dest_value) {

978

if (src_value->data[0].v_pointer) {

979

dest_value->data[0].v_pointer = scan_device_ref (src_value->data[0].v_pointer);

980

} else {

981

dest_value->data[0].v_pointer = NULL;

982

}

983

}

984

985

986

static gpointer value_scan_device_peek_pointer (const GValue* value) {

987

return value->data[0].v_pointer;

988

}

989

990

991

static gchar* value_scan_device_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

992

if (collect_values[0].v_pointer) {

993

ScanDevice* object;

994

object = collect_values[0].v_pointer;

995

if (object->parent_instance.g_class == NULL) {

996

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

997

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

998

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

999

}

1000

value->data[0].v_pointer = scan_device_ref (object);

1001

} else {

1002

value->data[0].v_pointer = NULL;

1003

}

1004

return NULL;

1005

}

1006

1007

1008

static gchar* value_scan_device_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1009

ScanDevice** object_p;

1010

object_p = collect_values[0].v_pointer;

1011

if (!object_p) {

1012

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

1013

}

1014

if (!value->data[0].v_pointer) {

1015

*object_p = NULL;

1016

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

1017

*object_p = value->data[0].v_pointer;

1018

} else {

1019

*object_p = scan_device_ref (value->data[0].v_pointer);

1020

}

1021

return NULL;

1022

}

1023

1024

1025

GParamSpec* param_spec_scan_device (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

1026

ParamSpecScanDevice* spec;

1027

g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCAN_DEVICE), NULL);

1028

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

1029

G_PARAM_SPEC (spec)->value_type = object_type;

1030

return G_PARAM_SPEC (spec);

1031

}

1032

1033

1034

gpointer value_get_scan_device (const GValue* value) {

1035

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_DEVICE), NULL);

1036

return value->data[0].v_pointer;

1037

}

1038

1039

1040

void value_set_scan_device (GValue* value, gpointer v_object) {

1041

ScanDevice* old;

1042

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_DEVICE));

1043

old = value->data[0].v_pointer;

1044

if (v_object) {

1045

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_DEVICE));

1046

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1047

value->data[0].v_pointer = v_object;

1048

scan_device_ref (value->data[0].v_pointer);

1049

} else {

1050

value->data[0].v_pointer = NULL;

1051

}

1052

if (old) {

1053

scan_device_unref (old);

1054

}

1055

}

1056

1057

1058

void value_take_scan_device (GValue* value, gpointer v_object) {

1059

ScanDevice* old;

1060

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_DEVICE));

1061

old = value->data[0].v_pointer;

1062

if (v_object) {

1063

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_DEVICE));

1064

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1065

value->data[0].v_pointer = v_object;

1066

} else {

1067

value->data[0].v_pointer = NULL;

1068

}

1069

if (old) {

1070

scan_device_unref (old);

1071

}

1072

}

1073

1074

1075

static void scan_device_class_init (ScanDeviceClass * klass) {

1076

scan_device_parent_class = g_type_class_peek_parent (klass);

1077

SCAN_DEVICE_CLASS (klass)->finalize = scan_device_finalize;

1078

}

1079

1080

1081

static void scan_device_instance_init (ScanDevice * self) {

1082

self->ref_count = 1;

1083

}

1084

1085

1086

static void scan_device_finalize (ScanDevice* obj) {

1087

ScanDevice * self;

1088

self = SCAN_DEVICE (obj);

1089

_g_free0 (self->name);

1090

_g_free0 (self->label);

1091

}

1092

1093

1094

GType scan_device_get_type (void) {

1095

static volatile gsize scan_device_type_id__volatile = 0;

1096

if (g_once_init_enter (&scan_device_type_id__volatile)) {

1097

static const GTypeValueTable g_define_type_value_table = { value_scan_device_init, value_scan_device_free_value, value_scan_device_copy_value, value_scan_device_peek_pointer, "p", value_scan_device_collect_value, "p", value_scan_device_lcopy_value };

1098

static const GTypeInfo g_define_type_info = { sizeof (ScanDeviceClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) scan_device_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ScanDevice), 0, (GInstanceInitFunc) scan_device_instance_init, &g_define_type_value_table };

1099

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

1100

GType scan_device_type_id;

1101

scan_device_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ScanDevice", &g_define_type_info, &g_define_type_fundamental_info, 0);

1102

g_once_init_leave (&scan_device_type_id__volatile, scan_device_type_id);

1103

}

1104

return scan_device_type_id__volatile;

1105

}

1106

1107

1108

gpointer scan_device_ref (gpointer instance) {

1109

ScanDevice* self;

1110

self = instance;

1111

g_atomic_int_inc (&self->ref_count);

1112

return instance;

1113

}

1114

1115

1116

void scan_device_unref (gpointer instance) {

1117

ScanDevice* self;

1118

self = instance;

1119

if (g_atomic_int_dec_and_test (&self->ref_count)) {

1120

SCAN_DEVICE_GET_CLASS (self)->finalize (self);

1121

g_type_free_instance ((GTypeInstance *) self);

1122

}

1123

}

1124

1125

1126

ScanPageInfo* scan_page_info_construct (GType object_type) {

1127

ScanPageInfo* self = NULL;

1128

self = (ScanPageInfo*) g_type_create_instance (object_type);

1129

return self;

1130

}

1131

1132

1133

ScanPageInfo* scan_page_info_new (void) {

1134

return scan_page_info_construct (TYPE_SCAN_PAGE_INFO);

1135

}

1136

1137

1138

static void value_scan_page_info_init (GValue* value) {

1139

value->data[0].v_pointer = NULL;

1140

}

1141

1142

1143

static void value_scan_page_info_free_value (GValue* value) {

1144

if (value->data[0].v_pointer) {

1145

scan_page_info_unref (value->data[0].v_pointer);

1146

}

1147

}

1148

1149

1150

static void value_scan_page_info_copy_value (const GValue* src_value, GValue* dest_value) {

1151

if (src_value->data[0].v_pointer) {

1152

dest_value->data[0].v_pointer = scan_page_info_ref (src_value->data[0].v_pointer);

1153

} else {

1154

dest_value->data[0].v_pointer = NULL;

1155

}

1156

}

1157

1158

1159

static gpointer value_scan_page_info_peek_pointer (const GValue* value) {

1160

return value->data[0].v_pointer;

1161

}

1162

1163

1164

static gchar* value_scan_page_info_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1165

if (collect_values[0].v_pointer) {

1166

ScanPageInfo* object;

1167

object = collect_values[0].v_pointer;

1168

if (object->parent_instance.g_class == NULL) {

1169

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1170

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

1171

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1172

}

1173

value->data[0].v_pointer = scan_page_info_ref (object);

1174

} else {

1175

value->data[0].v_pointer = NULL;

1176

}

1177

return NULL;

1178

}

1179

1180

1181

static gchar* value_scan_page_info_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1182

ScanPageInfo** object_p;

1183

object_p = collect_values[0].v_pointer;

1184

if (!object_p) {

1185

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

1186

}

1187

if (!value->data[0].v_pointer) {

1188

*object_p = NULL;

1189

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

1190

*object_p = value->data[0].v_pointer;

1191

} else {

1192

*object_p = scan_page_info_ref (value->data[0].v_pointer);

1193

}

1194

return NULL;

1195

}

1196

1197

1198

GParamSpec* param_spec_scan_page_info (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

1199

ParamSpecScanPageInfo* spec;

1200

g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCAN_PAGE_INFO), NULL);

1201

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

1202

G_PARAM_SPEC (spec)->value_type = object_type;

1203

return G_PARAM_SPEC (spec);

1204

}

1205

1206

1207

gpointer value_get_scan_page_info (const GValue* value) {

1208

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_PAGE_INFO), NULL);

1209

return value->data[0].v_pointer;

1210

}

1211

1212

1213

void value_set_scan_page_info (GValue* value, gpointer v_object) {

1214

ScanPageInfo* old;

1215

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_PAGE_INFO));

1216

old = value->data[0].v_pointer;

1217

if (v_object) {

1218

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_PAGE_INFO));

1219

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1220

value->data[0].v_pointer = v_object;

1221

scan_page_info_ref (value->data[0].v_pointer);

1222

} else {

1223

value->data[0].v_pointer = NULL;

1224

}

1225

if (old) {

1226

scan_page_info_unref (old);

1227

}

1228

}

1229

1230

1231

void value_take_scan_page_info (GValue* value, gpointer v_object) {

1232

ScanPageInfo* old;

1233

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_PAGE_INFO));

1234

old = value->data[0].v_pointer;

1235

if (v_object) {

1236

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_PAGE_INFO));

1237

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1238

value->data[0].v_pointer = v_object;

1239

} else {

1240

value->data[0].v_pointer = NULL;

1241

}

1242

if (old) {

1243

scan_page_info_unref (old);

1244

}

1245

}

1246

1247

1248

static void scan_page_info_class_init (ScanPageInfoClass * klass) {

1249

scan_page_info_parent_class = g_type_class_peek_parent (klass);

1250

SCAN_PAGE_INFO_CLASS (klass)->finalize = scan_page_info_finalize;

1251

}

1252

1253

1254

static void scan_page_info_instance_init (ScanPageInfo * self) {

1255

self->ref_count = 1;

1256

}

1257

1258

1259

static void scan_page_info_finalize (ScanPageInfo* obj) {

1260

ScanPageInfo * self;

1261

self = SCAN_PAGE_INFO (obj);

1262

_g_free0 (self->device);

1263

}

1264

1265

1266

GType scan_page_info_get_type (void) {

1267

static volatile gsize scan_page_info_type_id__volatile = 0;

1268

if (g_once_init_enter (&scan_page_info_type_id__volatile)) {

1269

static const GTypeValueTable g_define_type_value_table = { value_scan_page_info_init, value_scan_page_info_free_value, value_scan_page_info_copy_value, value_scan_page_info_peek_pointer, "p", value_scan_page_info_collect_value, "p", value_scan_page_info_lcopy_value };

1270

static const GTypeInfo g_define_type_info = { sizeof (ScanPageInfoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) scan_page_info_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ScanPageInfo), 0, (GInstanceInitFunc) scan_page_info_instance_init, &g_define_type_value_table };

1271

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

1272

GType scan_page_info_type_id;

1273

scan_page_info_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ScanPageInfo", &g_define_type_info, &g_define_type_fundamental_info, 0);

1274

g_once_init_leave (&scan_page_info_type_id__volatile, scan_page_info_type_id);

1275

}

1276

return scan_page_info_type_id__volatile;

1277

}

1278

1279

1280

gpointer scan_page_info_ref (gpointer instance) {

1281

ScanPageInfo* self;

1282

self = instance;

1283

g_atomic_int_inc (&self->ref_count);

1284

return instance;

1285

}

1286

1287

1288

void scan_page_info_unref (gpointer instance) {

1289

ScanPageInfo* self;

1290

self = instance;

1291

if (g_atomic_int_dec_and_test (&self->ref_count)) {

1292

SCAN_PAGE_INFO_GET_CLASS (self)->finalize (self);

1293

g_type_free_instance ((GTypeInstance *) self);

1294

}

1295

}

1296

1297

1298

ScanLine* scan_line_construct (GType object_type) {

1299

ScanLine* self = NULL;

1300

self = (ScanLine*) g_type_create_instance (object_type);

1301

return self;

1302

}

1303

1304

1305

ScanLine* scan_line_new (void) {

1306

return scan_line_construct (TYPE_SCAN_LINE);

1307

}

1308

1309

1310

static void value_scan_line_init (GValue* value) {

1311

value->data[0].v_pointer = NULL;

1312

}

1313

1314

1315

static void value_scan_line_free_value (GValue* value) {

1316

if (value->data[0].v_pointer) {

1317

scan_line_unref (value->data[0].v_pointer);

1318

}

1319

}

1320

1321

1322

static void value_scan_line_copy_value (const GValue* src_value, GValue* dest_value) {

1323

if (src_value->data[0].v_pointer) {

1324

dest_value->data[0].v_pointer = scan_line_ref (src_value->data[0].v_pointer);

1325

} else {

1326

dest_value->data[0].v_pointer = NULL;

1327

}

1328

}

1329

1330

1331

static gpointer value_scan_line_peek_pointer (const GValue* value) {

1332

return value->data[0].v_pointer;

1333

}

1334

1335

1336

static gchar* value_scan_line_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1337

if (collect_values[0].v_pointer) {

1338

ScanLine* object;

1339

object = collect_values[0].v_pointer;

1340

if (object->parent_instance.g_class == NULL) {

1341

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1342

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

1343

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1344

}

1345

value->data[0].v_pointer = scan_line_ref (object);

1346

} else {

1347

value->data[0].v_pointer = NULL;

1348

}

1349

return NULL;

1350

}

1351

1352

1353

static gchar* value_scan_line_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1354

ScanLine** object_p;

1355

object_p = collect_values[0].v_pointer;

1356

if (!object_p) {

1357

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

1358

}

1359

if (!value->data[0].v_pointer) {

1360

*object_p = NULL;

1361

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

1362

*object_p = value->data[0].v_pointer;

1363

} else {

1364

*object_p = scan_line_ref (value->data[0].v_pointer);

1365

}

1366

return NULL;

1367

}

1368

1369

1370

GParamSpec* param_spec_scan_line (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

1371

ParamSpecScanLine* spec;

1372

g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCAN_LINE), NULL);

1373

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

1374

G_PARAM_SPEC (spec)->value_type = object_type;

1375

return G_PARAM_SPEC (spec);

1376

}

1377

1378

1379

gpointer value_get_scan_line (const GValue* value) {

1380

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_LINE), NULL);

1381

return value->data[0].v_pointer;

1382

}

1383

1384

1385

void value_set_scan_line (GValue* value, gpointer v_object) {

1386

ScanLine* old;

1387

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_LINE));

1388

old = value->data[0].v_pointer;

1389

if (v_object) {

1390

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_LINE));

1391

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1392

value->data[0].v_pointer = v_object;

1393

scan_line_ref (value->data[0].v_pointer);

1394

} else {

1395

value->data[0].v_pointer = NULL;

1396

}

1397

if (old) {

1398

scan_line_unref (old);

1399

}

1400

}

1401

1402

1403

void value_take_scan_line (GValue* value, gpointer v_object) {

1404

ScanLine* old;

1405

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_LINE));

1406

old = value->data[0].v_pointer;

1407

if (v_object) {

1408

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_LINE));

1409

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1410

value->data[0].v_pointer = v_object;

1411

} else {

1412

value->data[0].v_pointer = NULL;

1413

}

1414

if (old) {

1415

scan_line_unref (old);

1416

}

1417

}

1418

1419

1420

static void scan_line_class_init (ScanLineClass * klass) {

1421

scan_line_parent_class = g_type_class_peek_parent (klass);

1422

SCAN_LINE_CLASS (klass)->finalize = scan_line_finalize;

1423

}

1424

1425

1426

static void scan_line_instance_init (ScanLine * self) {

1427

self->ref_count = 1;

1428

}

1429

1430

1431

static void scan_line_finalize (ScanLine* obj) {

1432

ScanLine * self;

1433

self = SCAN_LINE (obj);

1434

self->data = (g_free (self->data), NULL);

1435

}

1436

1437

1438

GType scan_line_get_type (void) {

1439

static volatile gsize scan_line_type_id__volatile = 0;

1440

if (g_once_init_enter (&scan_line_type_id__volatile)) {

1441

static const GTypeValueTable g_define_type_value_table = { value_scan_line_init, value_scan_line_free_value, value_scan_line_copy_value, value_scan_line_peek_pointer, "p", value_scan_line_collect_value, "p", value_scan_line_lcopy_value };

1442

static const GTypeInfo g_define_type_info = { sizeof (ScanLineClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) scan_line_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ScanLine), 0, (GInstanceInitFunc) scan_line_instance_init, &g_define_type_value_table };

1443

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

1444

GType scan_line_type_id;

1445

scan_line_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ScanLine", &g_define_type_info, &g_define_type_fundamental_info, 0);

1446

g_once_init_leave (&scan_line_type_id__volatile, scan_line_type_id);

1447

}

1448

return scan_line_type_id__volatile;

1449

}

1450

1451

1452

gpointer scan_line_ref (gpointer instance) {

1453

ScanLine* self;

1454

self = instance;

1455

g_atomic_int_inc (&self->ref_count);

1456

return instance;

1457

}

1458

1459

1460

void scan_line_unref (gpointer instance) {

1461

ScanLine* self;

1462

self = instance;

1463

if (g_atomic_int_dec_and_test (&self->ref_count)) {

1464

SCAN_LINE_GET_CLASS (self)->finalize (self);

1465

g_type_free_instance ((GTypeInstance *) self);

1466

}

1467

}

1468

1469

1470

GType scan_mode_get_type (void) {

1471

static volatile gsize scan_mode_type_id__volatile = 0;

1472

if (g_once_init_enter (&scan_mode_type_id__volatile)) {

1473

static const GEnumValue values[] = {{SCAN_MODE_DEFAULT, "SCAN_MODE_DEFAULT", "default"}, {SCAN_MODE_COLOR, "SCAN_MODE_COLOR", "color"}, {SCAN_MODE_GRAY, "SCAN_MODE_GRAY", "gray"}, {SCAN_MODE_LINEART, "SCAN_MODE_LINEART", "lineart"}, {0, NULL, NULL}};

1474

GType scan_mode_type_id;

1475

scan_mode_type_id = g_enum_register_static ("ScanMode", values);

1476

g_once_init_leave (&scan_mode_type_id__volatile, scan_mode_type_id);

1477

}

1478

return scan_mode_type_id__volatile;

1479

}

1480

1481

1482

GType scan_type_get_type (void) {

1483

static volatile gsize scan_type_type_id__volatile = 0;

1484

if (g_once_init_enter (&scan_type_type_id__volatile)) {

1485

static const GEnumValue values[] = {{SCAN_TYPE_SINGLE, "SCAN_TYPE_SINGLE", "single"}, {SCAN_TYPE_ADF_FRONT, "SCAN_TYPE_ADF_FRONT", "adf-front"}, {SCAN_TYPE_ADF_BACK, "SCAN_TYPE_ADF_BACK", "adf-back"}, {SCAN_TYPE_ADF_BOTH, "SCAN_TYPE_ADF_BOTH", "adf-both"}, {0, NULL, NULL}};

1486

GType scan_type_type_id;

1487

scan_type_type_id = g_enum_register_static ("ScanType", values);

1488

g_once_init_leave (&scan_type_type_id__volatile, scan_type_type_id);

1489

}

1490

return scan_type_type_id__volatile;

1491

}

1492

1493

1494

ScanOptions* scan_options_construct (GType object_type) {

1495

ScanOptions* self = NULL;

1496

self = (ScanOptions*) g_type_create_instance (object_type);

1497

return self;

1498

}

1499

1500

1501

ScanOptions* scan_options_new (void) {

1502

return scan_options_construct (TYPE_SCAN_OPTIONS);

1503

}

1504

1505

1506

static void value_scan_options_init (GValue* value) {

1507

value->data[0].v_pointer = NULL;

1508

}

1509

1510

1511

static void value_scan_options_free_value (GValue* value) {

1512

if (value->data[0].v_pointer) {

1513

scan_options_unref (value->data[0].v_pointer);

1514

}

1515

}

1516

1517

1518

static void value_scan_options_copy_value (const GValue* src_value, GValue* dest_value) {

1519

if (src_value->data[0].v_pointer) {

1520

dest_value->data[0].v_pointer = scan_options_ref (src_value->data[0].v_pointer);

1521

} else {

1522

dest_value->data[0].v_pointer = NULL;

1523

}

1524

}

1525

1526

1527

static gpointer value_scan_options_peek_pointer (const GValue* value) {

1528

return value->data[0].v_pointer;

1529

}

1530

1531

1532

static gchar* value_scan_options_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1533

if (collect_values[0].v_pointer) {

1534

ScanOptions* object;

1535

object = collect_values[0].v_pointer;

1536

if (object->parent_instance.g_class == NULL) {

1537

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1538

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

1539

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1540

}

1541

value->data[0].v_pointer = scan_options_ref (object);

1542

} else {

1543

value->data[0].v_pointer = NULL;

1544

}

1545

return NULL;

1546

}

1547

1548

1549

static gchar* value_scan_options_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1550

ScanOptions** object_p;

1551

object_p = collect_values[0].v_pointer;

1552

if (!object_p) {

1553

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

1554

}

1555

if (!value->data[0].v_pointer) {

1556

*object_p = NULL;

1557

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

1558

*object_p = value->data[0].v_pointer;

1559

} else {

1560

*object_p = scan_options_ref (value->data[0].v_pointer);

1561

}

1562

return NULL;

1563

}

1564

1565

1566

GParamSpec* param_spec_scan_options (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

1567

ParamSpecScanOptions* spec;

1568

g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCAN_OPTIONS), NULL);

1569

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

1570

G_PARAM_SPEC (spec)->value_type = object_type;

1571

return G_PARAM_SPEC (spec);

1572

}

1573

1574

1575

gpointer value_get_scan_options (const GValue* value) {

1576

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_OPTIONS), NULL);

1577

return value->data[0].v_pointer;

1578

}

1579

1580

1581

void value_set_scan_options (GValue* value, gpointer v_object) {

1582

ScanOptions* old;

1583

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_OPTIONS));

1584

old = value->data[0].v_pointer;

1585

if (v_object) {

1586

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_OPTIONS));

1587

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1588

value->data[0].v_pointer = v_object;

1589

scan_options_ref (value->data[0].v_pointer);

1590

} else {

1591

value->data[0].v_pointer = NULL;

1592

}

1593

if (old) {

1594

scan_options_unref (old);

1595

}

1596

}

1597

1598

1599

void value_take_scan_options (GValue* value, gpointer v_object) {

1600

ScanOptions* old;

1601

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_OPTIONS));

1602

old = value->data[0].v_pointer;

1603

if (v_object) {

1604

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_OPTIONS));

1605

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1606

value->data[0].v_pointer = v_object;

1607

} else {

1608

value->data[0].v_pointer = NULL;

1609

}

1610

if (old) {

1611

scan_options_unref (old);

1612

}

1613

}

1614

1615

1616

static void scan_options_class_init (ScanOptionsClass * klass) {

1617

scan_options_parent_class = g_type_class_peek_parent (klass);

1618

SCAN_OPTIONS_CLASS (klass)->finalize = scan_options_finalize;

1619

}

1620

1621

1622

static void scan_options_instance_init (ScanOptions * self) {

1623

self->ref_count = 1;

1624

}

1625

1626

1627

static void scan_options_finalize (ScanOptions* obj) {

1628

ScanOptions * self;

1629

self = SCAN_OPTIONS (obj);

1630

}

1631

1632

1633

GType scan_options_get_type (void) {

1634

static volatile gsize scan_options_type_id__volatile = 0;

1635

if (g_once_init_enter (&scan_options_type_id__volatile)) {

1636

static const GTypeValueTable g_define_type_value_table = { value_scan_options_init, value_scan_options_free_value, value_scan_options_copy_value, value_scan_options_peek_pointer, "p", value_scan_options_collect_value, "p", value_scan_options_lcopy_value };

1637

static const GTypeInfo g_define_type_info = { sizeof (ScanOptionsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) scan_options_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ScanOptions), 0, (GInstanceInitFunc) scan_options_instance_init, &g_define_type_value_table };

1638

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

1639

GType scan_options_type_id;

1640

scan_options_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ScanOptions", &g_define_type_info, &g_define_type_fundamental_info, 0);

1641

g_once_init_leave (&scan_options_type_id__volatile, scan_options_type_id);

1642

}

1643

return scan_options_type_id__volatile;

1644

}

1645

1646

1647

gpointer scan_options_ref (gpointer instance) {

1648

ScanOptions* self;

1649

self = instance;

1650

g_atomic_int_inc (&self->ref_count);

1651

return instance;

1652

}

1653

1654

1655

void scan_options_unref (gpointer instance) {

1656

ScanOptions* self;

1657

self = instance;

1658

if (g_atomic_int_dec_and_test (&self->ref_count)) {

1659

SCAN_OPTIONS_GET_CLASS (self)->finalize (self);

1660

g_type_free_instance ((GTypeInstance *) self);

1661

}

1662

}

1663

1664

1665

ScanJob* scan_job_construct (GType object_type) {

1666

ScanJob* self = NULL;

1667

self = (ScanJob*) g_type_create_instance (object_type);

1668

return self;

1669

}

1670

1671

1672

ScanJob* scan_job_new (void) {

1673

return scan_job_construct (TYPE_SCAN_JOB);

1674

}

1675

1676

1677

static void value_scan_job_init (GValue* value) {

1678

value->data[0].v_pointer = NULL;

1679

}

1680

1681

1682

static void value_scan_job_free_value (GValue* value) {

1683

if (value->data[0].v_pointer) {

1684

scan_job_unref (value->data[0].v_pointer);

1685

}

1686

}

1687

1688

1689

static void value_scan_job_copy_value (const GValue* src_value, GValue* dest_value) {

1690

if (src_value->data[0].v_pointer) {

1691

dest_value->data[0].v_pointer = scan_job_ref (src_value->data[0].v_pointer);

1692

} else {

1693

dest_value->data[0].v_pointer = NULL;

1694

}

1695

}

1696

1697

1698

static gpointer value_scan_job_peek_pointer (const GValue* value) {

1699

return value->data[0].v_pointer;

1700

}

1701

1702

1703

static gchar* value_scan_job_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1704

if (collect_values[0].v_pointer) {

1705

ScanJob* object;

1706

object = collect_values[0].v_pointer;

1707

if (object->parent_instance.g_class == NULL) {

1708

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1709

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

1710

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1711

}

1712

value->data[0].v_pointer = scan_job_ref (object);

1713

} else {

1714

value->data[0].v_pointer = NULL;

1715

}

1716

return NULL;

1717

}

1718

1719

1720

static gchar* value_scan_job_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1721

ScanJob** object_p;

1722

object_p = collect_values[0].v_pointer;

1723

if (!object_p) {

1724

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

1725

}

1726

if (!value->data[0].v_pointer) {

1727

*object_p = NULL;

1728

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

1729

*object_p = value->data[0].v_pointer;

1730

} else {

1731

*object_p = scan_job_ref (value->data[0].v_pointer);

1732

}

1733

return NULL;

1734

}

1735

1736

1737

GParamSpec* param_spec_scan_job (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

1738

ParamSpecScanJob* spec;

1739

g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCAN_JOB), NULL);

1740

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

1741

G_PARAM_SPEC (spec)->value_type = object_type;

1742

return G_PARAM_SPEC (spec);

1743

}

1744

1745

1746

gpointer value_get_scan_job (const GValue* value) {

1747

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_JOB), NULL);

1748

return value->data[0].v_pointer;

1749

}

1750

1751

1752

void value_set_scan_job (GValue* value, gpointer v_object) {

1753

ScanJob* old;

1754

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_JOB));

1755

old = value->data[0].v_pointer;

1756

if (v_object) {

1757

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_JOB));

1758

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1759

value->data[0].v_pointer = v_object;

1760

scan_job_ref (value->data[0].v_pointer);

1761

} else {

1762

value->data[0].v_pointer = NULL;

1763

}

1764

if (old) {

1765

scan_job_unref (old);

1766

}

1767

}

1768

1769

1770

void value_take_scan_job (GValue* value, gpointer v_object) {

1771

ScanJob* old;

1772

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCAN_JOB));

1773

old = value->data[0].v_pointer;

1774

if (v_object) {

1775

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCAN_JOB));

1776

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1777

value->data[0].v_pointer = v_object;

1778

} else {

1779

value->data[0].v_pointer = NULL;

1780

}

1781

if (old) {

1782

scan_job_unref (old);

1783

}

1784

}

1785

1786

1787

static void scan_job_class_init (ScanJobClass * klass) {

1788

scan_job_parent_class = g_type_class_peek_parent (klass);

1789

SCAN_JOB_CLASS (klass)->finalize = scan_job_finalize;

1790

}

1791

1792

1793

static void scan_job_instance_init (ScanJob * self) {

1794

self->ref_count = 1;

1795

}

1796

1797

1798

static void scan_job_finalize (ScanJob* obj) {

1799

ScanJob * self;

1800

self = SCAN_JOB (obj);

1801

_g_free0 (self->device);

1802

}

1803

1804

1805

GType scan_job_get_type (void) {

1806

static volatile gsize scan_job_type_id__volatile = 0;

1807

if (g_once_init_enter (&scan_job_type_id__volatile)) {

1808

static const GTypeValueTable g_define_type_value_table = { value_scan_job_init, value_scan_job_free_value, value_scan_job_copy_value, value_scan_job_peek_pointer, "p", value_scan_job_collect_value, "p", value_scan_job_lcopy_value };

1809

static const GTypeInfo g_define_type_info = { sizeof (ScanJobClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) scan_job_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ScanJob), 0, (GInstanceInitFunc) scan_job_instance_init, &g_define_type_value_table };

1810

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

1811

GType scan_job_type_id;

1812

scan_job_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ScanJob", &g_define_type_info, &g_define_type_fundamental_info, 0);

1813

g_once_init_leave (&scan_job_type_id__volatile, scan_job_type_id);

1814

}

1815

return scan_job_type_id__volatile;

1816

}

1817

1818

1819

gpointer scan_job_ref (gpointer instance) {

1820

ScanJob* self;

1821

self = instance;

1822

g_atomic_int_inc (&self->ref_count);

1823

return instance;

1824

}

1825

1826

1827

void scan_job_unref (gpointer instance) {

1828

ScanJob* self;

1829

self = instance;

1830

if (g_atomic_int_dec_and_test (&self->ref_count)) {

1831

SCAN_JOB_GET_CLASS (self)->finalize (self);

1832

g_type_free_instance ((GTypeInstance *) self);

1833

}

1834

}

1835

1836

1837

Request* request_construct (GType object_type) {

1838

Request* self = NULL;

1839

self = (Request*) g_type_create_instance (object_type);

1840

return self;

1841

}

1842

1843

1844

Request* request_new (void) {

1845

return request_construct (TYPE_REQUEST);

1846

}

1847

1848

1849

static void value_request_init (GValue* value) {

1850

value->data[0].v_pointer = NULL;

1851

}

1852

1853

1854

static void value_request_free_value (GValue* value) {

1855

if (value->data[0].v_pointer) {

1856

request_unref (value->data[0].v_pointer);

1857

}

1858

}

1859

1860

1861

static void value_request_copy_value (const GValue* src_value, GValue* dest_value) {

1862

if (src_value->data[0].v_pointer) {

1863

dest_value->data[0].v_pointer = request_ref (src_value->data[0].v_pointer);

1864

} else {

1865

dest_value->data[0].v_pointer = NULL;

1866

}

1867

}

1868

1869

1870

static gpointer value_request_peek_pointer (const GValue* value) {

1871

return value->data[0].v_pointer;

1872

}

1873

1874

1875

static gchar* value_request_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1876

if (collect_values[0].v_pointer) {

1877

Request* object;

1878

object = collect_values[0].v_pointer;

1879

if (object->parent_instance.g_class == NULL) {

1880

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1881

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

1882

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

1883

}

1884

value->data[0].v_pointer = request_ref (object);

1885

} else {

1886

value->data[0].v_pointer = NULL;

1887

}

1888

return NULL;

1889

}

1890

1891

1892

static gchar* value_request_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

1893

Request** object_p;

1894

object_p = collect_values[0].v_pointer;

1895

if (!object_p) {

1896

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

1897

}

1898

if (!value->data[0].v_pointer) {

1899

*object_p = NULL;

1900

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

1901

*object_p = value->data[0].v_pointer;

1902

} else {

1903

*object_p = request_ref (value->data[0].v_pointer);

1904

}

1905

return NULL;

1906

}

1907

1908

1909

GParamSpec* param_spec_request (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

1910

ParamSpecRequest* spec;

1911

g_return_val_if_fail (g_type_is_a (object_type, TYPE_REQUEST), NULL);

1912

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

1913

G_PARAM_SPEC (spec)->value_type = object_type;

1914

return G_PARAM_SPEC (spec);

1915

}

1916

1917

1918

gpointer value_get_request (const GValue* value) {

1919

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_REQUEST), NULL);

1920

return value->data[0].v_pointer;

1921

}

1922

1923

1924

void value_set_request (GValue* value, gpointer v_object) {

1925

Request* old;

1926

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_REQUEST));

1927

old = value->data[0].v_pointer;

1928

if (v_object) {

1929

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_REQUEST));

1930

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1931

value->data[0].v_pointer = v_object;

1932

request_ref (value->data[0].v_pointer);

1933

} else {

1934

value->data[0].v_pointer = NULL;

1935

}

1936

if (old) {

1937

request_unref (old);

1938

}

1939

}

1940

1941

1942

void value_take_request (GValue* value, gpointer v_object) {

1943

Request* old;

1944

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_REQUEST));

1945

old = value->data[0].v_pointer;

1946

if (v_object) {

1947

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_REQUEST));

1948

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

1949

value->data[0].v_pointer = v_object;

1950

} else {

1951

value->data[0].v_pointer = NULL;

1952

}

1953

if (old) {

1954

request_unref (old);

1955

}

1956

}

1957

1958

1959

static void request_class_init (RequestClass * klass) {

1960

request_parent_class = g_type_class_peek_parent (klass);

1961

REQUEST_CLASS (klass)->finalize = request_finalize;

1962

}

1963

1964

1965

static void request_instance_init (Request * self) {

1966

self->ref_count = 1;

1967

}

1968

1969

1970

static void request_finalize (Request* obj) {

1971

Request * self;

1972

self = REQUEST (obj);

1973

}

1974

1975

1976

GType request_get_type (void) {

1977

static volatile gsize request_type_id__volatile = 0;

1978

if (g_once_init_enter (&request_type_id__volatile)) {

1979

static const GTypeValueTable g_define_type_value_table = { value_request_init, value_request_free_value, value_request_copy_value, value_request_peek_pointer, "p", value_request_collect_value, "p", value_request_lcopy_value };

1980

static const GTypeInfo g_define_type_info = { sizeof (RequestClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) request_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Request), 0, (GInstanceInitFunc) request_instance_init, &g_define_type_value_table };

1981

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

1982

GType request_type_id;

1983

request_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Request", &g_define_type_info, &g_define_type_fundamental_info, 0);

1984

g_once_init_leave (&request_type_id__volatile, request_type_id);

1985

}

1986

return request_type_id__volatile;

1987

}

1988

1989

1990

gpointer request_ref (gpointer instance) {

1991

Request* self;

1992

self = instance;

1993

g_atomic_int_inc (&self->ref_count);

1994

return instance;

1995

}

1996

1997

1998

void request_unref (gpointer instance) {

1999

Request* self;

2000

self = instance;

2001

if (g_atomic_int_dec_and_test (&self->ref_count)) {

2002

REQUEST_GET_CLASS (self)->finalize (self);

2003

g_type_free_instance ((GTypeInstance *) self);

2004

}

2005

}

2006

2007

2008

RequestRedetect* request_redetect_construct (GType object_type) {

2009

RequestRedetect* self = NULL;

2010

self = (RequestRedetect*) request_construct (object_type);

2011

return self;

2012

}

2013

2014

2015

RequestRedetect* request_redetect_new (void) {

2016

return request_redetect_construct (TYPE_REQUEST_REDETECT);

2017

}

2018

2019

2020

static void request_redetect_class_init (RequestRedetectClass * klass) {

2021

request_redetect_parent_class = g_type_class_peek_parent (klass);

2022

}

2023

2024

2025

static void request_redetect_instance_init (RequestRedetect * self) {

2026

}

2027

2028

2029

GType request_redetect_get_type (void) {

2030

static volatile gsize request_redetect_type_id__volatile = 0;

2031

if (g_once_init_enter (&request_redetect_type_id__volatile)) {

2032

static const GTypeInfo g_define_type_info = { sizeof (RequestRedetectClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) request_redetect_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RequestRedetect), 0, (GInstanceInitFunc) request_redetect_instance_init, NULL };

2033

GType request_redetect_type_id;

2034

request_redetect_type_id = g_type_register_static (TYPE_REQUEST, "RequestRedetect", &g_define_type_info, 0);

2035

g_once_init_leave (&request_redetect_type_id__volatile, request_redetect_type_id);

2036

}

2037

return request_redetect_type_id__volatile;

2038

}

2039

2040

2041

RequestCancel* request_cancel_construct (GType object_type) {

2042

RequestCancel* self = NULL;

2043

self = (RequestCancel*) request_construct (object_type);

2044

return self;

2045

}

2046

2047

2048

RequestCancel* request_cancel_new (void) {

2049

return request_cancel_construct (TYPE_REQUEST_CANCEL);

2050

}

2051

2052

2053

static void request_cancel_class_init (RequestCancelClass * klass) {

2054

request_cancel_parent_class = g_type_class_peek_parent (klass);

2055

}

2056

2057

2058

static void request_cancel_instance_init (RequestCancel * self) {

2059

}

2060

2061

2062

GType request_cancel_get_type (void) {

2063

static volatile gsize request_cancel_type_id__volatile = 0;

2064

if (g_once_init_enter (&request_cancel_type_id__volatile)) {

2065

static const GTypeInfo g_define_type_info = { sizeof (RequestCancelClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) request_cancel_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RequestCancel), 0, (GInstanceInitFunc) request_cancel_instance_init, NULL };

2066

GType request_cancel_type_id;

2067

request_cancel_type_id = g_type_register_static (TYPE_REQUEST, "RequestCancel", &g_define_type_info, 0);

2068

g_once_init_leave (&request_cancel_type_id__volatile, request_cancel_type_id);

2069

}

2070

return request_cancel_type_id__volatile;

2071

}

2072

2073

2074

RequestStartScan* request_start_scan_construct (GType object_type) {

2075

RequestStartScan* self = NULL;

2076

self = (RequestStartScan*) request_construct (object_type);

2077

return self;

2078

}

2079

2080

2081

RequestStartScan* request_start_scan_new (void) {

2082

return request_start_scan_construct (TYPE_REQUEST_START_SCAN);

2083

}

2084

2085

2086

static void request_start_scan_class_init (RequestStartScanClass * klass) {

2087

request_start_scan_parent_class = g_type_class_peek_parent (klass);

2088

REQUEST_CLASS (klass)->finalize = request_start_scan_finalize;

2089

}

2090

2091

2092

static void request_start_scan_instance_init (RequestStartScan * self) {

2093

}

2094

2095

2096

static void request_start_scan_finalize (Request* obj) {

2097

RequestStartScan * self;

2098

self = REQUEST_START_SCAN (obj);

2099

_scan_job_unref0 (self->job);

2100

REQUEST_CLASS (request_start_scan_parent_class)->finalize (obj);

2101

}

2102

2103

2104

GType request_start_scan_get_type (void) {

2105

static volatile gsize request_start_scan_type_id__volatile = 0;

2106

if (g_once_init_enter (&request_start_scan_type_id__volatile)) {

2107

static const GTypeInfo g_define_type_info = { sizeof (RequestStartScanClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) request_start_scan_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RequestStartScan), 0, (GInstanceInitFunc) request_start_scan_instance_init, NULL };

2108

GType request_start_scan_type_id;

2109

request_start_scan_type_id = g_type_register_static (TYPE_REQUEST, "RequestStartScan", &g_define_type_info, 0);

2110

g_once_init_leave (&request_start_scan_type_id__volatile, request_start_scan_type_id);

2111

}

2112

return request_start_scan_type_id__volatile;

2113

}

2114

2115

2116

RequestQuit* request_quit_construct (GType object_type) {

2117

RequestQuit* self = NULL;

2118

self = (RequestQuit*) request_construct (object_type);

2119

return self;

2120

}

2121

2122

2123

RequestQuit* request_quit_new (void) {

2124

return request_quit_construct (TYPE_REQUEST_QUIT);

2125

}

2126

2127

2128

static void request_quit_class_init (RequestQuitClass * klass) {

2129

request_quit_parent_class = g_type_class_peek_parent (klass);

2130

}

2131

2132

2133

static void request_quit_instance_init (RequestQuit * self) {

2134

}

2135

2136

2137

GType request_quit_get_type (void) {

2138

static volatile gsize request_quit_type_id__volatile = 0;

2139

if (g_once_init_enter (&request_quit_type_id__volatile)) {

2140

static const GTypeInfo g_define_type_info = { sizeof (RequestQuitClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) request_quit_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (RequestQuit), 0, (GInstanceInitFunc) request_quit_instance_init, NULL };

2141

GType request_quit_type_id;

2142

request_quit_type_id = g_type_register_static (TYPE_REQUEST, "RequestQuit", &g_define_type_info, 0);

2143

g_once_init_leave (&request_quit_type_id__volatile, request_quit_type_id);

2144

}

2145

return request_quit_type_id__volatile;

2146

}

2147

2148

2149

Credentials* credentials_construct (GType object_type) {

2150

Credentials* self = NULL;

2151

self = (Credentials*) g_type_create_instance (object_type);

2152

return self;

2153

}

2154

2155

2156

Credentials* credentials_new (void) {

2157

return credentials_construct (TYPE_CREDENTIALS);

2158

}

2159

2160

2161

static void value_credentials_init (GValue* value) {

2162

value->data[0].v_pointer = NULL;

2163

}

2164

2165

2166

static void value_credentials_free_value (GValue* value) {

2167

if (value->data[0].v_pointer) {

2168

credentials_unref (value->data[0].v_pointer);

2169

}

2170

}

2171

2172

2173

static void value_credentials_copy_value (const GValue* src_value, GValue* dest_value) {

2174

if (src_value->data[0].v_pointer) {

2175

dest_value->data[0].v_pointer = credentials_ref (src_value->data[0].v_pointer);

2176

} else {

2177

dest_value->data[0].v_pointer = NULL;

2178

}

2179

}

2180

2181

2182

static gpointer value_credentials_peek_pointer (const GValue* value) {

2183

return value->data[0].v_pointer;

2184

}

2185

2186

2187

static gchar* value_credentials_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

2188

if (collect_values[0].v_pointer) {

2189

Credentials* object;

2190

object = collect_values[0].v_pointer;

2191

if (object->parent_instance.g_class == NULL) {

2192

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

2193

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

2194

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

2195

}

2196

value->data[0].v_pointer = credentials_ref (object);

2197

} else {

2198

value->data[0].v_pointer = NULL;

2199

}

2200

return NULL;

2201

}

2202

2203

2204

static gchar* value_credentials_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

2205

Credentials** object_p;

2206

object_p = collect_values[0].v_pointer;

2207

if (!object_p) {

2208

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

2209

}

2210

if (!value->data[0].v_pointer) {

2211

*object_p = NULL;

2212

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

2213

*object_p = value->data[0].v_pointer;

2214

} else {

2215

*object_p = credentials_ref (value->data[0].v_pointer);

2216

}

2217

return NULL;

2218

}

2219

2220

2221

GParamSpec* param_spec_credentials (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

2222

ParamSpecCredentials* spec;

2223

g_return_val_if_fail (g_type_is_a (object_type, TYPE_CREDENTIALS), NULL);

2224

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

2225

G_PARAM_SPEC (spec)->value_type = object_type;

2226

return G_PARAM_SPEC (spec);

2227

}

2228

2229

2230

gpointer value_get_credentials (const GValue* value) {

2231

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CREDENTIALS), NULL);

2232

return value->data[0].v_pointer;

2233

}

2234

2235

2236

void value_set_credentials (GValue* value, gpointer v_object) {

2237

Credentials* old;

2238

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CREDENTIALS));

2239

old = value->data[0].v_pointer;

2240

if (v_object) {

2241

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_CREDENTIALS));

2242

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

2243

value->data[0].v_pointer = v_object;

2244

credentials_ref (value->data[0].v_pointer);

2245

} else {

2246

value->data[0].v_pointer = NULL;

2247

}

2248

if (old) {

2249

credentials_unref (old);

2250

}

2251

}

2252

2253

2254

void value_take_credentials (GValue* value, gpointer v_object) {

2255

Credentials* old;

2256

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_CREDENTIALS));

2257

old = value->data[0].v_pointer;

2258

if (v_object) {

2259

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_CREDENTIALS));

2260

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

2261

value->data[0].v_pointer = v_object;

2262

} else {

2263

value->data[0].v_pointer = NULL;

2264

}

2265

if (old) {

2266

credentials_unref (old);

2267

}

2268

}

2269

2270

2271

static void credentials_class_init (CredentialsClass * klass) {

2272

credentials_parent_class = g_type_class_peek_parent (klass);

2273

CREDENTIALS_CLASS (klass)->finalize = credentials_finalize;

2274

}

2275

2276

2277

static void credentials_instance_init (Credentials * self) {

2278

self->ref_count = 1;

2279

}

2280

2281

2282

static void credentials_finalize (Credentials* obj) {

2283

Credentials * self;

2284

self = CREDENTIALS (obj);

2285

_g_free0 (self->username);

2286

_g_free0 (self->password);

2287

}

2288

2289

2290

GType credentials_get_type (void) {

2291

static volatile gsize credentials_type_id__volatile = 0;

2292

if (g_once_init_enter (&credentials_type_id__volatile)) {

2293

static const GTypeValueTable g_define_type_value_table = { value_credentials_init, value_credentials_free_value, value_credentials_copy_value, value_credentials_peek_pointer, "p", value_credentials_collect_value, "p", value_credentials_lcopy_value };

2294

static const GTypeInfo g_define_type_info = { sizeof (CredentialsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) credentials_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Credentials), 0, (GInstanceInitFunc) credentials_instance_init, &g_define_type_value_table };

2295

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

2296

GType credentials_type_id;

2297

credentials_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Credentials", &g_define_type_info, &g_define_type_fundamental_info, 0);

2298

g_once_init_leave (&credentials_type_id__volatile, credentials_type_id);

2299

}

2300

return credentials_type_id__volatile;

2301

}

2302

2303

2304

gpointer credentials_ref (gpointer instance) {

2305

Credentials* self;

2306

self = instance;

2307

g_atomic_int_inc (&self->ref_count);

2308

return instance;

2309

}

2310

2311

2312

void credentials_unref (gpointer instance) {

2313

Credentials* self;

2314

self = instance;

2315

if (g_atomic_int_dec_and_test (&self->ref_count)) {

2316

CREDENTIALS_GET_CLASS (self)->finalize (self);

2317

g_type_free_instance ((GTypeInstance *) self);

2318

}

2319

}

2320

2321

2322

GType scan_state_get_type (void) {

2323

static volatile gsize scan_state_type_id__volatile = 0;

2324

if (g_once_init_enter (&scan_state_type_id__volatile)) {

2325

static const GEnumValue values[] = {{SCAN_STATE_IDLE, "SCAN_STATE_IDLE", "idle"}, {SCAN_STATE_REDETECT, "SCAN_STATE_REDETECT", "redetect"}, {SCAN_STATE_OPEN, "SCAN_STATE_OPEN", "open"}, {SCAN_STATE_GET_OPTION, "SCAN_STATE_GET_OPTION", "get-option"}, {SCAN_STATE_START, "SCAN_STATE_START", "start"}, {SCAN_STATE_GET_PARAMETERS, "SCAN_STATE_GET_PARAMETERS", "get-parameters"}, {SCAN_STATE_READ, "SCAN_STATE_READ", "read"}, {0, NULL, NULL}};

2326

GType scan_state_type_id;

2327

scan_state_type_id = g_enum_register_static ("ScanState", values);

2328

g_once_init_leave (&scan_state_type_id__volatile, scan_state_type_id);

2329

}

2330

return scan_state_type_id__volatile;

2331

}

2332

2333

2334

static void notify_real_run (Notify* self, Scanner* scanner) {

2335

g_return_if_fail (self != NULL);

2336

g_return_if_fail (scanner != NULL);

2337

}

2338

2339

2340

void notify_run (Notify* self, Scanner* scanner) {

2341

NOTIFY_GET_CLASS (self)->run (self, scanner);

2342

}

2343

2344

2345

Notify* notify_construct (GType object_type) {

2346

Notify* self = NULL;

2347

self = (Notify*) g_type_create_instance (object_type);

2348

return self;

2349

}

2350

2351

2352

Notify* notify_new (void) {

2353

return notify_construct (TYPE_NOTIFY);

2354

}

2355

2356

2357

static void value_notify_init (GValue* value) {

2358

value->data[0].v_pointer = NULL;

2359

}

2360

2361

2362

static void value_notify_free_value (GValue* value) {

2363

if (value->data[0].v_pointer) {

2364

notify_unref (value->data[0].v_pointer);

2365

}

2366

}

2367

2368

2369

static void value_notify_copy_value (const GValue* src_value, GValue* dest_value) {

2370

if (src_value->data[0].v_pointer) {

2371

dest_value->data[0].v_pointer = notify_ref (src_value->data[0].v_pointer);

2372

} else {

2373

dest_value->data[0].v_pointer = NULL;

2374

}

2375

}

2376

2377

2378

static gpointer value_notify_peek_pointer (const GValue* value) {

2379

return value->data[0].v_pointer;

2380

}

2381

2382

2383

static gchar* value_notify_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

2384

if (collect_values[0].v_pointer) {

2385

Notify* object;

2386

object = collect_values[0].v_pointer;

2387

if (object->parent_instance.g_class == NULL) {

2388

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

2389

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

2390

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

2391

}

2392

value->data[0].v_pointer = notify_ref (object);

2393

} else {

2394

value->data[0].v_pointer = NULL;

2395

}

2396

return NULL;

2397

}

2398

2399

2400

static gchar* value_notify_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

2401

Notify** object_p;

2402

object_p = collect_values[0].v_pointer;

2403

if (!object_p) {

2404

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

2405

}

2406

if (!value->data[0].v_pointer) {

2407

*object_p = NULL;

2408

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

2409

*object_p = value->data[0].v_pointer;

2410

} else {

2411

*object_p = notify_ref (value->data[0].v_pointer);

2412

}

2413

return NULL;

2414

}

2415

2416

2417

GParamSpec* param_spec_notify (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

2418

ParamSpecNotify* spec;

2419

g_return_val_if_fail (g_type_is_a (object_type, TYPE_NOTIFY), NULL);

2420

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

2421

G_PARAM_SPEC (spec)->value_type = object_type;

2422

return G_PARAM_SPEC (spec);

2423

}

2424

2425

2426

gpointer value_get_notify (const GValue* value) {

2427

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_NOTIFY), NULL);

2428

return value->data[0].v_pointer;

2429

}

2430

2431

2432

void value_set_notify (GValue* value, gpointer v_object) {

2433

Notify* old;

2434

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_NOTIFY));

2435

old = value->data[0].v_pointer;

2436

if (v_object) {

2437

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_NOTIFY));

2438

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

2439

value->data[0].v_pointer = v_object;

2440

notify_ref (value->data[0].v_pointer);

2441

} else {

2442

value->data[0].v_pointer = NULL;

2443

}

2444

if (old) {

2445

notify_unref (old);

2446

}

2447

}

2448

2449

2450

void value_take_notify (GValue* value, gpointer v_object) {

2451

Notify* old;

2452

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_NOTIFY));

2453

old = value->data[0].v_pointer;

2454

if (v_object) {

2455

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_NOTIFY));

2456

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

2457

value->data[0].v_pointer = v_object;

2458

} else {

2459

value->data[0].v_pointer = NULL;

2460

}

2461

if (old) {

2462

notify_unref (old);

2463

}

2464

}

2465

2466

2467

static void notify_class_init (NotifyClass * klass) {

2468

notify_parent_class = g_type_class_peek_parent (klass);

2469

NOTIFY_CLASS (klass)->finalize = notify_finalize;

2470

NOTIFY_CLASS (klass)->run = notify_real_run;

2471

}

2472

2473

2474

static void notify_instance_init (Notify * self) {

2475

self->ref_count = 1;

2476

}

2477

2478

2479

static void notify_finalize (Notify* obj) {

2480

Notify * self;

2481

self = NOTIFY (obj);

2482

}

2483

2484

2485

GType notify_get_type (void) {

2486

static volatile gsize notify_type_id__volatile = 0;

2487

if (g_once_init_enter (&notify_type_id__volatile)) {

2488

static const GTypeValueTable g_define_type_value_table = { value_notify_init, value_notify_free_value, value_notify_copy_value, value_notify_peek_pointer, "p", value_notify_collect_value, "p", value_notify_lcopy_value };

2489

static const GTypeInfo g_define_type_info = { sizeof (NotifyClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Notify), 0, (GInstanceInitFunc) notify_instance_init, &g_define_type_value_table };

2490

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

2491

GType notify_type_id;

2492

notify_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Notify", &g_define_type_info, &g_define_type_fundamental_info, 0);

2493

g_once_init_leave (&notify_type_id__volatile, notify_type_id);

2494

}

2495

return notify_type_id__volatile;

2496

}

2497

2498

2499

gpointer notify_ref (gpointer instance) {

2500

Notify* self;

2501

self = instance;

2502

g_atomic_int_inc (&self->ref_count);

2503

return instance;

2504

}

2505

2506

2507

void notify_unref (gpointer instance) {

2508

Notify* self;

2509

self = instance;

2510

if (g_atomic_int_dec_and_test (&self->ref_count)) {

2511

NOTIFY_GET_CLASS (self)->finalize (self);

2512

g_type_free_instance ((GTypeInstance *) self);

2513

}

2514

}

2515

2516

2517

static void notify_scanning_changed_real_run (Notify* base, Scanner* scanner) {

2518

NotifyScanningChanged * self;

2519

self = (NotifyScanningChanged*) base;

2520

g_return_if_fail (scanner != NULL);

2521

g_signal_emit_by_name (scanner, "scanning-changed");

2522

}

2523

2524

2525

NotifyScanningChanged* notify_scanning_changed_construct (GType object_type) {

2526

NotifyScanningChanged* self = NULL;

2527

self = (NotifyScanningChanged*) notify_construct (object_type);

2528

return self;

2529

}

2530

2531

2532

NotifyScanningChanged* notify_scanning_changed_new (void) {

2533

return notify_scanning_changed_construct (TYPE_NOTIFY_SCANNING_CHANGED);

2534

}

2535

2536

2537

static void notify_scanning_changed_class_init (NotifyScanningChangedClass * klass) {

2538

notify_scanning_changed_parent_class = g_type_class_peek_parent (klass);

2539

NOTIFY_CLASS (klass)->run = notify_scanning_changed_real_run;

2540

}

2541

2542

2543

static void notify_scanning_changed_instance_init (NotifyScanningChanged * self) {

2544

}

2545

2546

2547

GType notify_scanning_changed_get_type (void) {

2548

static volatile gsize notify_scanning_changed_type_id__volatile = 0;

2549

if (g_once_init_enter (&notify_scanning_changed_type_id__volatile)) {

2550

static const GTypeInfo g_define_type_info = { sizeof (NotifyScanningChangedClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_scanning_changed_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NotifyScanningChanged), 0, (GInstanceInitFunc) notify_scanning_changed_instance_init, NULL };

2551

GType notify_scanning_changed_type_id;

2552

notify_scanning_changed_type_id = g_type_register_static (TYPE_NOTIFY, "NotifyScanningChanged", &g_define_type_info, 0);

2553

g_once_init_leave (&notify_scanning_changed_type_id__volatile, notify_scanning_changed_type_id);

2554

}

2555

return notify_scanning_changed_type_id__volatile;

2556

}

2557

2558

2559

static void _scan_device_unref0_ (gpointer var) {

2560

(var == NULL) ? NULL : (var = (scan_device_unref (var), NULL));

2561

}

2562

2563

2564

static void _g_list_free__scan_device_unref0_ (GList* self) {

2565

g_list_foreach (self, (GFunc) _scan_device_unref0_, NULL);

2566

g_list_free (self);

2567

}

2568

2569

2570

NotifyUpdateDevices* notify_update_devices_construct (GType object_type, GList* devices) {

2571

NotifyUpdateDevices* self = NULL;

2572

GList* _tmp0_;

2573

self = (NotifyUpdateDevices*) notify_construct (object_type);

2574

_tmp0_ = devices;

2575

devices = NULL;

2576

__g_list_free__scan_device_unref0_0 (self->priv->devices);

2577

self->priv->devices = _tmp0_;

2578

__g_list_free__scan_device_unref0_0 (devices);

2579

return self;

2580

}

2581

2582

2583

NotifyUpdateDevices* notify_update_devices_new (GList* devices) {

2584

return notify_update_devices_construct (TYPE_NOTIFY_UPDATE_DEVICES, devices);

2585

}

2586

2587

2588

static void notify_update_devices_real_run (Notify* base, Scanner* scanner) {

2589

NotifyUpdateDevices * self;

2590

self = (NotifyUpdateDevices*) base;

2591

g_return_if_fail (scanner != NULL);

2592

g_signal_emit_by_name (scanner, "update-devices", self->priv->devices);

2593

}

2594

2595

2596

static void notify_update_devices_class_init (NotifyUpdateDevicesClass * klass) {

2597

notify_update_devices_parent_class = g_type_class_peek_parent (klass);

2598

NOTIFY_CLASS (klass)->finalize = notify_update_devices_finalize;

2599

g_type_class_add_private (klass, sizeof (NotifyUpdateDevicesPrivate));

2600

NOTIFY_CLASS (klass)->run = notify_update_devices_real_run;

2601

}

2602

2603

2604

static void notify_update_devices_instance_init (NotifyUpdateDevices * self) {

2605

self->priv = NOTIFY_UPDATE_DEVICES_GET_PRIVATE (self);

2606

}

2607

2608

2609

static void notify_update_devices_finalize (Notify* obj) {

2610

NotifyUpdateDevices * self;

2611

self = NOTIFY_UPDATE_DEVICES (obj);

2612

__g_list_free__scan_device_unref0_0 (self->priv->devices);

2613

NOTIFY_CLASS (notify_update_devices_parent_class)->finalize (obj);

2614

}

2615

2616

2617

GType notify_update_devices_get_type (void) {

2618

static volatile gsize notify_update_devices_type_id__volatile = 0;

2619

if (g_once_init_enter (&notify_update_devices_type_id__volatile)) {

2620

static const GTypeInfo g_define_type_info = { sizeof (NotifyUpdateDevicesClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_update_devices_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NotifyUpdateDevices), 0, (GInstanceInitFunc) notify_update_devices_instance_init, NULL };

2621

GType notify_update_devices_type_id;

2622

notify_update_devices_type_id = g_type_register_static (TYPE_NOTIFY, "NotifyUpdateDevices", &g_define_type_info, 0);

2623

g_once_init_leave (&notify_update_devices_type_id__volatile, notify_update_devices_type_id);

2624

}

2625

return notify_update_devices_type_id__volatile;

2626

}

2627

2628

2629

NotifyRequestAuthorization* notify_request_authorization_construct (GType object_type, const gchar* resource) {

2630

NotifyRequestAuthorization* self = NULL;

2631

gchar* _tmp0_;

2632

g_return_val_if_fail (resource != NULL, NULL);

2633

self = (NotifyRequestAuthorization*) notify_construct (object_type);

2634

_tmp0_ = g_strdup (resource);

2635

_g_free0 (self->priv->resource);

2636

self->priv->resource = _tmp0_;

2637

return self;

2638

}

2639

2640

2641

NotifyRequestAuthorization* notify_request_authorization_new (const gchar* resource) {

2642

return notify_request_authorization_construct (TYPE_NOTIFY_REQUEST_AUTHORIZATION, resource);

2643

}

2644

2645

2646

static void notify_request_authorization_real_run (Notify* base, Scanner* scanner) {

2647

NotifyRequestAuthorization * self;

2648

self = (NotifyRequestAuthorization*) base;

2649

g_return_if_fail (scanner != NULL);

2650

g_signal_emit_by_name (scanner, "request-authorization", self->priv->resource);

2651

}

2652

2653

2654

static void notify_request_authorization_class_init (NotifyRequestAuthorizationClass * klass) {

2655

notify_request_authorization_parent_class = g_type_class_peek_parent (klass);

2656

NOTIFY_CLASS (klass)->finalize = notify_request_authorization_finalize;

2657

g_type_class_add_private (klass, sizeof (NotifyRequestAuthorizationPrivate));

2658

NOTIFY_CLASS (klass)->run = notify_request_authorization_real_run;

2659

}

2660

2661

2662

static void notify_request_authorization_instance_init (NotifyRequestAuthorization * self) {

2663

self->priv = NOTIFY_REQUEST_AUTHORIZATION_GET_PRIVATE (self);

2664

}

2665

2666

2667

static void notify_request_authorization_finalize (Notify* obj) {

2668

NotifyRequestAuthorization * self;

2669

self = NOTIFY_REQUEST_AUTHORIZATION (obj);

2670

_g_free0 (self->priv->resource);

2671

NOTIFY_CLASS (notify_request_authorization_parent_class)->finalize (obj);

2672

}

2673

2674

2675

GType notify_request_authorization_get_type (void) {

2676

static volatile gsize notify_request_authorization_type_id__volatile = 0;

2677

if (g_once_init_enter (&notify_request_authorization_type_id__volatile)) {

2678

static const GTypeInfo g_define_type_info = { sizeof (NotifyRequestAuthorizationClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_request_authorization_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NotifyRequestAuthorization), 0, (GInstanceInitFunc) notify_request_authorization_instance_init, NULL };

2679

GType notify_request_authorization_type_id;

2680

notify_request_authorization_type_id = g_type_register_static (TYPE_NOTIFY, "NotifyRequestAuthorization", &g_define_type_info, 0);

2681

g_once_init_leave (&notify_request_authorization_type_id__volatile, notify_request_authorization_type_id);

2682

}

2683

return notify_request_authorization_type_id__volatile;

2684

}

2685

2686

2687

NotifyScanFailed* notify_scan_failed_construct (GType object_type, gint error_code, const gchar* error_string) {

2688

NotifyScanFailed* self = NULL;

2689

gchar* _tmp0_;

2690

g_return_val_if_fail (error_string != NULL, NULL);

2691

self = (NotifyScanFailed*) notify_construct (object_type);

2692

self->priv->error_code = error_code;

2693

_tmp0_ = g_strdup (error_string);

2694

_g_free0 (self->priv->error_string);

2695

self->priv->error_string = _tmp0_;

2696

return self;

2697

}

2698

2699

2700

NotifyScanFailed* notify_scan_failed_new (gint error_code, const gchar* error_string) {

2701

return notify_scan_failed_construct (TYPE_NOTIFY_SCAN_FAILED, error_code, error_string);

2702

}

2703

2704

2705

static void notify_scan_failed_real_run (Notify* base, Scanner* scanner) {

2706

NotifyScanFailed * self;

2707

self = (NotifyScanFailed*) base;

2708

g_return_if_fail (scanner != NULL);

2709

g_signal_emit_by_name (scanner, "scan-failed", self->priv->error_code, self->priv->error_string);

2710

}

2711

2712

2713

static void notify_scan_failed_class_init (NotifyScanFailedClass * klass) {

2714

notify_scan_failed_parent_class = g_type_class_peek_parent (klass);

2715

NOTIFY_CLASS (klass)->finalize = notify_scan_failed_finalize;

2716

g_type_class_add_private (klass, sizeof (NotifyScanFailedPrivate));

2717

NOTIFY_CLASS (klass)->run = notify_scan_failed_real_run;

2718

}

2719

2720

2721

static void notify_scan_failed_instance_init (NotifyScanFailed * self) {

2722

self->priv = NOTIFY_SCAN_FAILED_GET_PRIVATE (self);

2723

}

2724

2725

2726

static void notify_scan_failed_finalize (Notify* obj) {

2727

NotifyScanFailed * self;

2728

self = NOTIFY_SCAN_FAILED (obj);

2729

_g_free0 (self->priv->error_string);

2730

NOTIFY_CLASS (notify_scan_failed_parent_class)->finalize (obj);

2731

}

2732

2733

2734

GType notify_scan_failed_get_type (void) {

2735

static volatile gsize notify_scan_failed_type_id__volatile = 0;

2736

if (g_once_init_enter (&notify_scan_failed_type_id__volatile)) {

2737

static const GTypeInfo g_define_type_info = { sizeof (NotifyScanFailedClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_scan_failed_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NotifyScanFailed), 0, (GInstanceInitFunc) notify_scan_failed_instance_init, NULL };

2738

GType notify_scan_failed_type_id;

2739

notify_scan_failed_type_id = g_type_register_static (TYPE_NOTIFY, "NotifyScanFailed", &g_define_type_info, 0);

2740

g_once_init_leave (&notify_scan_failed_type_id__volatile, notify_scan_failed_type_id);

2741

}

2742

return notify_scan_failed_type_id__volatile;

2743

}

2744

2745

2746

static void notify_document_done_real_run (Notify* base, Scanner* scanner) {

2747

NotifyDocumentDone * self;

2748

self = (NotifyDocumentDone*) base;

2749

g_return_if_fail (scanner != NULL);

2750

g_signal_emit_by_name (scanner, "document-done");

2751

}

2752

2753

2754

NotifyDocumentDone* notify_document_done_construct (GType object_type) {

2755

NotifyDocumentDone* self = NULL;

2756

self = (NotifyDocumentDone*) notify_construct (object_type);

2757

return self;

2758

}

2759

2760

2761

NotifyDocumentDone* notify_document_done_new (void) {

2762

return notify_document_done_construct (TYPE_NOTIFY_DOCUMENT_DONE);

2763

}

2764

2765

2766

static void notify_document_done_class_init (NotifyDocumentDoneClass * klass) {

2767

notify_document_done_parent_class = g_type_class_peek_parent (klass);

2768

NOTIFY_CLASS (klass)->run = notify_document_done_real_run;

2769

}

2770

2771

2772

static void notify_document_done_instance_init (NotifyDocumentDone * self) {

2773

}

2774

2775

2776

GType notify_document_done_get_type (void) {

2777

static volatile gsize notify_document_done_type_id__volatile = 0;

2778

if (g_once_init_enter (&notify_document_done_type_id__volatile)) {

2779

static const GTypeInfo g_define_type_info = { sizeof (NotifyDocumentDoneClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_document_done_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NotifyDocumentDone), 0, (GInstanceInitFunc) notify_document_done_instance_init, NULL };

2780

GType notify_document_done_type_id;

2781

notify_document_done_type_id = g_type_register_static (TYPE_NOTIFY, "NotifyDocumentDone", &g_define_type_info, 0);

2782

g_once_init_leave (&notify_document_done_type_id__volatile, notify_document_done_type_id);

2783

}

2784

return notify_document_done_type_id__volatile;

2785

}

2786

2787

2788

static void notify_expect_page_real_run (Notify* base, Scanner* scanner) {

2789

NotifyExpectPage * self;

2790

self = (NotifyExpectPage*) base;

2791

g_return_if_fail (scanner != NULL);

2792

g_signal_emit_by_name (scanner, "expect-page");

2793

}

2794

2795

2796

NotifyExpectPage* notify_expect_page_construct (GType object_type) {

2797

NotifyExpectPage* self = NULL;

2798

self = (NotifyExpectPage*) notify_construct (object_type);

2799

return self;

2800

}

2801

2802

2803

NotifyExpectPage* notify_expect_page_new (void) {

2804

return notify_expect_page_construct (TYPE_NOTIFY_EXPECT_PAGE);

2805

}

2806

2807

2808

static void notify_expect_page_class_init (NotifyExpectPageClass * klass) {

2809

notify_expect_page_parent_class = g_type_class_peek_parent (klass);

2810

NOTIFY_CLASS (klass)->run = notify_expect_page_real_run;

2811

}

2812

2813

2814

static void notify_expect_page_instance_init (NotifyExpectPage * self) {

2815

}

2816

2817

2818

GType notify_expect_page_get_type (void) {

2819

static volatile gsize notify_expect_page_type_id__volatile = 0;

2820

if (g_once_init_enter (&notify_expect_page_type_id__volatile)) {

2821

static const GTypeInfo g_define_type_info = { sizeof (NotifyExpectPageClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_expect_page_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NotifyExpectPage), 0, (GInstanceInitFunc) notify_expect_page_instance_init, NULL };

2822

GType notify_expect_page_type_id;

2823

notify_expect_page_type_id = g_type_register_static (TYPE_NOTIFY, "NotifyExpectPage", &g_define_type_info, 0);

2824

g_once_init_leave (&notify_expect_page_type_id__volatile, notify_expect_page_type_id);

2825

}

2826

return notify_expect_page_type_id__volatile;

2827

}

2828

2829

2830

static gpointer _scan_page_info_ref0 (gpointer self) {

2831

return self ? scan_page_info_ref (self) : NULL;

2832

}

2833

2834

2835

NotifyGotPageInfo* notify_got_page_info_construct (GType object_type, ScanPageInfo* info) {

2836

NotifyGotPageInfo* self = NULL;

2837

ScanPageInfo* _tmp0_;

2838

g_return_val_if_fail (info != NULL, NULL);

2839

self = (NotifyGotPageInfo*) notify_construct (object_type);

2840

_tmp0_ = _scan_page_info_ref0 (info);

2841

_scan_page_info_unref0 (self->priv->info);

2842

self->priv->info = _tmp0_;

2843

return self;

2844

}

2845

2846

2847

NotifyGotPageInfo* notify_got_page_info_new (ScanPageInfo* info) {

2848

return notify_got_page_info_construct (TYPE_NOTIFY_GOT_PAGE_INFO, info);

2849

}

2850

2851

2852

static void notify_got_page_info_real_run (Notify* base, Scanner* scanner) {

2853

NotifyGotPageInfo * self;

2854

self = (NotifyGotPageInfo*) base;

2855

g_return_if_fail (scanner != NULL);

2856

g_signal_emit_by_name (scanner, "got-page-info", self->priv->info);

2857

}

2858

2859

2860

static void notify_got_page_info_class_init (NotifyGotPageInfoClass * klass) {

2861

notify_got_page_info_parent_class = g_type_class_peek_parent (klass);

2862

NOTIFY_CLASS (klass)->finalize = notify_got_page_info_finalize;

2863

g_type_class_add_private (klass, sizeof (NotifyGotPageInfoPrivate));

2864

NOTIFY_CLASS (klass)->run = notify_got_page_info_real_run;

2865

}

2866

2867

2868

static void notify_got_page_info_instance_init (NotifyGotPageInfo * self) {

2869

self->priv = NOTIFY_GOT_PAGE_INFO_GET_PRIVATE (self);

2870

}

2871

2872

2873

static void notify_got_page_info_finalize (Notify* obj) {

2874

NotifyGotPageInfo * self;

2875

self = NOTIFY_GOT_PAGE_INFO (obj);

2876

_scan_page_info_unref0 (self->priv->info);

2877

NOTIFY_CLASS (notify_got_page_info_parent_class)->finalize (obj);

2878

}

2879

2880

2881

GType notify_got_page_info_get_type (void) {

2882

static volatile gsize notify_got_page_info_type_id__volatile = 0;

2883

if (g_once_init_enter (&notify_got_page_info_type_id__volatile)) {

2884

static const GTypeInfo g_define_type_info = { sizeof (NotifyGotPageInfoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_got_page_info_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NotifyGotPageInfo), 0, (GInstanceInitFunc) notify_got_page_info_instance_init, NULL };

2885

GType notify_got_page_info_type_id;

2886

notify_got_page_info_type_id = g_type_register_static (TYPE_NOTIFY, "NotifyGotPageInfo", &g_define_type_info, 0);

2887

g_once_init_leave (&notify_got_page_info_type_id__volatile, notify_got_page_info_type_id);

2888

}

2889

return notify_got_page_info_type_id__volatile;

2890

}

2891

2892

2893

static void notify_page_done_real_run (Notify* base, Scanner* scanner) {

2894

NotifyPageDone * self;

2895

self = (NotifyPageDone*) base;

2896

g_return_if_fail (scanner != NULL);

2897

g_signal_emit_by_name (scanner, "page-done");

2898

}

2899

2900

2901

NotifyPageDone* notify_page_done_construct (GType object_type) {

2902

NotifyPageDone* self = NULL;

2903

self = (NotifyPageDone*) notify_construct (object_type);

2904

return self;

2905

}

2906

2907

2908

NotifyPageDone* notify_page_done_new (void) {

2909

return notify_page_done_construct (TYPE_NOTIFY_PAGE_DONE);

2910

}

2911

2912

2913

static void notify_page_done_class_init (NotifyPageDoneClass * klass) {

2914

notify_page_done_parent_class = g_type_class_peek_parent (klass);

2915

NOTIFY_CLASS (klass)->run = notify_page_done_real_run;

2916

}

2917

2918

2919

static void notify_page_done_instance_init (NotifyPageDone * self) {

2920

}

2921

2922

2923

GType notify_page_done_get_type (void) {

2924

static volatile gsize notify_page_done_type_id__volatile = 0;

2925

if (g_once_init_enter (&notify_page_done_type_id__volatile)) {

2926

static const GTypeInfo g_define_type_info = { sizeof (NotifyPageDoneClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_page_done_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NotifyPageDone), 0, (GInstanceInitFunc) notify_page_done_instance_init, NULL };

2927

GType notify_page_done_type_id;

2928

notify_page_done_type_id = g_type_register_static (TYPE_NOTIFY, "NotifyPageDone", &g_define_type_info, 0);

2929

g_once_init_leave (&notify_page_done_type_id__volatile, notify_page_done_type_id);

2930

}

2931

return notify_page_done_type_id__volatile;

2932

}

2933

2934

2935

static gpointer _scan_line_ref0 (gpointer self) {

2936

return self ? scan_line_ref (self) : NULL;

2937

}

2938

2939

2940

NotifyGotLine* notify_got_line_construct (GType object_type, ScanLine* line) {

2941

NotifyGotLine* self = NULL;

2942

ScanLine* _tmp0_;

2943

g_return_val_if_fail (line != NULL, NULL);

2944

self = (NotifyGotLine*) notify_construct (object_type);

2945

_tmp0_ = _scan_line_ref0 (line);

2946

_scan_line_unref0 (self->priv->line);

2947

self->priv->line = _tmp0_;

2948

return self;

2949

}

2950

2951

2952

NotifyGotLine* notify_got_line_new (ScanLine* line) {

2953

return notify_got_line_construct (TYPE_NOTIFY_GOT_LINE, line);

2954

}

2955

2956

2957

static void notify_got_line_real_run (Notify* base, Scanner* scanner) {

2958

NotifyGotLine * self;

2959

self = (NotifyGotLine*) base;

2960

g_return_if_fail (scanner != NULL);

2961

g_signal_emit_by_name (scanner, "got-line", self->priv->line);

2962

}

2963

2964

2965

static void notify_got_line_class_init (NotifyGotLineClass * klass) {

2966

notify_got_line_parent_class = g_type_class_peek_parent (klass);

2967

NOTIFY_CLASS (klass)->finalize = notify_got_line_finalize;

2968

g_type_class_add_private (klass, sizeof (NotifyGotLinePrivate));

2969

NOTIFY_CLASS (klass)->run = notify_got_line_real_run;

2970

}

2971

2972

2973

static void notify_got_line_instance_init (NotifyGotLine * self) {

2974

self->priv = NOTIFY_GOT_LINE_GET_PRIVATE (self);

2975

}

2976

2977

2978

static void notify_got_line_finalize (Notify* obj) {

2979

NotifyGotLine * self;

2980

self = NOTIFY_GOT_LINE (obj);

2981

_scan_line_unref0 (self->priv->line);

2982

NOTIFY_CLASS (notify_got_line_parent_class)->finalize (obj);

2983

}

2984

2985

2986

GType notify_got_line_get_type (void) {

2987

static volatile gsize notify_got_line_type_id__volatile = 0;

2988

if (g_once_init_enter (&notify_got_line_type_id__volatile)) {

2989

static const GTypeInfo g_define_type_info = { sizeof (NotifyGotLineClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) notify_got_line_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (NotifyGotLine), 0, (GInstanceInitFunc) notify_got_line_instance_init, NULL };

2990

GType notify_got_line_type_id;

2991

notify_got_line_type_id = g_type_register_static (TYPE_NOTIFY, "NotifyGotLine", &g_define_type_info, 0);

2992

g_once_init_leave (&notify_got_line_type_id__volatile, notify_got_line_type_id);

2993

}

2994

return notify_got_line_type_id__volatile;

2995

}

2996

2997

2998

static void _scan_job_unref0_ (gpointer var) {

2999

(var == NULL) ? NULL : (var = (scan_job_unref (var), NULL));

3000

}

3001

3002

3003

static void _g_list_free__scan_job_unref0_ (GList* self) {

3004

g_list_foreach (self, (GFunc) _scan_job_unref0_, NULL);

3005

g_list_free (self);

3006

}

3007

3008

3009

static Scanner* scanner_construct (GType object_type) {

3010

Scanner* self = NULL;

3011

GAsyncQueue* _tmp0_ = NULL;

3012

GAsyncQueue* _tmp1_ = NULL;

3013

GAsyncQueue* _tmp2_ = NULL;

3014

self = (Scanner*) g_type_create_instance (object_type);

3015

_tmp0_ = g_async_queue_new ();

3016

_g_async_queue_unref0 (self->priv->request_queue);

3017

self->priv->request_queue = _tmp0_;

3018

_tmp1_ = g_async_queue_new ();

3019

_g_async_queue_unref0 (self->priv->notify_queue);

3020

self->priv->notify_queue = _tmp1_;

3021

_tmp2_ = g_async_queue_new ();

3022

_g_async_queue_unref0 (self->priv->authorize_queue);

3023

self->priv->authorize_queue = _tmp2_;

3024

return self;

3025

}

3026

3027

3028

static Scanner* scanner_new (void) {

3029

return scanner_construct (TYPE_SCANNER);

3030

}

3031

3032

3033

static gpointer _scanner_ref0 (gpointer self) {

3034

return self ? scanner_ref (self) : NULL;

3035

}

3036

3037

3038

Scanner* scanner_get_instance (void) {

3039

Scanner* result = NULL;

3040

Scanner* _tmp1_;

3041

if (scanner_scanner_object == NULL) {

3042

Scanner* _tmp0_ = NULL;

3043

_tmp0_ = scanner_new ();

3044

_scanner_unref0 (scanner_scanner_object);

3045

scanner_scanner_object = _tmp0_;

3046

}

3047

_tmp1_ = _scanner_ref0 (scanner_scanner_object);

3048

result = _tmp1_;

3049

return result;

3050

}

3051

3052

3053

static gboolean scanner_notify_idle_cb (Scanner* self) {

3054

gboolean result = FALSE;

3055

gpointer _tmp0_ = NULL;

3056

Notify* notification;

3057

g_return_val_if_fail (self != NULL, FALSE);

3058

_tmp0_ = g_async_queue_pop (self->priv->notify_queue);

3059

notification = (Notify*) _tmp0_;

3060

notify_run (notification, self);

3061

result = FALSE;

3062

_notify_unref0 (notification);

3063

return result;

3064

}

3065

3066

3067

static gpointer _notify_ref0 (gpointer self) {

3068

return self ? notify_ref (self) : NULL;

3069

}

3070

3071

3072

static gboolean _scanner_notify_idle_cb_gsource_func (gpointer self) {

3073

gboolean result;

3074

result = scanner_notify_idle_cb (self);

3075

return result;

3076

}

3077

3078

3079

static void scanner_notify (Scanner* self, Notify* notification) {

3080

Notify* _tmp0_;

3081

g_return_if_fail (self != NULL);

3082

g_return_if_fail (notification != NULL);

3083

_tmp0_ = _notify_ref0 (notification);

3084

g_async_queue_push (self->priv->notify_queue, _tmp0_);

3085

g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, _scanner_notify_idle_cb_gsource_func, scanner_ref (self), scanner_unref);

3086

}

3087

3088

3089

static void scanner_set_scanning (Scanner* self, gboolean is_scanning) {

3090

gboolean _tmp0_ = FALSE;

3091

gboolean _tmp1_ = FALSE;

3092

g_return_if_fail (self != NULL);

3093

if (self->priv->scanning) {

3094

_tmp1_ = !is_scanning;

3095

} else {

3096

_tmp1_ = FALSE;

3097

}

3098

if (_tmp1_) {

3099

_tmp0_ = TRUE;

3100

} else {

3101

gboolean _tmp2_ = FALSE;

3102

if (!self->priv->scanning) {

3103

_tmp2_ = is_scanning;

3104

} else {

3105

_tmp2_ = FALSE;

3106

}

3107

_tmp0_ = _tmp2_;

3108

}

3109

if (_tmp0_) {

3110

NotifyScanningChanged* _tmp3_ = NULL;

3111

NotifyScanningChanged* _tmp4_;

3112

self->priv->scanning = is_scanning;

3113

g_signal_emit_by_name (self, "scanning-changed");

3114

_tmp3_ = notify_scanning_changed_new ();

3115

_tmp4_ = _tmp3_;

3116

scanner_notify (self, (Notify*) _tmp4_);

3117

_notify_unref0 (_tmp4_);

3118

}

3119

}

3120

3121

3122

static gboolean string_contains (const gchar* self, const gchar* needle) {

3123

gboolean result = FALSE;

3124

gchar* _tmp0_ = NULL;

3125

g_return_val_if_fail (self != NULL, FALSE);

3126

g_return_val_if_fail (needle != NULL, FALSE);

3127

_tmp0_ = strstr ((gchar*) self, (gchar*) needle);

3128

result = _tmp0_ != NULL;

3129

return result;

3130

}

3131

3132

3133

static gint scanner_get_device_weight (const gchar* device) {

3134

gint result = 0;

3135

gboolean _tmp0_;

3136

gboolean _tmp1_;

3137

g_return_val_if_fail (device != NULL, 0);

3138

_tmp0_ = g_str_has_prefix (device, "vfl:");

3139

if (_tmp0_) {

3140

result = 2;

3141

return result;

3142

}

3143

_tmp1_ = string_contains (device, "usb");

3144

if (_tmp1_) {

3145

result = 0;

3146

return result;

3147

}

3148

result = 1;

3149

return result;

3150

}

3151

3152

3153

static gint scanner_compare_devices (ScanDevice* device1, ScanDevice* device2) {

3154

gint result = 0;

3155

gint _tmp0_;

3156

gint weight1;

3157

gint _tmp1_;

3158

gint weight2;

3159

gint _tmp2_;

3160

g_return_val_if_fail (device1 != NULL, 0);

3161

g_return_val_if_fail (device2 != NULL, 0);

3162

_tmp0_ = scanner_get_device_weight (device1->name);

3163

weight1 = _tmp0_;

3164

_tmp1_ = scanner_get_device_weight (device2->name);

3165

weight2 = _tmp1_;

3166

if (weight1 != weight2) {

3167

result = weight1 - weight2;

3168

return result;

3169

}

3170

_tmp2_ = g_strcmp0 (device1->label, device2->label);

3171

result = _tmp2_;

3172

return result;

3173

}

3174

3175

3176

static gchar* sane_status_to_string (SANE_Status status) {

3177

gchar* result = NULL;

3178

switch (status) {

3179

case SANE_STATUS_GOOD:

3180

{

3181

gchar* _tmp0_;

3182

_tmp0_ = g_strdup ("SANE_STATUS_GOOD");

3183

result = _tmp0_;

3184

return result;

3185

}

3186

case SANE_STATUS_UNSUPPORTED:

3187

{

3188

gchar* _tmp1_;

3189

_tmp1_ = g_strdup ("SANE_STATUS_UNSUPPORTED");

3190

result = _tmp1_;

3191

return result;

3192

}

3193

case SANE_STATUS_CANCELLED:

3194

{

3195

gchar* _tmp2_;

3196

_tmp2_ = g_strdup ("SANE_STATUS_CANCELLED");

3197

result = _tmp2_;

3198

return result;

3199

}

3200

case SANE_STATUS_DEVICE_BUSY:

3201

{

3202

gchar* _tmp3_;

3203

_tmp3_ = g_strdup ("SANE_STATUS_DEVICE_BUSY");

3204

result = _tmp3_;

3205

return result;

3206

}

3207

case SANE_STATUS_INVAL:

3208

{

3209

gchar* _tmp4_;

3210

_tmp4_ = g_strdup ("SANE_STATUS_INVAL");

3211

result = _tmp4_;

3212

return result;

3213

}

3214

case SANE_STATUS_EOF:

3215

{

3216

gchar* _tmp5_;

3217

_tmp5_ = g_strdup ("SANE_STATUS_EOF");

3218

result = _tmp5_;

3219

return result;

3220

}

3221

case SANE_STATUS_JAMMED:

3222

{

3223

gchar* _tmp6_;

3224

_tmp6_ = g_strdup ("SANE_STATUS_JAMMED");

3225

result = _tmp6_;

3226

return result;

3227

}

3228

case SANE_STATUS_NO_DOCS:

3229

{

3230

gchar* _tmp7_;

3231

_tmp7_ = g_strdup ("SANE_STATUS_NO_DOCS");

3232

result = _tmp7_;

3233

return result;

3234

}

3235

case SANE_STATUS_COVER_OPEN:

3236

{

3237

gchar* _tmp8_;

3238

_tmp8_ = g_strdup ("SANE_STATUS_COVER_OPEN");

3239

result = _tmp8_;

3240

return result;

3241

}

3242

case SANE_STATUS_IO_ERROR:

3243

{

3244

gchar* _tmp9_;

3245

_tmp9_ = g_strdup ("SANE_STATUS_IO_ERROR");

3246

result = _tmp9_;

3247

return result;

3248

}

3249

case SANE_STATUS_NO_MEM:

3250

{

3251

gchar* _tmp10_;

3252

_tmp10_ = g_strdup ("SANE_STATUS_NO_MEM");

3253

result = _tmp10_;

3254

return result;

3255

}

3256

case SANE_STATUS_ACCESS_DENIED:

3257

{

3258

gchar* _tmp11_;

3259

_tmp11_ = g_strdup ("SANE_STATUS_ACCESS_DENIED");

3260

result = _tmp11_;

3261

return result;

3262

}

3263

default:

3264

{

3265

gchar* _tmp12_ = NULL;

3266

_tmp12_ = g_strdup_printf ("SANE_STATUS(%d)", (gint) status);

3267

result = _tmp12_;

3268

return result;

3269

}

3270

}

3271

}

3272

3273

3274

static gchar* string_replace (const gchar* self, const gchar* old, const gchar* replacement) {

3275

gchar* result = NULL;

3276

GError * _inner_error_ = NULL;

3277

g_return_val_if_fail (self != NULL, NULL);

3278

g_return_val_if_fail (old != NULL, NULL);

3279

g_return_val_if_fail (replacement != NULL, NULL);

3280

{

3281

gchar* _tmp0_ = NULL;

3282

gchar* _tmp1_;

3283

GRegex* _tmp2_ = NULL;

3284

GRegex* _tmp3_;

3285

GRegex* regex;

3286

gchar* _tmp4_ = NULL;

3287

gchar* _tmp5_;

3288

_tmp0_ = g_regex_escape_string (old, -1);

3289

_tmp1_ = _tmp0_;

3290

_tmp2_ = g_regex_new (_tmp1_, 0, 0, &_inner_error_);

3291

_tmp3_ = _tmp2_;

3292

_g_free0 (_tmp1_);

3293

regex = _tmp3_;

3294

if (_inner_error_ != NULL) {

3295

if (_inner_error_->domain == G_REGEX_ERROR) {

3296

goto __catch8_g_regex_error;

3297

}

3298

g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

3299

g_clear_error (&_inner_error_);

3300

return NULL;

3301

}

3302

_tmp4_ = g_regex_replace_literal (regex, self, (gssize) (-1), 0, replacement, 0, &_inner_error_);

3303

_tmp5_ = _tmp4_;

3304

if (_inner_error_ != NULL) {

3305

_g_regex_unref0 (regex);

3306

if (_inner_error_->domain == G_REGEX_ERROR) {

3307

goto __catch8_g_regex_error;

3308

}

3309

_g_regex_unref0 (regex);

3310

g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

3311

g_clear_error (&_inner_error_);

3312

return NULL;

3313

}

3314

result = _tmp5_;

3315

_g_regex_unref0 (regex);

3316

return result;

3317

}

3318

goto __finally8;

3319

__catch8_g_regex_error:

3320

{

3321

GError* e = NULL;

3322

e = _inner_error_;

3323

_inner_error_ = NULL;

3324

g_assert_not_reached ();

3325

_g_error_free0 (e);

3326

}

3327

__finally8:

3328

if (_inner_error_ != NULL) {

3329

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

3330

g_clear_error (&_inner_error_);

3331

return NULL;

3332

}

3333

}

3334

3335

3336

static gpointer _scan_device_ref0 (gpointer self) {

3337

return self ? scan_device_ref (self) : NULL;

3338

}

3339

3340

3341

static gint _scanner_compare_devices_gcompare_func (gconstpointer a, gconstpointer b) {

3342

gint result;

3343

result = scanner_compare_devices (a, b);

3344

return result;

3345

}

3346

3347

3348

static void scanner_do_redetect (Scanner* self) {

3349

SANE_Device** device_list;

3350

gint device_list_length1;

3351

gint _device_list_size_;

3352

SANE_Device** _tmp0_ = NULL;

3353

SANE_Status _tmp1_;

3354

SANE_Status status;

3355

gchar* _tmp2_ = NULL;

3356

gchar* _tmp3_;

3357

GList* devices;

3358

GList* _tmp17_;

3359

NotifyUpdateDevices* _tmp18_ = NULL;

3360

NotifyUpdateDevices* _tmp19_;

3361

g_return_if_fail (self != NULL);

3362

device_list = NULL;

3363

device_list_length1 = 0;

3364

_device_list_size_ = device_list_length1;

3365

_tmp1_ = sane_get_devices (&_tmp0_, FALSE);

3366

device_list = _tmp0_;

3367

device_list_length1 = -1;

3368

_device_list_size_ = device_list_length1;

3369

status = _tmp1_;

3370

_tmp2_ = sane_status_to_string (status);

3371

_tmp3_ = _tmp2_;

3372

g_debug ("scanner.vala:318: sane_get_devices () -> %s", _tmp3_);

3373

_g_free0 (_tmp3_);

3374

if (status != SANE_STATUS_GOOD) {

3375

const gchar* _tmp4_ = NULL;

3376

_tmp4_ = sane_strstatus (status);

3377

g_warning ("scanner.vala:321: Unable to get SANE devices: %s", _tmp4_);

3378

self->priv->need_redetect = FALSE;

3379

self->priv->state = SCAN_STATE_IDLE;

3380

return;

3381

}

3382

devices = NULL;

3383

{

3384

gint i;

3385

i = 0;

3386

{

3387

gboolean _tmp5_;

3388

_tmp5_ = TRUE;

3389

while (TRUE) {

3390

ScanDevice* _tmp6_ = NULL;

3391

ScanDevice* scan_device;

3392

gchar* _tmp7_;

3393

gchar* _tmp8_;

3394

gchar* vendor;

3395

gchar* _tmp10_ = NULL;

3396

gchar* _tmp11_ = NULL;

3397

gchar* _tmp12_;

3398

ScanDevice* _tmp13_;

3399

if (!_tmp5_) {

3400

i++;

3401

}

3402

_tmp5_ = FALSE;

3403

if (!(device_list[i] != NULL)) {

3404

break;

3405

}

3406

g_debug ("scanner.vala:330: Device: name=\"%s\" vendor=\"%s\" model=\"%s\" type=" \

3407

"\"%s\"", device_list[i]->name, device_list[i]->vendor, device_list[i]->model, device_list[i]->type);

3408

_tmp6_ = scan_device_new ();

3409

scan_device = _tmp6_;

3410

_tmp7_ = g_strdup (device_list[i]->name);

3411

_g_free0 (scan_device->name);

3412

scan_device->name = _tmp7_;

3413

_tmp8_ = g_strdup (device_list[i]->vendor);

3414

vendor = _tmp8_;

3415

if (g_strcmp0 (vendor, "Hewlett-Packard") == 0) {

3416

gchar* _tmp9_;

3417

_tmp9_ = g_strdup ("HP");

3418

_g_free0 (vendor);

3419

vendor = _tmp9_;

3420

}

3421

_tmp10_ = g_strdup_printf ("%s %s", vendor, device_list[i]->model);

3422

_g_free0 (scan_device->label);

3423

scan_device->label = _tmp10_;

3424

_tmp11_ = string_replace (scan_device->label, "_", " ");

3425

_tmp12_ = _tmp11_;

3426

_g_free0 (_tmp12_);

3427

_tmp13_ = _scan_device_ref0 (scan_device);

3428

devices = g_list_append (devices, _tmp13_);

3429

_g_free0 (vendor);

3430

_scan_device_unref0 (scan_device);

3431

}

3432

}

3433

}

3434

devices = g_list_sort (devices, _scanner_compare_devices_gcompare_func);

3435

self->priv->need_redetect = FALSE;

3436

self->priv->state = SCAN_STATE_IDLE;

3437

if (devices != NULL) {

3438

gconstpointer _tmp14_ = NULL;

3439

ScanDevice* _tmp15_;

3440

ScanDevice* device;

3441

gchar* _tmp16_;

3442

_tmp14_ = g_list_nth_data (devices, (guint) 0);

3443

_tmp15_ = _scan_device_ref0 ((ScanDevice*) _tmp14_);

3444

device = _tmp15_;

3445

_tmp16_ = g_strdup (device->name);

3446

_g_free0 (self->priv->default_device);

3447

self->priv->default_device = _tmp16_;

3448

_scan_device_unref0 (device);

3449

} else {

3450

_g_free0 (self->priv->default_device);

3451

self->priv->default_device = NULL;

3452

}

3453

_tmp17_ = devices;

3454

devices = NULL;

3455

_tmp18_ = notify_update_devices_new (_tmp17_);

3456

_tmp19_ = _tmp18_;

3457

scanner_notify (self, (Notify*) _tmp19_);

3458

_notify_unref0 (_tmp19_);

3459

__g_list_free__scan_device_unref0_0 (devices);

3460

}

3461

3462

3463

static gboolean scanner_set_default_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index) {

3464

gboolean result = FALSE;

3465

SANE_Status _tmp0_;

3466

SANE_Status status;

3467

gchar* _tmp1_ = NULL;

3468

gchar* _tmp2_;

3469

g_return_val_if_fail (self != NULL, FALSE);

3470

g_return_val_if_fail (option != NULL, FALSE);

3471

if ((option->cap & SANE_CAP_AUTOMATIC) == 0) {

3472

result = FALSE;

3473

return result;

3474

}

3475

_tmp0_ = sane_control_option (handle, option_index, SANE_ACTION_SET_AUTO, NULL, NULL);

3476

status = _tmp0_;

3477

_tmp1_ = sane_status_to_string (status);

3478

_tmp2_ = _tmp1_;

3479

g_debug ("scanner.vala:372: sane_control_option (%d, SANE_ACTION_SET_AUTO) -> %s", (gint) option_index, _tmp2_);

3480

_g_free0 (_tmp2_);

3481

if (status != SANE_STATUS_GOOD) {

3482

const gchar* _tmp3_ = NULL;

3483

_tmp3_ = sane_strstatus (status);

3484

g_warning ("scanner.vala:374: Error setting default option %s: %s", option->name, _tmp3_);

3485

}

3486

result = status == SANE_STATUS_GOOD;

3487

return result;

3488

}

3489

3490

3491

static void scanner_set_bool_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, gboolean value, gboolean* _result_) {

3492

gboolean _result = FALSE;

3493

SANE_Bool v;

3494

SANE_Status _tmp0_;

3495

SANE_Status status;

3496

const gchar* _tmp1_ = NULL;

3497

const gchar* _tmp2_ = NULL;

3498

gchar* _tmp3_ = NULL;

3499

gchar* _tmp4_;

3500

g_return_if_fail (self != NULL);

3501

g_return_if_fail (option != NULL);

3502

g_return_if_fail (option->type == SANE_TYPE_BOOL);

3503

v = (SANE_Bool) value;

3504

_tmp0_ = sane_control_option (handle, option_index, SANE_ACTION_SET_VALUE, &v, NULL);

3505

status = _tmp0_;

3506

_result = (gboolean) v;

3507

if (value) {

3508

_tmp1_ = "SANE_TRUE";

3509

} else {

3510

_tmp1_ = "SANE_FALSE";

3511

}

3512

if (_result) {

3513

_tmp2_ = "SANE_TRUE";

3514

} else {

3515

_tmp2_ = "SANE_FALSE";

3516

}

3517

_tmp3_ = sane_status_to_string (status);

3518

_tmp4_ = _tmp3_;

3519

g_debug ("scanner.vala:386: sane_control_option (%d, SANE_ACTION_SET_VALUE, %s) " \

3520

"-> (%s, %s)", (gint) option_index, _tmp1_, _tmp4_, _tmp2_);

3521

_g_free0 (_tmp4_);

3522

if (_result_) {

3523

*_result_ = _result;

3524

}

3525

}

3526

3527

3528

static void scanner_set_int_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, gint value, gint* _result_) {

3529

gint _result = 0;

3530

SANE_Int v;

3531

SANE_Status _tmp2_;

3532

SANE_Status status;

3533

gchar* _tmp3_ = NULL;

3534

gchar* _tmp4_;

3535

g_return_if_fail (self != NULL);

3536

g_return_if_fail (option != NULL);

3537

g_return_if_fail (option->type == SANE_TYPE_INT);

3538

v = (SANE_Int) value;

3539

if (option->constraint_type == SANE_CONSTRAINT_RANGE) {

3540

if (option->constraint.range->quant != 0) {

3541

v = v * option->constraint.range->quant;

3542

}

3543

if (v < option->constraint.range->min) {

3544

v = (SANE_Int) option->constraint.range->min;

3545

}

3546

if (v > option->constraint.range->max) {

3547

v = (SANE_Int) option->constraint.range->max;

3548

}

3549

} else {

3550

if (option->constraint_type == SANE_CONSTRAINT_WORD_LIST) {

3551

gint distance;

3552

gint nearest;

3553

distance = G_MAXINT;

3554

nearest = 0;

3555

{

3556

gint i;

3557

i = 0;

3558

{

3559

gboolean _tmp0_;

3560

_tmp0_ = TRUE;

3561

while (TRUE) {

3562

gint x;

3563

gint _tmp1_;

3564

gint d;

3565

if (!_tmp0_) {

3566

i++;

3567

}

3568

_tmp0_ = FALSE;

3569

if (!(i < option->constraint.word_list[0])) {

3570

break;

3571

}

3572

x = (gint) option->constraint.word_list[i + 1];

3573

_tmp1_ = abs (x - v);

3574

d = _tmp1_;

3575

if (d < distance) {

3576

distance = d;

3577

nearest = x;

3578

}

3579

}

3580

}

3581

}

3582

v = (SANE_Int) nearest;

3583

}

3584

}

3585

_tmp2_ = sane_control_option (handle, option_index, SANE_ACTION_SET_VALUE, &v, NULL);

3586

status = _tmp2_;

3587

_tmp3_ = sane_status_to_string (status);

3588

_tmp4_ = _tmp3_;

3589

g_debug ("scanner.vala:422: sane_control_option (%d, SANE_ACTION_SET_VALUE, %d) " \

3590

"-> (%s, %d)", (gint) option_index, value, _tmp4_, (gint) v);

3591

_g_free0 (_tmp4_);

3592

_result = (gint) v;

3593

if (_result_) {

3594

*_result_ = _result;

3595

}

3596

}

3597

3598

3599

static void scanner_set_fixed_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, gdouble value, gdouble* _result_) {

3600

gdouble _result = 0.0;

3601

gdouble v;

3602

SANE_Fixed v_fixed;

3603

SANE_Fixed _tmp6_;

3604

SANE_Status _tmp7_;

3605

SANE_Status status;

3606

gchar* _tmp8_ = NULL;

3607

gchar* _tmp9_;

3608

gdouble _tmp10_;

3609

gdouble _tmp11_;

3610

g_return_if_fail (self != NULL);

3611

g_return_if_fail (option != NULL);

3612

v = value;

3613

g_return_if_fail (option->type == SANE_TYPE_FIXED);

3614

if (option->constraint_type == SANE_CONSTRAINT_RANGE) {

3615

gdouble _tmp0_;

3616

gdouble min;

3617

gdouble _tmp1_;

3618

gdouble max;

3619

_tmp0_ = SANE_UNFIX ((SANE_Fixed) option->constraint.range->min);

3620

min = _tmp0_;

3621

_tmp1_ = SANE_UNFIX ((SANE_Fixed) option->constraint.range->max);

3622

max = _tmp1_;

3623

if (v < min) {

3624

v = min;

3625

}

3626

if (v > max) {

3627

v = max;

3628

}

3629

} else {

3630

if (option->constraint_type == SANE_CONSTRAINT_WORD_LIST) {

3631

gdouble distance;

3632

gdouble nearest;

3633

distance = DBL_MAX;

3634

nearest = 0.0;

3635

{

3636

gint i;

3637

i = 0;

3638

{

3639

gboolean _tmp2_;

3640

_tmp2_ = TRUE;

3641

while (TRUE) {

3642

gdouble _tmp3_;

3643

gdouble x;

3644

gdouble _tmp4_;

3645

if (!_tmp2_) {

3646

i++;

3647

}

3648

_tmp2_ = FALSE;

3649

if (!(i < option->constraint.word_list[0])) {

3650

break;

3651

}

3652

_tmp3_ = SANE_UNFIX ((SANE_Fixed) option->constraint.word_list[i + 1]);

3653

x = _tmp3_;

3654

_tmp4_ = fabs (x - v);

3655

if (_tmp4_ < distance) {

3656

gdouble _tmp5_;

3657

_tmp5_ = fabs (x - v);

3658

distance = _tmp5_;

3659

nearest = x;

3660

}

3661

}

3662

}

3663

}

3664

v = nearest;

3665

}

3666

}

3667

_tmp6_ = SANE_FIX (v);

3668

v_fixed = _tmp6_;

3669

_tmp7_ = sane_control_option (handle, option_index, SANE_ACTION_SET_VALUE, &v_fixed, NULL);

3670

status = _tmp7_;

3671

_tmp8_ = sane_status_to_string (status);

3672

_tmp9_ = _tmp8_;

3673

_tmp10_ = SANE_UNFIX (v_fixed);

3674

g_debug ("scanner.vala:462: sane_control_option (%d, SANE_ACTION_SET_VALUE, %f) " \

3675

"-> (%s, %f)", (gint) option_index, value, _tmp9_, _tmp10_);

3676

_g_free0 (_tmp9_);

3677

_tmp11_ = SANE_UNFIX (v_fixed);

3678

_result = _tmp11_;

3679

if (_result_) {

3680

*_result_ = _result;

3681

}

3682

}

3683

3684

3685

static gchar string_get (const gchar* self, glong index) {

3686

gchar result = '\0';

3687

g_return_val_if_fail (self != NULL, '\0');

3688

result = ((gchar*) self)[index];

3689

return result;

3690

}

3691

3692

3693

static gboolean scanner_set_string_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, const gchar* value, gchar** _result_) {

3694

gchar* _result = NULL;

3695

gboolean result = FALSE;

3696

gchar* _tmp0_ = NULL;

3697

gchar* s;

3698

gint s_length1;

3699

gint _s_size_;

3700

gint i;

3701

SANE_Status _tmp5_;

3702

SANE_Status status;

3703

gchar* _tmp6_;

3704

gchar* _tmp7_ = NULL;

3705

gchar* _tmp8_;

3706

g_return_val_if_fail (self != NULL, FALSE);

3707

g_return_val_if_fail (option != NULL, FALSE);

3708

g_return_val_if_fail (value != NULL, FALSE);

3709

g_return_val_if_fail (option->type == SANE_TYPE_STRING, FALSE);

3710

_tmp0_ = g_new0 (gchar, option->size);

3711

s = _tmp0_;

3712

s_length1 = option->size;

3713

_s_size_ = s_length1;

3714

i = 0;

3715

{

3716

gboolean _tmp1_;

3717

_tmp1_ = TRUE;

3718

while (TRUE) {

3719

gboolean _tmp2_ = FALSE;

3720

gchar _tmp4_;

3721

if (!_tmp1_) {

3722

i++;

3723

}

3724

_tmp1_ = FALSE;

3725

if (i < (option->size - 1)) {

3726

gchar _tmp3_;

3727

_tmp3_ = string_get (value, (glong) i);

3728

_tmp2_ = _tmp3_ != '\0';

3729

} else {

3730

_tmp2_ = FALSE;

3731

}

3732

if (!_tmp2_) {

3733

break;

3734

}

3735

_tmp4_ = string_get (value, (glong) i);

3736

s[i] = _tmp4_;

3737

}

3738

}

3739

s[i] = '\0';

3740

_tmp5_ = sane_control_option (handle, option_index, SANE_ACTION_SET_VALUE, s, NULL);

3741

status = _tmp5_;

3742

_tmp6_ = g_strdup ((const gchar*) s);

3743

_g_free0 (_result);

3744

_result = _tmp6_;

3745

_tmp7_ = sane_status_to_string (status);

3746

_tmp8_ = _tmp7_;

3747

g_debug ("scanner.vala:478: sane_control_option (%d, SANE_ACTION_SET_VALUE, \"%s" \

3748

"\") -> (%s, \"%s\")", (gint) option_index, value, _tmp8_, _result);

3749

_g_free0 (_tmp8_);

3750

result = status == SANE_STATUS_GOOD;

3751

s = (g_free (s), NULL);

3752

if (_result_) {

3753

*_result_ = _result;

3754

} else {

3755

_g_free0 (_result);

3756

}

3757

return result;

3758

}

3759

3760

3761

static gboolean scanner_set_constrained_string_option (Scanner* self, SANE_Handle handle, const SANE_Option_Descriptor* option, SANE_Int option_index, gchar** values, int values_length1, gchar** _result_) {

3762

gchar* _result = NULL;

3763

gboolean result = FALSE;

3764

g_return_val_if_fail (self != NULL, FALSE);

3765

g_return_val_if_fail (option != NULL, FALSE);

3766

g_return_val_if_fail (option->type == SANE_TYPE_STRING, FALSE);

3767

g_return_val_if_fail (option->constraint_type == SANE_CONSTRAINT_STRING_LIST, FALSE);

3768

{

3769

gint i;

3770

i = 0;

3771

{

3772

gboolean _tmp0_;

3773

_tmp0_ = TRUE;

3774

while (TRUE) {

3775

gint j;

3776

if (!_tmp0_) {

3777

i++;

3778

}

3779

_tmp0_ = FALSE;

3780

if (!(values[i] != NULL)) {

3781

break;

3782

}

3783

j = 0;

3784

{

3785

gboolean _tmp1_;

3786

_tmp1_ = TRUE;

3787

while (TRUE) {

3788

if (!_tmp1_) {

3789

j++;

3790

}

3791

_tmp1_ = FALSE;

3792

if (!(option->constraint.string_list[j] != NULL)) {

3793

break;

3794

}

3795

if (g_strcmp0 (values[i], option->constraint.string_list[j]) == 0) {

3796

break;

3797

}

3798

}

3799

}

3800

if (option->constraint.string_list[j] != NULL) {

3801

gchar* _tmp2_ = NULL;

3802

gboolean _tmp3_;

3803

_tmp3_ = scanner_set_string_option (self, handle, option, option_index, values[i], &_tmp2_);

3804

_g_free0 (_result);

3805

_result = _tmp2_;

3806

result = _tmp3_;

3807

if (_result_) {

3808

*_result_ = _result;

3809

} else {

3810

_g_free0 (_result);

3811

}

3812

return result;

3813

}

3814

}

3815

}

3816

}

3817

result = FALSE;

3818

if (_result_) {

3819

*_result_ = _result;

3820

} else {

3821

_g_free0 (_result);

3822

}

3823

return result;

3824

}

3825

3826

3827

static void scanner_log_option (Scanner* self, SANE_Int index, const SANE_Option_Descriptor* option) {

3828

gchar* _tmp0_ = NULL;

3829

gchar* s;

3830

gchar* _tmp16_ = NULL;

3831

gchar* _tmp17_;

3832

gchar* _tmp18_;

3833

SANE_Int cap;

3834

g_return_if_fail (self != NULL);

3835

g_return_if_fail (option != NULL);

3836

_tmp0_ = g_strdup_printf ("Option %d:", (gint) index);

3837

s = _tmp0_;

3838

if (g_strcmp0 (option->name, "") != 0) {

3839

gchar* _tmp1_ = NULL;

3840

gchar* _tmp2_;

3841

gchar* _tmp3_;

3842

_tmp1_ = g_strdup_printf (" name='%s'", option->name);

3843

_tmp2_ = _tmp1_;

3844

_tmp3_ = g_strconcat (s, _tmp2_, NULL);

3845

_g_free0 (s);

3846

s = _tmp3_;

3847

_g_free0 (_tmp2_);

3848

}

3849

if (g_strcmp0 (option->title, "") != 0) {

3850

gchar* _tmp4_ = NULL;

3851

gchar* _tmp5_;

3852

gchar* _tmp6_;

3853

_tmp4_ = g_strdup_printf (" title='%s'", option->title);

3854

_tmp5_ = _tmp4_;

3855

_tmp6_ = g_strconcat (s, _tmp5_, NULL);

3856

_g_free0 (s);

3857

s = _tmp6_;

3858

_g_free0 (_tmp5_);

3859

}

3860

switch (option->type) {

3861

case SANE_TYPE_BOOL:

3862

{

3863

gchar* _tmp7_;

3864

_tmp7_ = g_strconcat (s, " type=bool", NULL);

3865

_g_free0 (s);

3866

s = _tmp7_;

3867

break;

3868

}

3869

case SANE_TYPE_INT:

3870

{

3871

gchar* _tmp8_;

3872

_tmp8_ = g_strconcat (s, " type=int", NULL);

3873

_g_free0 (s);

3874

s = _tmp8_;

3875

break;

3876

}

3877

case SANE_TYPE_FIXED:

3878

{

3879

gchar* _tmp9_;

3880

_tmp9_ = g_strconcat (s, " type=fixed", NULL);

3881

_g_free0 (s);

3882

s = _tmp9_;

3883

break;

3884

}

3885

case SANE_TYPE_STRING:

3886

{

3887

gchar* _tmp10_;

3888

_tmp10_ = g_strconcat (s, " type=string", NULL);

3889

_g_free0 (s);

3890

s = _tmp10_;

3891

break;

3892

}

3893

case SANE_TYPE_BUTTON:

3894

{

3895

gchar* _tmp11_;

3896

_tmp11_ = g_strconcat (s, " type=button", NULL);

3897

_g_free0 (s);

3898

s = _tmp11_;

3899

break;

3900

}

3901

case SANE_TYPE_GROUP:

3902

{

3903

gchar* _tmp12_;

3904

_tmp12_ = g_strconcat (s, " type=group", NULL);

3905

_g_free0 (s);

3906

s = _tmp12_;

3907

break;

3908

}

3909

default:

3910

{

3911

gchar* _tmp13_ = NULL;

3912

gchar* _tmp14_;

3913

gchar* _tmp15_;

3914

_tmp13_ = g_strdup_printf (" type=%d", (gint) option->type);

3915

_tmp14_ = _tmp13_;

3916

_tmp15_ = g_strconcat (s, _tmp14_, NULL);

3917

_g_free0 (s);

3918

s = _tmp15_;

3919

_g_free0 (_tmp14_);

3920

break;

3921

}

3922

}

3923

_tmp16_ = g_strdup_printf (" size=%d", (gint) option->size);

3924

_tmp17_ = _tmp16_;

3925

_tmp18_ = g_strconcat (s, _tmp17_, NULL);

3926

_g_free0 (s);

3927

s = _tmp18_;

3928

_g_free0 (_tmp17_);

3929

switch (option->unit) {

3930

case SANE_UNIT_NONE:

3931

{

3932

break;

3933

}

3934

case SANE_UNIT_PIXEL:

3935

{

3936

gchar* _tmp19_;

3937

_tmp19_ = g_strconcat (s, " unit=pixels", NULL);

3938

_g_free0 (s);

3939

s = _tmp19_;

3940

break;

3941

}

3942

case SANE_UNIT_BIT:

3943

{

3944

gchar* _tmp20_;

3945

_tmp20_ = g_strconcat (s, " unit=bits", NULL);

3946

_g_free0 (s);

3947

s = _tmp20_;

3948

break;

3949

}

3950

case SANE_UNIT_MM:

3951

{

3952

gchar* _tmp21_;

3953

_tmp21_ = g_strconcat (s, " unit=mm", NULL);

3954

_g_free0 (s);

3955

s = _tmp21_;

3956

break;

3957

}

3958

case SANE_UNIT_DPI:

3959

{

3960

gchar* _tmp22_;

3961

_tmp22_ = g_strconcat (s, " unit=dpi", NULL);

3962

_g_free0 (s);

3963

s = _tmp22_;

3964

break;

3965

}

3966

case SANE_UNIT_PERCENT:

3967

{

3968

gchar* _tmp23_;

3969

_tmp23_ = g_strconcat (s, " unit=percent", NULL);

3970

_g_free0 (s);

3971

s = _tmp23_;

3972

break;

3973

}

3974

case SANE_UNIT_MICROSECOND:

3975

{

3976

gchar* _tmp24_;

3977

_tmp24_ = g_strconcat (s, " unit=microseconds", NULL);

3978

_g_free0 (s);

3979

s = _tmp24_;

3980

break;

3981

}

3982

default:

3983

{

3984

gchar* _tmp25_ = NULL;

3985

gchar* _tmp26_;

3986

gchar* _tmp27_;

3987

_tmp25_ = g_strdup_printf (" unit=%d", (gint) option->unit);

3988

_tmp26_ = _tmp25_;

3989

_tmp27_ = g_strconcat (s, _tmp26_, NULL);

3990

_g_free0 (s);

3991

s = _tmp27_;

3992

_g_free0 (_tmp26_);

3993

break;

3994

}

3995

}

3996

switch (option->constraint_type) {

3997

case SANE_CONSTRAINT_RANGE:

3998

{

3999

if (option->type == SANE_TYPE_FIXED) {

4000

gdouble _tmp28_;

4001

gdouble _tmp29_;

4002

gchar* _tmp30_ = NULL;

4003

gchar* _tmp31_;

4004

gchar* _tmp32_;

4005

_tmp28_ = SANE_UNFIX ((SANE_Fixed) option->constraint.range->min);

4006

_tmp29_ = SANE_UNFIX ((SANE_Fixed) option->constraint.range->max);

4007

_tmp30_ = g_strdup_printf (" min=%f, max=%f, quant=%d", _tmp28_, _tmp29_, (gint) option->constraint.range->quant);

4008

_tmp31_ = _tmp30_;

4009

_tmp32_ = g_strconcat (s, _tmp31_, NULL);

4010

_g_free0 (s);

4011

s = _tmp32_;

4012

_g_free0 (_tmp31_);

4013

} else {

4014

gchar* _tmp33_ = NULL;

4015

gchar* _tmp34_;

4016

gchar* _tmp35_;

4017

_tmp33_ = g_strdup_printf (" min=%d, max=%d, quant=%d", (gint) option->constraint.range->min, (gint) option->constraint.range->max, (gint) option->constraint.range->quant);

4018

_tmp34_ = _tmp33_;

4019

_tmp35_ = g_strconcat (s, _tmp34_, NULL);

4020

_g_free0 (s);

4021

s = _tmp35_;

4022

_g_free0 (_tmp34_);

4023

}

4024

break;

4025

}

4026

case SANE_CONSTRAINT_WORD_LIST:

4027

{

4028

gchar* _tmp36_;

4029

gchar* _tmp46_;

4030

_tmp36_ = g_strconcat (s, " values=[", NULL);

4031

_g_free0 (s);

4032

s = _tmp36_;

4033

{

4034

gint i;

4035

i = 0;

4036

{

4037

gboolean _tmp37_;

4038

_tmp37_ = TRUE;

4039

while (TRUE) {

4040

if (!_tmp37_) {

4041

i++;

4042

}

4043

_tmp37_ = FALSE;

4044

if (!(i < option->constraint.word_list[0])) {

4045

break;

4046

}

4047

if (i != 0) {

4048

gchar* _tmp38_;

4049

_tmp38_ = g_strconcat (s, ", ", NULL);

4050

_g_free0 (s);

4051

s = _tmp38_;

4052

}

4053

if (option->type == SANE_TYPE_INT) {

4054

gchar* _tmp39_ = NULL;

4055

gchar* _tmp40_;

4056

gchar* _tmp41_;

4057

_tmp39_ = g_strdup_printf ("%d", (gint) option->constraint.word_list[i + 1]);

4058

_tmp40_ = _tmp39_;

4059

_tmp41_ = g_strconcat (s, _tmp40_, NULL);

4060

_g_free0 (s);

4061

s = _tmp41_;

4062

_g_free0 (_tmp40_);

4063

} else {

4064

gdouble _tmp42_;

4065

gchar* _tmp43_ = NULL;

4066

gchar* _tmp44_;

4067

gchar* _tmp45_;

4068

_tmp42_ = SANE_UNFIX ((SANE_Fixed) option->constraint.word_list[i + 1]);

4069

_tmp43_ = g_strdup_printf ("%f", _tmp42_);

4070

_tmp44_ = _tmp43_;

4071

_tmp45_ = g_strconcat (s, _tmp44_, NULL);

4072

_g_free0 (s);

4073

s = _tmp45_;

4074

_g_free0 (_tmp44_);

4075

}

4076

}

4077

}

4078

}

4079

_tmp46_ = g_strconcat (s, "]", NULL);

4080

_g_free0 (s);

4081

s = _tmp46_;

4082

break;

4083

}

4084

case SANE_CONSTRAINT_STRING_LIST:

4085

{

4086

gchar* _tmp47_;

4087

gchar* _tmp53_;

4088

_tmp47_ = g_strconcat (s, " values=[", NULL);

4089

_g_free0 (s);

4090

s = _tmp47_;

4091

{

4092

gint i;

4093

i = 0;

4094

{

4095

gboolean _tmp48_;

4096

_tmp48_ = TRUE;

4097

while (TRUE) {

4098

gchar* _tmp50_ = NULL;

4099

gchar* _tmp51_;

4100

gchar* _tmp52_;

4101

if (!_tmp48_) {

4102

i++;

4103

}

4104

_tmp48_ = FALSE;

4105

if (!(option->constraint.string_list[i] != NULL)) {

4106

break;

4107

}

4108

if (i != 0) {

4109

gchar* _tmp49_;

4110

_tmp49_ = g_strconcat (s, ", ", NULL);

4111

_g_free0 (s);

4112

s = _tmp49_;

4113

}

4114

_tmp50_ = g_strdup_printf ("\"%s\"", option->constraint.string_list[i]);

4115

_tmp51_ = _tmp50_;

4116

_tmp52_ = g_strconcat (s, _tmp51_, NULL);

4117

_g_free0 (s);

4118

s = _tmp52_;

4119

_g_free0 (_tmp51_);

4120

}

4121

}

4122

}

4123

_tmp53_ = g_strconcat (s, "]", NULL);

4124

_g_free0 (s);

4125

s = _tmp53_;

4126

break;

4127

}

4128

default:

4129

{

4130

break;

4131

}

4132

}

4133

cap = option->cap;

4134

if (cap != 0) {

4135

gchar* _tmp54_;

4136

_tmp54_ = g_strconcat (s, " cap=", NULL);

4137

_g_free0 (s);

4138

s = _tmp54_;

4139

if ((cap & SANE_CAP_SOFT_SELECT) != 0) {

4140

gchar* _tmp56_;

4141

if (g_strcmp0 (s, "") != 0) {

4142

gchar* _tmp55_;

4143

_tmp55_ = g_strconcat (s, ",", NULL);

4144

_g_free0 (s);

4145

s = _tmp55_;

4146

}

4147

_tmp56_ = g_strconcat (s, "soft-select", NULL);

4148

_g_free0 (s);

4149

s = _tmp56_;

4150

cap = cap & (~SANE_CAP_SOFT_SELECT);

4151

}

4152

if ((cap & SANE_CAP_HARD_SELECT) != 0) {

4153

gchar* _tmp58_;

4154

if (g_strcmp0 (s, "") != 0) {

4155

gchar* _tmp57_;

4156

_tmp57_ = g_strconcat (s, ",", NULL);

4157

_g_free0 (s);

4158

s = _tmp57_;

4159

}

4160

_tmp58_ = g_strconcat (s, "hard-select", NULL);

4161

_g_free0 (s);

4162

s = _tmp58_;

4163

cap = cap & (~SANE_CAP_HARD_SELECT);

4164

}

4165

if ((cap & SANE_CAP_SOFT_DETECT) != 0) {

4166

gchar* _tmp60_;

4167

if (g_strcmp0 (s, "") != 0) {

4168

gchar* _tmp59_;

4169

_tmp59_ = g_strconcat (s, ",", NULL);

4170

_g_free0 (s);

4171

s = _tmp59_;

4172

}

4173

_tmp60_ = g_strconcat (s, "soft-detect", NULL);

4174

_g_free0 (s);

4175

s = _tmp60_;

4176

cap = cap & (~SANE_CAP_SOFT_DETECT);

4177

}

4178

if ((cap & SANE_CAP_EMULATED) != 0) {

4179

gchar* _tmp62_;

4180

if (g_strcmp0 (s, "") != 0) {

4181

gchar* _tmp61_;

4182

_tmp61_ = g_strconcat (s, ",", NULL);

4183

_g_free0 (s);

4184

s = _tmp61_;

4185

}

4186

_tmp62_ = g_strconcat (s, "emulated", NULL);

4187

_g_free0 (s);

4188

s = _tmp62_;

4189

cap = cap & (~SANE_CAP_EMULATED);

4190

}

4191

if ((cap & SANE_CAP_AUTOMATIC) != 0) {

4192

gchar* _tmp64_;

4193

if (g_strcmp0 (s, "") != 0) {

4194

gchar* _tmp63_;

4195

_tmp63_ = g_strconcat (s, ",", NULL);

4196

_g_free0 (s);

4197

s = _tmp63_;

4198

}

4199

_tmp64_ = g_strconcat (s, "automatic", NULL);

4200

_g_free0 (s);

4201

s = _tmp64_;

4202

cap = cap & (~SANE_CAP_AUTOMATIC);

4203

}

4204

if ((cap & SANE_CAP_INACTIVE) != 0) {

4205

gchar* _tmp66_;

4206

if (g_strcmp0 (s, "") != 0) {

4207

gchar* _tmp65_;

4208

_tmp65_ = g_strconcat (s, ",", NULL);

4209

_g_free0 (s);

4210

s = _tmp65_;

4211

}

4212

_tmp66_ = g_strconcat (s, "inactive", NULL);

4213

_g_free0 (s);

4214

s = _tmp66_;

4215

cap = cap & (~SANE_CAP_INACTIVE);

4216

}

4217

if ((cap & SANE_CAP_ADVANCED) != 0) {

4218

gchar* _tmp68_;

4219

if (g_strcmp0 (s, "") != 0) {

4220

gchar* _tmp67_;

4221

_tmp67_ = g_strconcat (s, ",", NULL);

4222

_g_free0 (s);

4223

s = _tmp67_;

4224

}

4225

_tmp68_ = g_strconcat (s, "advanced", NULL);

4226

_g_free0 (s);

4227

s = _tmp68_;

4228

cap = cap & (~SANE_CAP_ADVANCED);

4229

}

4230

if (cap != 0) {

4231

gchar* _tmp70_ = NULL;

4232

gchar* _tmp71_;

4233

gchar* _tmp72_;

4234

if (g_strcmp0 (s, "") != 0) {

4235

gchar* _tmp69_;

4236

_tmp69_ = g_strconcat (s, ",", NULL);

4237

_g_free0 (s);

4238

s = _tmp69_;

4239

}

4240

_tmp70_ = g_strdup_printf ("%x", (guint) cap);

4241

_tmp71_ = _tmp70_;

4242

_tmp72_ = g_strconcat (s, _tmp71_, NULL);

4243

_g_free0 (s);

4244

s = _tmp72_;

4245

_g_free0 (_tmp71_);

4246

}

4247

}

4248

g_debug ("scanner.vala:665: %s", s);

4249

if (option->desc != NULL) {

4250

g_debug ("scanner.vala:668: Description: %s", option->desc);

4251

}

4252

_g_free0 (s);

4253

}

4254

4255

4256

static void scanner_authorization_cb (const gchar* resource, gchar* username, int username_length1, gchar* password, int password_length1) {

4257

NotifyRequestAuthorization* _tmp0_ = NULL;

4258

NotifyRequestAuthorization* _tmp1_;

4259

gpointer _tmp2_ = NULL;

4260

Credentials* credentials;

4261

g_return_if_fail (resource != NULL);

4262

_tmp0_ = notify_request_authorization_new (resource);

4263

_tmp1_ = _tmp0_;

4264

scanner_notify (scanner_scanner_object, (Notify*) _tmp1_);

4265

_notify_unref0 (_tmp1_);

4266

_tmp2_ = g_async_queue_pop (scanner_scanner_object->priv->authorize_queue);

4267

credentials = (Credentials*) _tmp2_;

4268

{

4269

gint i;

4270

i = 0;

4271

{

4272

gboolean _tmp3_;

4273

_tmp3_ = TRUE;

4274

while (TRUE) {

4275

gboolean _tmp4_ = FALSE;

4276

gchar _tmp5_;

4277

gchar _tmp6_;

4278

if (!_tmp3_) {

4279

i++;

4280

}

4281

_tmp3_ = FALSE;

4282

_tmp5_ = string_get (credentials->username, (glong) i);

4283

if (_tmp5_ != '\0') {

4284

_tmp4_ = i < SANE_MAX_USERNAME_LEN;

4285

} else {

4286

_tmp4_ = FALSE;

4287

}

4288

if (!_tmp4_) {

4289

break;

4290

}

4291

_tmp6_ = string_get (credentials->username, (glong) i);

4292

username[i] = _tmp6_;

4293

}

4294

}

4295

}

4296

{

4297

gint i;

4298

i = 0;

4299

{

4300

gboolean _tmp7_;

4301

_tmp7_ = TRUE;

4302

while (TRUE) {

4303

gboolean _tmp8_ = FALSE;

4304

gchar _tmp9_;

4305

gchar _tmp10_;

4306

if (!_tmp7_) {

4307

i++;

4308

}

4309

_tmp7_ = FALSE;

4310

_tmp9_ = string_get (credentials->password, (glong) i);

4311

if (_tmp9_ != '\0') {

4312

_tmp8_ = i < SANE_MAX_USERNAME_LEN;

4313

} else {

4314

_tmp8_ = FALSE;

4315

}

4316

if (!_tmp8_) {

4317

break;

4318

}

4319

_tmp10_ = string_get (credentials->password, (glong) i);

4320

password[i] = _tmp10_;

4321

}

4322

}

4323

}

4324

_credentials_unref0 (credentials);

4325

}

4326

4327

4328

static gpointer _credentials_ref0 (gpointer self) {

4329

return self ? credentials_ref (self) : NULL;

4330

}

4331

4332

4333

void scanner_authorize (Scanner* self, const gchar* username, const gchar* password) {

4334

Credentials* _tmp0_ = NULL;

4335

Credentials* credentials;

4336

gchar* _tmp1_;

4337

gchar* _tmp2_;

4338

Credentials* _tmp3_;

4339

g_return_if_fail (self != NULL);

4340

g_return_if_fail (username != NULL);

4341

g_return_if_fail (password != NULL);

4342

_tmp0_ = credentials_new ();

4343

credentials = _tmp0_;

4344

_tmp1_ = g_strdup (username);

4345

_g_free0 (credentials->username);

4346

credentials->username = _tmp1_;

4347

_tmp2_ = g_strdup (password);

4348

_g_free0 (credentials->password);

4349

credentials->password = _tmp2_;

4350

_tmp3_ = _credentials_ref0 (credentials);

4351

g_async_queue_push (self->priv->authorize_queue, _tmp3_);

4352

_credentials_unref0 (credentials);

4353

}

4354

4355

4356

static void scanner_close_device (Scanner* self) {

4357

g_return_if_fail (self != NULL);

4358

if (self->priv->have_handle) {

4359

sane_cancel (self->priv->handle);

4360

g_debug ("scanner.vala:695: sane_cancel ()");

4361

sane_close (self->priv->handle);

4362

g_debug ("scanner.vala:698: sane_close ()");

4363

self->priv->have_handle = FALSE;

4364

}

4365

self->priv->buffer = (g_free (self->priv->buffer), NULL);

4366

self->priv->buffer = NULL;

4367

self->priv->buffer_length1 = 0;

4368

self->priv->_buffer_size_ = self->priv->buffer_length1;

4369

__g_list_free__scan_job_unref0_0 (self->priv->job_queue);

4370

self->priv->job_queue = NULL;

4371

scanner_set_scanning (self, FALSE);

4372

}

4373

4374

4375

static void scanner_fail_scan (Scanner* self, gint error_code, const gchar* error_string) {

4376

NotifyScanFailed* _tmp0_ = NULL;

4377

NotifyScanFailed* _tmp1_;

4378

g_return_if_fail (self != NULL);

4379

g_return_if_fail (error_string != NULL);

4380

scanner_close_device (self);

4381

self->priv->state = SCAN_STATE_IDLE;

4382

_tmp0_ = notify_scan_failed_new (error_code, error_string);

4383

_tmp1_ = _tmp0_;

4384

scanner_notify (self, (Notify*) _tmp1_);

4385

_notify_unref0 (_tmp1_);

4386

}

4387

4388

4389

static gpointer _request_ref0 (gpointer self) {

4390

return self ? request_ref (self) : NULL;

4391

}

4392

4393

4394

static gpointer _scan_job_ref0 (gpointer self) {

4395

return self ? scan_job_ref (self) : NULL;

4396

}

4397

4398

4399

static gboolean scanner_handle_requests (Scanner* self) {

4400

gboolean result = FALSE;

4401

gboolean _tmp0_ = FALSE;

4402

gint request_count;

4403

g_return_val_if_fail (self != NULL, FALSE);

4404

if (self->priv->state == SCAN_STATE_IDLE) {

4405

_tmp0_ = self->priv->need_redetect;

4406

} else {

4407

_tmp0_ = FALSE;

4408

}

4409

if (_tmp0_) {

4410

self->priv->state = SCAN_STATE_REDETECT;

4411

}

4412

request_count = 0;

4413

while (TRUE) {

4414

Request* request = NULL;

4415

gboolean _tmp1_ = FALSE;

4416

gboolean _tmp2_ = FALSE;

4417

if (self->priv->state == SCAN_STATE_IDLE) {

4418

_tmp2_ = request_count == 0;

4419

} else {

4420

_tmp2_ = FALSE;

4421

}

4422

if (_tmp2_) {

4423

_tmp1_ = TRUE;

4424

} else {

4425

gint _tmp3_;

4426

_tmp3_ = g_async_queue_length (self->priv->request_queue);

4427

_tmp1_ = _tmp3_ > 0;

4428

}

4429

if (_tmp1_) {

4430

gpointer _tmp4_ = NULL;

4431

_tmp4_ = g_async_queue_pop (self->priv->request_queue);

4432

_request_unref0 (request);

4433

request = (Request*) _tmp4_;

4434

} else {

4435

result = TRUE;

4436

_request_unref0 (request);

4437

return result;

4438

}

4439

g_debug ("scanner.vala:732: Processing request");

4440

request_count++;

4441

if (IS_REQUEST_START_SCAN (request)) {

4442

RequestStartScan* _tmp5_;

4443

RequestStartScan* r;

4444

ScanJob* _tmp6_;

4445

_tmp5_ = _request_ref0 (REQUEST_START_SCAN (request));

4446

r = _tmp5_;

4447

_tmp6_ = _scan_job_ref0 (r->job);

4448

self->priv->job_queue = g_list_append (self->priv->job_queue, _tmp6_);

4449

_request_unref0 (r);

4450

} else {

4451

if (IS_REQUEST_CANCEL (request)) {

4452

scanner_fail_scan (self, (gint) SANE_STATUS_CANCELLED, "Scan cancelled - do not report this error");

4453

} else {

4454

if (IS_REQUEST_QUIT (request)) {

4455

scanner_close_device (self);

4456

result = FALSE;

4457

_request_unref0 (request);

4458

return result;

4459

}

4460

}

4461

}

4462

_request_unref0 (request);

4463

}

4464

}

4465

4466

4467

static void scanner_do_open (Scanner* self) {

4468

ScanJob* _tmp0_;

4469

ScanJob* job;

4470

gboolean _tmp1_ = FALSE;

4471

SANE_Handle _tmp4_;

4472

SANE_Status _tmp5_;

4473

SANE_Status status;

4474

gchar* _tmp6_ = NULL;

4475

gchar* _tmp7_;

4476

gchar* _tmp10_;

4477

g_return_if_fail (self != NULL);

4478

_tmp0_ = _scan_job_ref0 (SCAN_JOB ((ScanJob*) self->priv->job_queue->data));

4479

job = _tmp0_;

4480

self->priv->line_count = 0;

4481

self->priv->pass_number = 0;

4482

self->priv->page_number = 0;

4483

self->priv->notified_page = -1;

4484

self->priv->option_index = (SANE_Int) 0;

4485

self->priv->br_x_option_index = (SANE_Int) 0;

4486

self->priv->br_y_option_index = (SANE_Int) 0;

4487

if (job->device == NULL) {

4488

_tmp1_ = self->priv->default_device != NULL;

4489

} else {

4490

_tmp1_ = FALSE;

4491

}

4492

if (_tmp1_) {

4493

gchar* _tmp2_;

4494

_tmp2_ = g_strdup (self->priv->default_device);

4495

_g_free0 (job->device);

4496

job->device = _tmp2_;

4497

}

4498

if (job->device == NULL) {

4499

const gchar* _tmp3_ = NULL;

4500

g_warning ("scanner.vala:769: No scan device available");

4501

_tmp3_ = _ ("No scanners available. Please connect a scanner.");

4502

scanner_fail_scan (self, 0, _tmp3_);

4503

_scan_job_unref0 (job);

4504

return;

4505

}

4506

if (self->priv->have_handle) {

4507

if (g_strcmp0 (self->priv->current_device, job->device) == 0) {

4508

self->priv->state = SCAN_STATE_GET_OPTION;

4509

_scan_job_unref0 (job);

4510

return;

4511

}

4512

sane_close (self->priv->handle);

4513

g_debug ("scanner.vala:786: sane_close ()");

4514

self->priv->have_handle = FALSE;

4515

}

4516

_g_free0 (self->priv->current_device);

4517

self->priv->current_device = NULL;

4518

self->priv->have_handle = FALSE;

4519

_tmp5_ = sane_open (job->device, &_tmp4_);

4520

self->priv->handle = _tmp4_;

4521

status = _tmp5_;

4522

_tmp6_ = sane_status_to_string (status);

4523

_tmp7_ = _tmp6_;

4524

g_debug ("scanner.vala:794: sane_open (\"%s\") -> %s", job->device, _tmp7_);

4525

_g_free0 (_tmp7_);

4526

if (status != SANE_STATUS_GOOD) {

4527

const gchar* _tmp8_ = NULL;

4528

const gchar* _tmp9_ = NULL;

4529

_tmp8_ = sane_strstatus (status);

4530

g_warning ("scanner.vala:798: Unable to get open device: %s", _tmp8_);

4531

_tmp9_ = _ ("Unable to connect to scanner");

4532

scanner_fail_scan (self, (gint) status, _tmp9_);

4533

_scan_job_unref0 (job);

4534

return;

4535

}

4536

self->priv->have_handle = TRUE;

4537

_tmp10_ = g_strdup (job->device);

4538

_g_free0 (self->priv->current_device);

4539

self->priv->current_device = _tmp10_;

4540

self->priv->state = SCAN_STATE_GET_OPTION;

4541

_scan_job_unref0 (job);

4542

}

4543

4544

4545

static void scanner_do_get_option (Scanner* self) {

4546

ScanJob* _tmp0_;

4547

ScanJob* job;

4548

const SANE_Option_Descriptor* _tmp1_ = NULL;

4549

const SANE_Option_Descriptor* option;

4550

SANE_Int index;

4551

g_return_if_fail (self != NULL);

4552

_tmp0_ = _scan_job_ref0 (SCAN_JOB ((ScanJob*) self->priv->job_queue->data));

4553

job = _tmp0_;

4554

_tmp1_ = sane_get_option_descriptor (self->priv->handle, self->priv->option_index);

4555

option = _tmp1_;

4556

g_debug ("scanner.vala:815: sane_get_option_descriptor (%d)", (gint) self->priv->option_index);

4557

index = self->priv->option_index;

4558

self->priv->option_index++;

4559

if (option == NULL) {

4560

if (self->priv->br_x_option_index != 0) {

4561

const SANE_Option_Descriptor* _tmp2_ = NULL;

4562

_tmp2_ = sane_get_option_descriptor (self->priv->handle, self->priv->br_x_option_index);

4563

option = _tmp2_;

4564

g_debug ("scanner.vala:825: sane_get_option_descriptor (%d)", (gint) self->priv->br_x_option_index);

4565

if (option->constraint_type == SANE_CONSTRAINT_RANGE) {

4566

if (option->type == SANE_TYPE_FIXED) {

4567

gdouble _tmp3_;

4568

_tmp3_ = SANE_UNFIX ((SANE_Fixed) option->constraint.range->max);

4569

scanner_set_fixed_option (self, self->priv->handle, option, self->priv->br_x_option_index, _tmp3_, NULL);

4570

} else {

4571

scanner_set_int_option (self, self->priv->handle, option, self->priv->br_x_option_index, (gint) option->constraint.range->max, NULL);

4572

}

4573

}

4574

}

4575

if (self->priv->br_y_option_index != 0) {

4576

const SANE_Option_Descriptor* _tmp4_ = NULL;

4577

_tmp4_ = sane_get_option_descriptor (self->priv->handle, self->priv->br_y_option_index);

4578

option = _tmp4_;

4579

g_debug ("scanner.vala:837: sane_get_option_descriptor (%d)", (gint) self->priv->br_y_option_index);

4580

if (option->constraint_type == SANE_CONSTRAINT_RANGE) {

4581

if (option->type == SANE_TYPE_FIXED) {

4582

gdouble _tmp5_;

4583

_tmp5_ = SANE_UNFIX ((SANE_Fixed) option->constraint.range->max);

4584

scanner_set_fixed_option (self, self->priv->handle, option, self->priv->br_y_option_index, _tmp5_, NULL);

4585

} else {

4586

scanner_set_int_option (self, self->priv->handle, option, self->priv->br_y_option_index, (gint) option->constraint.range->max, NULL);

4587

}

4588

}

4589

}

4590

self->priv->state = SCAN_STATE_START;

4591

_scan_job_unref0 (job);

4592

return;

4593

}

4594

scanner_log_option (self, index, option);

4595

if (option->type == SANE_TYPE_GROUP) {

4596

_scan_job_unref0 (job);

4597

return;

4598

}

4599

if ((option->cap & SANE_CAP_INACTIVE) != 0) {

4600

_scan_job_unref0 (job);

4601

return;

4602

}

4603

if (option->name == NULL) {

4604

_scan_job_unref0 (job);

4605

return;

4606

}

4607

if (g_strcmp0 (option->name, SANE_NAME_SCAN_RESOLUTION) == 0) {

4608

if (option->type == SANE_TYPE_FIXED) {

4609

gdouble _tmp6_;

4610

scanner_set_fixed_option (self, self->priv->handle, option, index, job->dpi, &_tmp6_);

4611

job->dpi = _tmp6_;

4612

} else {

4613

gint dpi = 0;

4614

gint _tmp7_;

4615

scanner_set_int_option (self, self->priv->handle, option, index, (gint) job->dpi, &_tmp7_);

4616

dpi = _tmp7_;

4617

job->dpi = (gdouble) dpi;

4618

}

4619

} else {

4620

if (g_strcmp0 (option->name, SANE_NAME_SCAN_SOURCE) == 0) {

4621

gchar* _tmp8_;

4622

const gchar* _tmp9_ = NULL;

4623

gchar* _tmp10_;

4624

gchar* _tmp11_;

4625

const gchar* _tmp12_ = NULL;

4626

gchar* _tmp13_;

4627

gchar* _tmp14_;

4628

gchar* _tmp15_;

4629

const gchar* _tmp16_ = NULL;

4630

gchar* _tmp17_;

4631

gchar** _tmp18_ = NULL;

4632

gchar** flatbed_sources;

4633

gint flatbed_sources_length1;

4634

gint _flatbed_sources_size_;

4635

gchar* _tmp19_;

4636

const gchar* _tmp20_ = NULL;

4637

gchar* _tmp21_;

4638

gchar* _tmp22_;

4639

gchar* _tmp23_;

4640

gchar* _tmp24_;

4641

gchar** _tmp25_ = NULL;

4642

gchar** adf_sources;

4643

gint adf_sources_length1;

4644

gint _adf_sources_size_;

4645

gchar* _tmp26_;

4646

const gchar* _tmp27_ = NULL;

4647

gchar* _tmp28_;

4648

gchar** _tmp29_ = NULL;

4649

gchar** adf_front_sources;

4650

gint adf_front_sources_length1;

4651

gint _adf_front_sources_size_;

4652

gchar* _tmp30_;

4653

const gchar* _tmp31_ = NULL;

4654

gchar* _tmp32_;

4655

gchar** _tmp33_ = NULL;

4656

gchar** adf_back_sources;

4657

gint adf_back_sources_length1;

4658

gint _adf_back_sources_size_;

4659

gchar* _tmp34_;

4660

const gchar* _tmp35_ = NULL;

4661

gchar* _tmp36_;

4662

gchar** _tmp37_ = NULL;

4663

gchar** adf_duplex_sources;

4664

gint adf_duplex_sources_length1;

4665

gint _adf_duplex_sources_size_;

4666

_tmp8_ = g_strdup ("Auto");

4667

_tmp9_ = SANE_I18N ("Auto");

4668

_tmp10_ = g_strdup (_tmp9_);

4669

_tmp11_ = g_strdup ("Flatbed");

4670

_tmp12_ = SANE_I18N ("Flatbed");

4671

_tmp13_ = g_strdup (_tmp12_);

4672

_tmp14_ = g_strdup ("FlatBed");

4673

_tmp15_ = g_strdup ("Normal");

4674

_tmp16_ = SANE_I18N ("Normal");

4675

_tmp17_ = g_strdup (_tmp16_);

4676

_tmp18_ = g_new0 (gchar*, 7 + 1);

4677

_tmp18_[0] = _tmp8_;

4678

_tmp18_[1] = _tmp10_;

4679

_tmp18_[2] = _tmp11_;

4680

_tmp18_[3] = _tmp13_;

4681

_tmp18_[4] = _tmp14_;

4682

_tmp18_[5] = _tmp15_;

4683

_tmp18_[6] = _tmp17_;

4684

flatbed_sources = _tmp18_;

4685

flatbed_sources_length1 = 7;

4686

_flatbed_sources_size_ = flatbed_sources_length1;

4687

_tmp19_ = g_strdup ("Automatic Document Feeder");

4688

_tmp20_ = SANE_I18N ("Automatic Document Feeder");

4689

_tmp21_ = g_strdup (_tmp20_);

4690

_tmp22_ = g_strdup ("ADF");

4691

_tmp23_ = g_strdup ("Automatic Document Feeder(left aligned)");

4692

_tmp24_ = g_strdup ("Automatic Document Feeder(centrally aligned)");

4693

_tmp25_ = g_new0 (gchar*, 5 + 1);

4694

_tmp25_[0] = _tmp19_;

4695

_tmp25_[1] = _tmp21_;

4696

_tmp25_[2] = _tmp22_;

4697

_tmp25_[3] = _tmp23_;

4698

_tmp25_[4] = _tmp24_;

4699

adf_sources = _tmp25_;

4700

adf_sources_length1 = 5;

4701

_adf_sources_size_ = adf_sources_length1;

4702

_tmp26_ = g_strdup ("ADF Front");

4703

_tmp27_ = SANE_I18N ("ADF Front");

4704

_tmp28_ = g_strdup (_tmp27_);

4705

_tmp29_ = g_new0 (gchar*, 2 + 1);

4706

_tmp29_[0] = _tmp26_;

4707

_tmp29_[1] = _tmp28_;

4708

adf_front_sources = _tmp29_;

4709

adf_front_sources_length1 = 2;

4710

_adf_front_sources_size_ = adf_front_sources_length1;

4711

_tmp30_ = g_strdup ("ADF Back");

4712

_tmp31_ = SANE_I18N ("ADF Back");

4713

_tmp32_ = g_strdup (_tmp31_);

4714

_tmp33_ = g_new0 (gchar*, 2 + 1);

4715

_tmp33_[0] = _tmp30_;

4716

_tmp33_[1] = _tmp32_;

4717

adf_back_sources = _tmp33_;

4718

adf_back_sources_length1 = 2;

4719

_adf_back_sources_size_ = adf_back_sources_length1;

4720

_tmp34_ = g_strdup ("ADF Duplex");

4721

_tmp35_ = SANE_I18N ("ADF Duplex");

4722

_tmp36_ = g_strdup (_tmp35_);

4723

_tmp37_ = g_new0 (gchar*, 2 + 1);

4724

_tmp37_[0] = _tmp34_;

4725

_tmp37_[1] = _tmp36_;

4726

adf_duplex_sources = _tmp37_;

4727

adf_duplex_sources_length1 = 2;

4728

_adf_duplex_sources_size_ = adf_duplex_sources_length1;

4729

switch (job->type) {

4730

case SCAN_TYPE_SINGLE:

4731

{

4732

gboolean _tmp38_;

4733

_tmp38_ = scanner_set_default_option (self, self->priv->handle, option, index);

4734

if (!_tmp38_) {

4735

gboolean _tmp39_;

4736

_tmp39_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, flatbed_sources, flatbed_sources_length1, NULL);

4737

if (!_tmp39_) {

4738

g_warning ("scanner.vala:921: Unable to set single page source, please file a bug");

4739

}

4740

}

4741

break;

4742

}

4743

case SCAN_TYPE_ADF_FRONT:

4744

{

4745

gboolean _tmp40_;

4746

_tmp40_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, adf_front_sources, adf_front_sources_length1, NULL);

4747

if (!_tmp40_) {

4748

gboolean _tmp41_;

4749

_tmp41_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, adf_sources, adf_sources_length1, NULL);

4750

if (!(!_tmp41_)) {

4751

g_warning ("scanner.vala:926: Unable to set front ADF source, please file a bug");

4752

}

4753

}

4754

break;

4755

}

4756

case SCAN_TYPE_ADF_BACK:

4757

{

4758

gboolean _tmp42_;

4759

_tmp42_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, adf_back_sources, adf_back_sources_length1, NULL);

4760

if (!_tmp42_) {

4761

gboolean _tmp43_;

4762

_tmp43_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, adf_sources, adf_sources_length1, NULL);

4763

if (!_tmp43_) {

4764

g_warning ("scanner.vala:931: Unable to set back ADF source, please file a bug");

4765

}

4766

}

4767

break;

4768

}

4769

case SCAN_TYPE_ADF_BOTH:

4770

{

4771

gboolean _tmp44_;

4772

_tmp44_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, adf_duplex_sources, adf_duplex_sources_length1, NULL);

4773

if (!_tmp44_) {

4774

gboolean _tmp45_;

4775

_tmp45_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, adf_sources, adf_sources_length1, NULL);

4776

if (!_tmp45_) {

4777

g_warning ("scanner.vala:936: Unable to set duplex ADF source, please file a bug");

4778

}

4779

}

4780

break;

4781

}

4782

default:

4783

break;

4784

}

4785

adf_duplex_sources = (_vala_array_free (adf_duplex_sources, adf_duplex_sources_length1, (GDestroyNotify) g_free), NULL);

4786

adf_back_sources = (_vala_array_free (adf_back_sources, adf_back_sources_length1, (GDestroyNotify) g_free), NULL);

4787

adf_front_sources = (_vala_array_free (adf_front_sources, adf_front_sources_length1, (GDestroyNotify) g_free), NULL);

4788

adf_sources = (_vala_array_free (adf_sources, adf_sources_length1, (GDestroyNotify) g_free), NULL);

4789

flatbed_sources = (_vala_array_free (flatbed_sources, flatbed_sources_length1, (GDestroyNotify) g_free), NULL);

4790

} else {

4791

if (g_strcmp0 (option->name, "duplex") == 0) {

4792

if (option->type == SANE_TYPE_BOOL) {

4793

scanner_set_bool_option (self, self->priv->handle, option, index, job->type == SCAN_TYPE_ADF_BOTH, NULL);

4794

}

4795

} else {

4796

if (g_strcmp0 (option->name, "batch-scan") == 0) {

4797

if (option->type == SANE_TYPE_BOOL) {

4798

scanner_set_bool_option (self, self->priv->handle, option, index, job->type != SCAN_TYPE_SINGLE, NULL);

4799

}

4800

} else {

4801

if (g_strcmp0 (option->name, SANE_NAME_BIT_DEPTH) == 0) {

4802

if (job->depth > 0) {

4803

scanner_set_int_option (self, self->priv->handle, option, index, job->depth, NULL);

4804

}

4805

} else {

4806

if (g_strcmp0 (option->name, SANE_NAME_SCAN_MODE) == 0) {

4807

gchar* _tmp46_;

4808

gchar* _tmp47_;

4809

gchar* _tmp48_;

4810

gchar** _tmp49_ = NULL;

4811

gchar** color_scan_modes;

4812

gint color_scan_modes_length1;

4813

gint _color_scan_modes_size_;

4814

gchar* _tmp50_;

4815

gchar* _tmp51_;

4816

gchar* _tmp52_;

4817

const gchar* _tmp53_ = NULL;

4818

gchar* _tmp54_;

4819

gchar* _tmp55_;

4820

gchar** _tmp56_ = NULL;

4821

gchar** gray_scan_modes;

4822

gint gray_scan_modes_length1;

4823

gint _gray_scan_modes_size_;

4824

gchar* _tmp57_;

4825

gchar* _tmp58_;

4826

gchar* _tmp59_;

4827

const gchar* _tmp60_ = NULL;

4828

gchar* _tmp61_;

4829

gchar* _tmp62_;

4830

const gchar* _tmp63_ = NULL;

4831

gchar* _tmp64_;

4832

gchar* _tmp65_;

4833

const gchar* _tmp66_ = NULL;

4834

gchar* _tmp67_;

4835

gchar* _tmp68_;

4836

gchar* _tmp69_;

4837

gchar* _tmp70_;

4838

gchar* _tmp71_;

4839

const gchar* _tmp72_ = NULL;

4840

gchar* _tmp73_;

4841

gchar* _tmp74_;

4842

gchar** _tmp75_ = NULL;

4843

gchar** lineart_scan_modes;

4844

gint lineart_scan_modes_length1;

4845

gint _lineart_scan_modes_size_;

4846

_tmp46_ = g_strdup (SANE_VALUE_SCAN_MODE_COLOR);

4847

_tmp47_ = g_strdup ("Color");

4848

_tmp48_ = g_strdup ("24bit Color");

4849

_tmp49_ = g_new0 (gchar*, 3 + 1);

4850

_tmp49_[0] = _tmp46_;

4851

_tmp49_[1] = _tmp47_;

4852

_tmp49_[2] = _tmp48_;

4853

color_scan_modes = _tmp49_;

4854

color_scan_modes_length1 = 3;

4855

_color_scan_modes_size_ = color_scan_modes_length1;

4856

_tmp50_ = g_strdup (SANE_VALUE_SCAN_MODE_GRAY);

4857

_tmp51_ = g_strdup ("Gray");

4858

_tmp52_ = g_strdup ("Grayscale");

4859

_tmp53_ = SANE_I18N ("Grayscale");

4860

_tmp54_ = g_strdup (_tmp53_);

4861

_tmp55_ = g_strdup ("True Gray");

4862

_tmp56_ = g_new0 (gchar*, 5 + 1);

4863

_tmp56_[0] = _tmp50_;

4864

_tmp56_[1] = _tmp51_;

4865

_tmp56_[2] = _tmp52_;

4866

_tmp56_[3] = _tmp54_;

4867

_tmp56_[4] = _tmp55_;

4868

gray_scan_modes = _tmp56_;

4869

gray_scan_modes_length1 = 5;

4870

_gray_scan_modes_size_ = gray_scan_modes_length1;

4871

_tmp57_ = g_strdup (SANE_VALUE_SCAN_MODE_LINEART);

4872

_tmp58_ = g_strdup ("Lineart");

4873

_tmp59_ = g_strdup ("LineArt");

4874

_tmp60_ = SANE_I18N ("LineArt");

4875

_tmp61_ = g_strdup (_tmp60_);

4876

_tmp62_ = g_strdup ("Black & White");

4877

_tmp63_ = SANE_I18N ("Black & White");

4878

_tmp64_ = g_strdup (_tmp63_);

4879

_tmp65_ = g_strdup ("Binary");

4880

_tmp66_ = SANE_I18N ("Binary");

4881

_tmp67_ = g_strdup (_tmp66_);

4882

_tmp68_ = g_strdup ("Thresholded");

4883

_tmp69_ = g_strdup (SANE_VALUE_SCAN_MODE_GRAY);

4884

_tmp70_ = g_strdup ("Gray");

4885

_tmp71_ = g_strdup ("Grayscale");

4886

_tmp72_ = SANE_I18N ("Grayscale");

4887

_tmp73_ = g_strdup (_tmp72_);

4888

_tmp74_ = g_strdup ("True Gray");

4889

_tmp75_ = g_new0 (gchar*, 14 + 1);

4890

_tmp75_[0] = _tmp57_;

4891

_tmp75_[1] = _tmp58_;

4892

_tmp75_[2] = _tmp59_;

4893

_tmp75_[3] = _tmp61_;

4894

_tmp75_[4] = _tmp62_;

4895

_tmp75_[5] = _tmp64_;

4896

_tmp75_[6] = _tmp65_;

4897

_tmp75_[7] = _tmp67_;

4898

_tmp75_[8] = _tmp68_;

4899

_tmp75_[9] = _tmp69_;

4900

_tmp75_[10] = _tmp70_;

4901

_tmp75_[11] = _tmp71_;

4902

_tmp75_[12] = _tmp73_;

4903

_tmp75_[13] = _tmp74_;

4904

lineart_scan_modes = _tmp75_;

4905

lineart_scan_modes_length1 = 14;

4906

_lineart_scan_modes_size_ = lineart_scan_modes_length1;

4907

switch (job->scan_mode) {

4908

case SCAN_MODE_COLOR:

4909

{

4910

gboolean _tmp76_;

4911

_tmp76_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, color_scan_modes, color_scan_modes_length1, NULL);

4912

if (!_tmp76_) {

4913

g_warning ("scanner.vala:994: Unable to set Color mode, please file a bug");

4914

}

4915

break;

4916

}

4917

case SCAN_MODE_GRAY:

4918

{

4919

gboolean _tmp77_;

4920

_tmp77_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, gray_scan_modes, gray_scan_modes_length1, NULL);

4921

if (!_tmp77_) {

4922

g_warning ("scanner.vala:998: Unable to set Gray mode, please file a bug");

4923

}

4924

break;

4925

}

4926

case SCAN_MODE_LINEART:

4927

{

4928

gboolean _tmp78_;

4929

_tmp78_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, lineart_scan_modes, lineart_scan_modes_length1, NULL);

4930

if (!_tmp78_) {

4931

g_warning ("scanner.vala:1002: Unable to set Lineart mode, please file a bug");

4932

}

4933

break;

4934

}

4935

default:

4936

{

4937

break;

4938

}

4939

}

4940

lineart_scan_modes = (_vala_array_free (lineart_scan_modes, lineart_scan_modes_length1, (GDestroyNotify) g_free), NULL);

4941

gray_scan_modes = (_vala_array_free (gray_scan_modes, gray_scan_modes_length1, (GDestroyNotify) g_free), NULL);

4942

color_scan_modes = (_vala_array_free (color_scan_modes, color_scan_modes_length1, (GDestroyNotify) g_free), NULL);

4943

} else {

4944

if (g_strcmp0 (option->name, "compression") == 0) {

4945

const gchar* _tmp79_ = NULL;

4946

gchar* _tmp80_;

4947

const gchar* _tmp81_ = NULL;

4948

gchar* _tmp82_;

4949

gchar* _tmp83_;

4950

gchar* _tmp84_;

4951

gchar** _tmp85_ = NULL;

4952

gchar** disable_compression_names;

4953

gint disable_compression_names_length1;

4954

gint _disable_compression_names_size_;

4955

gboolean _tmp86_;

4956

_tmp79_ = SANE_I18N ("None");

4957

_tmp80_ = g_strdup (_tmp79_);

4958

_tmp81_ = SANE_I18N ("none");

4959

_tmp82_ = g_strdup (_tmp81_);

4960

_tmp83_ = g_strdup ("None");

4961

_tmp84_ = g_strdup ("none");

4962

_tmp85_ = g_new0 (gchar*, 4 + 1);

4963

_tmp85_[0] = _tmp80_;

4964

_tmp85_[1] = _tmp82_;

4965

_tmp85_[2] = _tmp83_;

4966

_tmp85_[3] = _tmp84_;

4967

disable_compression_names = _tmp85_;

4968

disable_compression_names_length1 = 4;

4969

_disable_compression_names_size_ = disable_compression_names_length1;

4970

_tmp86_ = scanner_set_constrained_string_option (self, self->priv->handle, option, index, disable_compression_names, disable_compression_names_length1, NULL);

4971

if (!_tmp86_) {

4972

g_warning ("scanner.vala:1020: Unable to disable compression, please file a bug");

4973

}

4974

disable_compression_names = (_vala_array_free (disable_compression_names, disable_compression_names_length1, (GDestroyNotify) g_free), NULL);

4975

} else {

4976

if (g_strcmp0 (option->name, SANE_NAME_SCAN_BR_X) == 0) {

4977

self->priv->br_x_option_index = index;

4978

} else {

4979

if (g_strcmp0 (option->name, SANE_NAME_SCAN_BR_Y) == 0) {

4980

self->priv->br_y_option_index = index;

4981

} else {

4982

if (g_strcmp0 (option->name, SANE_NAME_PAGE_WIDTH) == 0) {

4983

if (job->page_width > 0.0) {

4984

if (option->type == SANE_TYPE_FIXED) {

4985

scanner_set_fixed_option (self, self->priv->handle, option, index, job->page_width / 10.0, NULL);

4986

} else {

4987

scanner_set_int_option (self, self->priv->handle, option, index, job->page_width / 10, NULL);

4988

}

4989

}

4990

} else {

4991

if (g_strcmp0 (option->name, SANE_NAME_PAGE_HEIGHT) == 0) {

4992

if (job->page_height > 0.0) {

4993

if (option->type == SANE_TYPE_FIXED) {

4994

scanner_set_fixed_option (self, self->priv->handle, option, index, job->page_height / 10.0, NULL);

4995

} else {

4996

scanner_set_int_option (self, self->priv->handle, option, index, job->page_height / 10, NULL);

4997

}

4998

}

4999

}

5000

}

5001

}

5002

}

5003

}

5004

}

5005

}

5006

}

5007

}

5008

}

5009

}

5010

if (g_strcmp0 (self->priv->current_device, "test") == 0) {

5011

if (g_strcmp0 (option->name, "hand-scanner") == 0) {

5012

scanner_set_bool_option (self, self->priv->handle, option, index, FALSE, NULL);

5013

} else {

5014

if (g_strcmp0 (option->name, "three-pass") == 0) {

5015

scanner_set_bool_option (self, self->priv->handle, option, index, FALSE, NULL);

5016

} else {

5017

if (g_strcmp0 (option->name, "test-picture") == 0) {

5018

scanner_set_string_option (self, self->priv->handle, option, index, "Color pattern", NULL);

5019

} else {

5020

if (g_strcmp0 (option->name, "read-delay") == 0) {

5021

scanner_set_bool_option (self, self->priv->handle, option, index, TRUE, NULL);

5022

} else {

5023

if (g_strcmp0 (option->name, "read-delay-duration") == 0) {

5024

scanner_set_int_option (self, self->priv->handle, option, index, 200000, NULL);

5025

}

5026

}

5027

}

5028

}

5029

}

5030

}

5031

_scan_job_unref0 (job);

5032

}

5033

5034

5035

static void scanner_do_complete_document (Scanner* self) {

5036

NotifyDocumentDone* _tmp0_ = NULL;

5037

NotifyDocumentDone* _tmp1_;

5038

g_return_if_fail (self != NULL);

5039

self->priv->job_queue = g_list_remove_link (self->priv->job_queue, self->priv->job_queue);

5040

self->priv->state = SCAN_STATE_IDLE;

5041

if (self->priv->job_queue != NULL) {

5042

self->priv->state = SCAN_STATE_OPEN;

5043

return;

5044

}

5045

_tmp0_ = notify_document_done_new ();

5046

_tmp1_ = _tmp0_;

5047

scanner_notify (self, (Notify*) _tmp1_);

5048

_notify_unref0 (_tmp1_);

5049

scanner_set_scanning (self, FALSE);

5050

}

5051

5052

5053

static void scanner_do_start (Scanner* self) {

5054

SANE_Status status = 0;

5055

NotifyExpectPage* _tmp0_ = NULL;

5056

NotifyExpectPage* _tmp1_;

5057

SANE_Status _tmp2_;

5058

gchar* _tmp3_ = NULL;

5059

gchar* _tmp4_;

5060

g_return_if_fail (self != NULL);

5061

_tmp0_ = notify_expect_page_new ();

5062

_tmp1_ = _tmp0_;

5063

scanner_notify (self, (Notify*) _tmp1_);

5064

_notify_unref0 (_tmp1_);

5065

_tmp2_ = sane_start (self->priv->handle);

5066

status = _tmp2_;

5067

_tmp3_ = sane_status_to_string (status);

5068

_tmp4_ = _tmp3_;

5069

g_debug ("scanner.vala:1090: sane_start (page=%d, pass=%d) -> %s", self->priv->page_number, self->priv->pass_number, _tmp4_);

5070

_g_free0 (_tmp4_);

5071

if (status == SANE_STATUS_GOOD) {

5072

self->priv->state = SCAN_STATE_GET_PARAMETERS;

5073

} else {

5074

if (status == SANE_STATUS_NO_DOCS) {

5075

scanner_do_complete_document (self);

5076

} else {

5077

const gchar* _tmp5_ = NULL;

5078

const gchar* _tmp6_ = NULL;

5079

_tmp5_ = sane_strstatus (status);

5080

g_warning ("scanner.vala:1097: Unable to start device: %s", _tmp5_);

5081

_tmp6_ = _ ("Unable to start scan");

5082

scanner_fail_scan (self, (gint) status, _tmp6_);

5083

}

5084

}

5085

}

5086

5087

5088

static gchar* sane_frame_to_string (SANE_Frame frame) {

5089

gchar* result = NULL;

5090

switch (frame) {

5091

case SANE_FRAME_GRAY:

5092

{

5093

gchar* _tmp0_;

5094

_tmp0_ = g_strdup ("SANE_FRAME_GRAY");

5095

result = _tmp0_;

5096

return result;

5097

}

5098

case SANE_FRAME_RGB:

5099

{

5100

gchar* _tmp1_;

5101

_tmp1_ = g_strdup ("SANE_FRAME_RGB");

5102

result = _tmp1_;

5103

return result;

5104

}

5105

case SANE_FRAME_RED:

5106

{

5107

gchar* _tmp2_;

5108

_tmp2_ = g_strdup ("SANE_FRAME_RED");

5109

result = _tmp2_;

5110

return result;

5111

}

5112

case SANE_FRAME_GREEN:

5113

{

5114

gchar* _tmp3_;

5115

_tmp3_ = g_strdup ("SANE_FRAME_GREEN");

5116

result = _tmp3_;

5117

return result;

5118

}

5119

case SANE_FRAME_BLUE:

5120

{

5121

gchar* _tmp4_;

5122

_tmp4_ = g_strdup ("SANE_FRAME_BLUE");

5123

result = _tmp4_;

5124

return result;

5125

}

5126

default:

5127

{

5128

gchar* _tmp5_ = NULL;

5129

_tmp5_ = g_strdup_printf ("SANE_FRAME(%d)", (gint) frame);

5130

result = _tmp5_;

5131

return result;

5132

}

5133

}

5134

}

5135

5136

5137

static void scanner_do_get_parameters (Scanner* self) {

5138

SANE_Parameters _tmp0_ = {0};

5139

SANE_Status _tmp1_;

5140

SANE_Status status;

5141

gchar* _tmp2_ = NULL;

5142

gchar* _tmp3_;

5143

ScanJob* _tmp6_;

5144

ScanJob* job;

5145

const gchar* _tmp7_ = NULL;

5146

gchar* _tmp8_ = NULL;

5147

gchar* _tmp9_;

5148

ScanPageInfo* _tmp10_ = NULL;

5149

ScanPageInfo* info;

5150

gboolean _tmp11_ = FALSE;

5151

gboolean _tmp12_ = FALSE;

5152

gboolean _tmp13_ = FALSE;

5153

gint _tmp14_ = 0;

5154

gchar* _tmp15_;

5155

gint buffer_size;

5156

guchar* _tmp18_ = NULL;

5157

g_return_if_fail (self != NULL);

5158

_tmp1_ = sane_get_parameters (self->priv->handle, &_tmp0_);

5159

self->priv->parameters = _tmp0_;

5160

status = _tmp1_;

5161

_tmp2_ = sane_status_to_string (status);

5162

_tmp3_ = _tmp2_;

5163

g_debug ("scanner.vala:1107: sane_get_parameters () -> %s", _tmp3_);

5164

_g_free0 (_tmp3_);

5165

if (status != SANE_STATUS_GOOD) {

5166

const gchar* _tmp4_ = NULL;

5167

const gchar* _tmp5_ = NULL;

5168

_tmp4_ = sane_strstatus (status);

5169

g_warning ("scanner.vala:1110: Unable to get device parameters: %s", _tmp4_);

5170

_tmp5_ = _ ("Error communicating with scanner");

5171

scanner_fail_scan (self, (gint) status, _tmp5_);

5172

return;

5173

}

5174

_tmp6_ = _scan_job_ref0 (SCAN_JOB ((ScanJob*) self->priv->job_queue->data));

5175

job = _tmp6_;

5176

if (self->priv->parameters.last_frame) {

5177

_tmp7_ = "SANE_TRUE";

5178

} else {

5179

_tmp7_ = "SANE_FALSE";

5180

}

5181

_tmp8_ = sane_frame_to_string (self->priv->parameters.format);

5182

_tmp9_ = _tmp8_;

5183

g_debug ("scanner.vala:1119: Parameters: format=%s last_frame=%s bytes_per_line=" \

5184

"%d pixels_per_line=%d lines=%d depth=%d", _tmp9_, _tmp7_, self->priv->parameters.bytes_per_line, self->priv->parameters.pixels_per_line, self->priv->parameters.lines, self->priv->parameters.depth);

5185

_g_free0 (_tmp9_);

5186

_tmp10_ = scan_page_info_new ();

5187

info = _tmp10_;

5188

info->width = self->priv->parameters.pixels_per_line;

5189

info->height = self->priv->parameters.lines;

5190

info->depth = self->priv->parameters.depth;

5191

if (self->priv->parameters.depth == 8) {

5192

_tmp13_ = self->priv->parameters.format == SANE_FRAME_GRAY;

5193

} else {

5194

_tmp13_ = FALSE;

5195

}

5196

if (_tmp13_) {

5197

_tmp12_ = job->depth == 2;

5198

} else {

5199

_tmp12_ = FALSE;

5200

}

5201

if (_tmp12_) {

5202

_tmp11_ = job->scan_mode == SCAN_MODE_GRAY;

5203

} else {

5204

_tmp11_ = FALSE;

5205

}

5206

if (_tmp11_) {

5207

info->depth = job->depth;

5208

}

5209

if (self->priv->parameters.format == SANE_FRAME_GRAY) {

5210

_tmp14_ = 1;

5211

} else {

5212

_tmp14_ = 3;

5213

}

5214

info->n_channels = _tmp14_;

5215

info->dpi = job->dpi;

5216

_tmp15_ = g_strdup (self->priv->current_device);

5217

_g_free0 (info->device);

5218

info->device = _tmp15_;

5219

if (self->priv->page_number != self->priv->notified_page) {

5220

NotifyGotPageInfo* _tmp16_ = NULL;

5221

NotifyGotPageInfo* _tmp17_;

5222

_tmp16_ = notify_got_page_info_new (info);

5223

_tmp17_ = _tmp16_;

5224

scanner_notify (self, (Notify*) _tmp17_);

5225

_notify_unref0 (_tmp17_);

5226

self->priv->notified_page = self->priv->page_number;

5227

}

5228

buffer_size = self->priv->parameters.bytes_per_line + 1;

5229

_tmp18_ = g_new0 (guchar, buffer_size);

5230

self->priv->buffer = (g_free (self->priv->buffer), NULL);

5231

self->priv->buffer = _tmp18_;

5232

self->priv->buffer_length1 = buffer_size;

5233

self->priv->_buffer_size_ = self->priv->buffer_length1;

5234

self->priv->n_used = 0;

5235

self->priv->line_count = 0;

5236

self->priv->pass_number = 0;

5237

self->priv->state = SCAN_STATE_READ;

5238

_scan_page_info_unref0 (info);

5239

_scan_job_unref0 (job);

5240

}

5241

5242

5243

static void scanner_do_complete_page (Scanner* self) {

5244

NotifyPageDone* _tmp0_ = NULL;

5245

NotifyPageDone* _tmp1_;

5246

ScanJob* _tmp2_;

5247

ScanJob* job;

5248

g_return_if_fail (self != NULL);

5249

_tmp0_ = notify_page_done_new ();

5250

_tmp1_ = _tmp0_;

5251

scanner_notify (self, (Notify*) _tmp1_);

5252

_notify_unref0 (_tmp1_);

5253

_tmp2_ = _scan_job_ref0 (SCAN_JOB ((ScanJob*) self->priv->job_queue->data));

5254

job = _tmp2_;

5255

if (!self->priv->parameters.last_frame) {

5256

self->priv->pass_number++;

5257

self->priv->state = SCAN_STATE_START;

5258

_scan_job_unref0 (job);

5259

return;

5260

}

5261

if (job->type != SCAN_TYPE_SINGLE) {

5262

NotifyPageDone* _tmp3_ = NULL;

5263

NotifyPageDone* _tmp4_;

5264

self->priv->page_number++;

5265

self->priv->pass_number = 0;

5266

_tmp3_ = notify_page_done_new ();

5267

_tmp4_ = _tmp3_;

5268

scanner_notify (self, (Notify*) _tmp4_);

5269

_notify_unref0 (_tmp4_);

5270

self->priv->state = SCAN_STATE_START;

5271

_scan_job_unref0 (job);

5272

return;

5273

}

5274

sane_cancel (self->priv->handle);

5275

g_debug ("scanner.vala:1179: sane_cancel ()");

5276

scanner_do_complete_document (self);

5277

_scan_job_unref0 (job);

5278

}

5279

5280

5281

static void scanner_do_read (Scanner* self) {

5282

ScanJob* _tmp0_;

5283

ScanJob* job;

5284

gint n_to_read;

5285

SANE_Int n_read;

5286

guchar* b;

5287

SANE_Int _tmp1_;

5288

SANE_Status _tmp2_;

5289

SANE_Status status;

5290

gchar* _tmp3_ = NULL;

5291

gchar* _tmp4_;

5292

gboolean full_read;

5293

gboolean _tmp8_ = FALSE;

5294

g_return_if_fail (self != NULL);

5295

_tmp0_ = _scan_job_ref0 (SCAN_JOB ((ScanJob*) self->priv->job_queue->data));

5296

job = _tmp0_;

5297

n_to_read = self->priv->buffer_length1 - self->priv->n_used;

5298

b = (guchar*) self->priv->buffer;

5299

_tmp2_ = sane_read (self->priv->handle, (guint8*) (b + self->priv->n_used), (SANE_Int) n_to_read, &_tmp1_);

5300

n_read = _tmp1_;

5301

status = _tmp2_;

5302

_tmp3_ = sane_status_to_string (status);

5303

_tmp4_ = _tmp3_;

5304

g_debug ("scanner.vala:1194: sane_read (%d) -> (%s, %d)", n_to_read, _tmp4_, (gint) n_read);

5305

_g_free0 (_tmp4_);

5306

if (status == SANE_STATUS_EOF) {

5307

gboolean _tmp5_ = FALSE;

5308

if (self->priv->parameters.lines > 0) {

5309

_tmp5_ = self->priv->line_count != self->priv->parameters.lines;

5310

} else {

5311

_tmp5_ = FALSE;

5312

}

5313

if (_tmp5_) {

5314

g_warning ("scanner.vala:1200: Scan completed with %d lines, expected %d lines", self->priv->parameters.lines, self->priv->parameters.lines);

5315

}

5316

if (self->priv->n_used > 0) {

5317

g_warning ("scanner.vala:1202: Scan complete with %d bytes of unused data", self->priv->n_used);

5318

}

5319

scanner_do_complete_page (self);

5320

_scan_job_unref0 (job);

5321

return;

5322

}

5323

if (status != SANE_STATUS_GOOD) {

5324

const gchar* _tmp6_ = NULL;

5325

const gchar* _tmp7_ = NULL;

5326

_tmp6_ = sane_strstatus (status);

5327

g_warning ("scanner.vala:1210: Unable to read frame from device: %s", _tmp6_);

5328

_tmp7_ = _ ("Error communicating with scanner");

5329

scanner_fail_scan (self, (gint) status, _tmp7_);

5330

_scan_job_unref0 (job);

5331

return;

5332

}

5333

full_read = FALSE;

5334

if (self->priv->n_used == 0) {

5335

_tmp8_ = n_read == self->priv->buffer_length1;

5336

} else {

5337

_tmp8_ = FALSE;

5338

}

5339

if (_tmp8_) {

5340

full_read = TRUE;

5341

}

5342

self->priv->n_used = self->priv->n_used + n_read;

5343

if (self->priv->n_used >= self->priv->parameters.bytes_per_line) {

5344

ScanLine* _tmp9_ = NULL;

5345

ScanLine* line;

5346

guchar* _tmp10_;

5347

gint _tmp11_;

5348

gint buffer_size;

5349

guchar* _tmp12_ = NULL;

5350

gint n_remaining;

5351

gboolean _tmp14_ = FALSE;

5352

gboolean _tmp15_ = FALSE;

5353

gboolean _tmp16_ = FALSE;

5354

NotifyGotLine* _tmp19_ = NULL;

5355

NotifyGotLine* _tmp20_;

5356

_tmp9_ = scan_line_new ();

5357

line = _tmp9_;

5358

switch (self->priv->parameters.format) {

5359

case SANE_FRAME_GRAY:

5360

{

5361

line->channel = 0;

5362

break;

5363

}

5364

case SANE_FRAME_RGB:

5365

{

5366

line->channel = -1;

5367

break;

5368

}

5369

case SANE_FRAME_RED:

5370

{

5371

line->channel = 0;

5372

break;

5373

}

5374

case SANE_FRAME_GREEN:

5375

{

5376

line->channel = 1;

5377

break;

5378

}

5379

case SANE_FRAME_BLUE:

5380

{

5381

line->channel = 2;

5382

break;

5383

}

5384

default:

5385

break;

5386

}

5387

line->width = self->priv->parameters.pixels_per_line;

5388

line->depth = self->priv->parameters.depth;

5389

_tmp10_ = self->priv->buffer;

5390

_tmp11_ = self->priv->buffer_length1;

5391

self->priv->buffer = NULL;

5392

line->data = (g_free (line->data), NULL);

5393

line->data = _tmp10_;

5394

line->data_length1 = _tmp11_;

5395

line->data_length = self->priv->parameters.bytes_per_line;

5396

line->number = self->priv->line_count;

5397

line->n_lines = self->priv->n_used / line->data_length;

5398

self->priv->line_count = self->priv->line_count + line->n_lines;

5399

buffer_size = self->priv->buffer_length1;

5400

if (full_read) {

5401

buffer_size = buffer_size + self->priv->parameters.bytes_per_line;

5402

}

5403

_tmp12_ = g_new0 (guchar, buffer_size);

5404

self->priv->buffer = (g_free (self->priv->buffer), NULL);

5405

self->priv->buffer = _tmp12_;

5406

self->priv->buffer_length1 = buffer_size;

5407

self->priv->_buffer_size_ = self->priv->buffer_length1;

5408

n_remaining = self->priv->n_used - (line->n_lines * line->data_length);

5409

self->priv->n_used = 0;

5410

{

5411

gint i;

5412

i = 0;

5413

{

5414

gboolean _tmp13_;

5415

_tmp13_ = TRUE;

5416

while (TRUE) {

5417

if (!_tmp13_) {

5418

i++;

5419

}

5420

_tmp13_ = FALSE;

5421

if (!(i < n_remaining)) {

5422

break;

5423

}

5424

self->priv->buffer[i] = line->data[i + (line->n_lines * line->data_length)];

5425

self->priv->n_used++;

5426

}

5427

}

5428

}

5429

if (self->priv->parameters.depth == 8) {

5430

_tmp16_ = self->priv->parameters.format == SANE_FRAME_GRAY;

5431

} else {

5432

_tmp16_ = FALSE;

5433

}

5434

if (_tmp16_) {

5435

_tmp15_ = job->depth == 2;

5436

} else {

5437

_tmp15_ = FALSE;

5438

}

5439

if (_tmp15_) {

5440

_tmp14_ = job->scan_mode == SCAN_MODE_GRAY;

5441

} else {

5442

_tmp14_ = FALSE;

5443

}

5444

if (_tmp14_) {

5445

guchar block;

5446

gint write_offset;

5447

gint block_shift;

5448

block = (guchar) 0;

5449

write_offset = 0;

5450

block_shift = 6;

5451

{

5452

gint i;

5453

i = 0;

5454

{

5455

gboolean _tmp17_;

5456

_tmp17_ = TRUE;

5457

while (TRUE) {

5458

gint offset;

5459

if (!_tmp17_) {

5460

i++;

5461

}

5462

_tmp17_ = FALSE;

5463

if (!(i < line->n_lines)) {

5464

break;

5465

}

5466

offset = i * line->data_length;

5467

{

5468

gint x;

5469

x = 0;

5470

{

5471

gboolean _tmp18_;

5472

_tmp18_ = TRUE;

5473

while (TRUE) {

5474

guchar p;

5475

guchar sample = '\0';

5476

if (!_tmp18_) {

5477

x++;

5478

}

5479

_tmp18_ = FALSE;

5480

if (!(x < line->width)) {

5481

break;

5482

}

5483

p = line->data[offset + x];

5484

if (p >= 192) {

5485

sample = (guchar) 3;

5486

} else {

5487

if (p >= 128) {

5488

sample = (guchar) 2;

5489

} else {

5490

if (p >= 64) {

5491

sample = (guchar) 1;

5492

} else {

5493

sample = (guchar) 0;

5494

}

5495

}

5496

}

5497

block = block | (sample << block_shift);

5498

if (block_shift == 0) {

5499

line->data[write_offset] = block;

5500

write_offset++;

5501

block = (guchar) 0;

5502

block_shift = 6;

5503

} else {

5504

block_shift = block_shift - 2;

5505

}

5506

}

5507

}

5508

}

5509

if (block_shift != 6) {

5510

line->data[write_offset] = block;

5511

write_offset++;

5512

block = (guchar) 0;

5513

block_shift = 6;

5514

}

5515

}

5516

}

5517

}

5518

line->data_length = ((line->width * 2) + 7) / 8;

5519

}

5520

_tmp19_ = notify_got_line_new (line);

5521

_tmp20_ = _tmp19_;

5522

scanner_notify (self, (Notify*) _tmp20_);

5523

_notify_unref0 (_tmp20_);

5524

_scan_line_unref0 (line);

5525

}

5526

_scan_job_unref0 (job);

5527

}

5528

5529

5530

static void _scanner_authorization_cb_sane_authcallback (const gchar* resource, gchar* username, gchar* password) {

5531

scanner_authorization_cb (resource, username, -1, password, -1);

5532

}

5533

5534

5535

static gboolean scanner_scan_thread (Scanner* self) {

5536

gboolean result = FALSE;

5537

SANE_Int version_code;

5538

SANE_Int _tmp0_;

5539

SANE_Status _tmp1_;

5540

SANE_Status status;

5541

gchar* _tmp2_ = NULL;

5542

gchar* _tmp3_;

5543

gint _tmp5_;

5544

gint _tmp6_;

5545

gint _tmp7_;

5546

g_return_val_if_fail (self != NULL, FALSE);

5547

self->priv->state = SCAN_STATE_IDLE;

5548

_tmp1_ = sane_init (&_tmp0_, _scanner_authorization_cb_sane_authcallback);

5549

version_code = _tmp0_;

5550

status = _tmp1_;

5551

_tmp2_ = sane_status_to_string (status);

5552

_tmp3_ = _tmp2_;

5553

g_debug ("scanner.vala:1327: sane_init () -> %s", _tmp3_);

5554

_g_free0 (_tmp3_);

5555

if (status != SANE_STATUS_GOOD) {

5556

const gchar* _tmp4_ = NULL;

5557

_tmp4_ = sane_strstatus (status);

5558

g_warning ("scanner.vala:1330: Unable to initialize SANE backend: %s", _tmp4_);

5559

result = FALSE;

5560

return result;

5561

}

5562

_tmp5_ = SANE_VERSION_MAJOR (version_code);

5563

_tmp6_ = SANE_VERSION_MINOR (version_code);

5564

_tmp7_ = SANE_VERSION_BUILD (version_code);

5565

g_debug ("scanner.vala:1333: SANE version %d.%d.%d", _tmp5_, _tmp6_, _tmp7_);

5566

scanner_redetect (self);

5567

while (TRUE) {

5568

gboolean _tmp8_;

5569

_tmp8_ = scanner_handle_requests (self);

5570

if (!_tmp8_) {

5571

break;

5572

}

5573

switch (self->priv->state) {

5574

case SCAN_STATE_IDLE:

5575

{

5576

if (self->priv->job_queue != NULL) {

5577

scanner_set_scanning (self, TRUE);

5578

self->priv->state = SCAN_STATE_OPEN;

5579

}

5580

break;

5581

}

5582

case SCAN_STATE_REDETECT:

5583

{

5584

scanner_do_redetect (self);

5585

break;

5586

}

5587

case SCAN_STATE_OPEN:

5588

{

5589

scanner_do_open (self);

5590

break;

5591

}

5592

case SCAN_STATE_GET_OPTION:

5593

{

5594

scanner_do_get_option (self);

5595

break;

5596

}

5597

case SCAN_STATE_START:

5598

{

5599

scanner_do_start (self);

5600

break;

5601

}

5602

case SCAN_STATE_GET_PARAMETERS:

5603

{

5604

scanner_do_get_parameters (self);

5605

break;

5606

}

5607

case SCAN_STATE_READ:

5608

{

5609

scanner_do_read (self);

5610

break;

5611

}

5612

default:

5613

break;

5614

}

5615

}

5616

result = TRUE;

5617

return result;

5618

}

5619

5620

5621

static gpointer _scanner_scan_thread_gthread_func (gpointer self) {

5622

gpointer result;

5623

result = scanner_scan_thread (self);

5624

return result;

5625

}

5626

5627

5628

void scanner_start (Scanner* self) {

5629

GError * _inner_error_ = NULL;

5630

g_return_if_fail (self != NULL);

5631

{

5632

GThread* _tmp0_ = NULL;

5633

GThread* _tmp1_;

5634

_tmp0_ = g_thread_create (_scanner_scan_thread_gthread_func, self, TRUE, &_inner_error_);

5635

_tmp1_ = _tmp0_;

5636

if (_inner_error_ != NULL) {

5637

goto __catch9_g_error;

5638

}

5639

self->priv->thread = _tmp1_;

5640

}

5641

goto __finally9;

5642

__catch9_g_error:

5643

{

5644

GError* e = NULL;

5645

e = _inner_error_;

5646

_inner_error_ = NULL;

5647

g_critical ("scanner.vala:1384: Unable to create thread: %s", e->message);

5648

_g_error_free0 (e);

5649

}

5650

__finally9:

5651

if (_inner_error_ != NULL) {

5652

g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);

5653

g_clear_error (&_inner_error_);

5654

return;

5655

}

5656

}

5657

5658

5659

void scanner_redetect (Scanner* self) {

5660

RequestRedetect* _tmp0_ = NULL;

5661

g_return_if_fail (self != NULL);

5662

if (self->priv->need_redetect) {

5663

return;

5664

}

5665

self->priv->need_redetect = TRUE;

5666

g_debug ("scanner.vala:1394: Requesting redetection of scan devices");

5667

_tmp0_ = request_redetect_new ();

5668

g_async_queue_push (self->priv->request_queue, (Request*) _tmp0_);

5669

}

5670

5671

5672

gboolean scanner_is_scanning (Scanner* self) {

5673

gboolean result = FALSE;

5674

g_return_val_if_fail (self != NULL, FALSE);

5675

result = self->priv->scanning;

5676

return result;

5677

}

5678

5679

5680

static gchar* scanner_get_scan_mode_string (Scanner* self, ScanMode mode) {

5681

gchar* result = NULL;

5682

g_return_val_if_fail (self != NULL, NULL);

5683

switch (mode) {

5684

case SCAN_MODE_DEFAULT:

5685

{

5686

gchar* _tmp0_;

5687

_tmp0_ = g_strdup ("ScanMode.DEFAULT");

5688

result = _tmp0_;

5689

return result;

5690

}

5691

case SCAN_MODE_COLOR:

5692

{

5693

gchar* _tmp1_;

5694

_tmp1_ = g_strdup ("ScanMode.COLOR");

5695

result = _tmp1_;

5696

return result;

5697

}

5698

case SCAN_MODE_GRAY:

5699

{

5700

gchar* _tmp2_;

5701

_tmp2_ = g_strdup ("ScanMode.GRAY");

5702

result = _tmp2_;

5703

return result;

5704

}

5705

case SCAN_MODE_LINEART:

5706

{

5707

gchar* _tmp3_;

5708

_tmp3_ = g_strdup ("ScanMode.LINEART");

5709

result = _tmp3_;

5710

return result;

5711

}

5712

default:

5713

{

5714

gchar* _tmp4_ = NULL;

5715

_tmp4_ = g_strdup_printf ("%d", (gint) mode);

5716

result = _tmp4_;

5717

return result;

5718

}

5719

}

5720

}

5721

5722

5723

static gchar* scanner_get_scan_type_string (Scanner* self, ScanType type) {

5724

gchar* result = NULL;

5725

g_return_val_if_fail (self != NULL, NULL);

5726

switch (type) {

5727

case SCAN_TYPE_SINGLE:

5728

{

5729

gchar* _tmp0_;

5730

_tmp0_ = g_strdup ("ScanType.SINGLE");

5731

result = _tmp0_;

5732

return result;

5733

}

5734

case SCAN_TYPE_ADF_FRONT:

5735

{

5736

gchar* _tmp1_;

5737

_tmp1_ = g_strdup ("ScanType.ADF_FRONT");

5738

result = _tmp1_;

5739

return result;

5740

}

5741

case SCAN_TYPE_ADF_BACK:

5742

{

5743

gchar* _tmp2_;

5744

_tmp2_ = g_strdup ("ScanType.ADF_BACK");

5745

result = _tmp2_;

5746

return result;

5747

}

5748

case SCAN_TYPE_ADF_BOTH:

5749

{

5750

gchar* _tmp3_;

5751

_tmp3_ = g_strdup ("ScanType.ADF_BOTH");

5752

result = _tmp3_;

5753

return result;

5754

}

5755

default:

5756

{

5757

gchar* _tmp4_ = NULL;

5758

_tmp4_ = g_strdup_printf ("%d", (gint) type);

5759

result = _tmp4_;

5760

return result;

5761

}

5762

}

5763

}

5764

5765

5766

void scanner_scan (Scanner* self, const gchar* device, ScanOptions* options) {

5767

const gchar* _tmp0_ = NULL;

5768

gchar* _tmp1_ = NULL;

5769

gchar* _tmp2_;

5770

gchar* _tmp3_ = NULL;

5771

gchar* _tmp4_;

5772

RequestStartScan* _tmp5_ = NULL;

5773

RequestStartScan* request;

5774

ScanJob* _tmp6_ = NULL;

5775

gchar* _tmp7_;

5776

Request* _tmp8_;

5777

g_return_if_fail (self != NULL);

5778

g_return_if_fail (options != NULL);

5779

if (device != NULL) {

5780

_tmp0_ = device;

5781

} else {

5782

_tmp0_ = "(null)";

5783

}

5784

_tmp1_ = scanner_get_scan_mode_string (self, options->scan_mode);

5785

_tmp2_ = _tmp1_;

5786

_tmp3_ = scanner_get_scan_type_string (self, options->type);

5787

_tmp4_ = _tmp3_;

5788

g_debug ("scanner.vala:1440: Scanner.scan (\"%s\", dpi=%d, scan_mode=%s, depth=%" \

5789

"d, type=%s, paper_width=%d, paper_height=%d)", _tmp0_, options->dpi, _tmp2_, options->depth, _tmp4_, options->paper_width, options->paper_height);

5790

_g_free0 (_tmp4_);

5791

_g_free0 (_tmp2_);

5792

_tmp5_ = request_start_scan_new ();

5793

request = _tmp5_;

5794

_tmp6_ = scan_job_new ();

5795

_scan_job_unref0 (request->job);

5796

request->job = _tmp6_;

5797

_tmp7_ = g_strdup (device);

5798

_g_free0 (request->job->device);

5799

request->job->device = _tmp7_;

5800

request->job->dpi = (gdouble) options->dpi;

5801

request->job->scan_mode = options->scan_mode;

5802

request->job->depth = options->depth;

5803

request->job->type = options->type;

5804

request->job->page_width = options->paper_width;

5805

request->job->page_height = options->paper_height;

5806

_tmp8_ = _request_ref0 ((Request*) request);

5807

g_async_queue_push (self->priv->request_queue, _tmp8_);

5808

_request_unref0 (request);

5809

}

5810

5811

5812

void scanner_cancel (Scanner* self) {

5813

RequestCancel* _tmp0_ = NULL;

5814

g_return_if_fail (self != NULL);

5815

_tmp0_ = request_cancel_new ();

5816

g_async_queue_push (self->priv->request_queue, (Request*) _tmp0_);

5817

}

5818

5819

5820

void scanner_free (Scanner* self) {

5821

RequestQuit* _tmp0_ = NULL;

5822

g_return_if_fail (self != NULL);

5823

g_debug ("scanner.vala:1462: Stopping scan thread");

5824

_tmp0_ = request_quit_new ();

5825

g_async_queue_push (self->priv->request_queue, (Request*) _tmp0_);

5826

if (self->priv->thread != NULL) {

5827

g_thread_join (self->priv->thread);

5828

}

5829

sane_exit ();

5830

g_debug ("scanner.vala:1470: sane_exit ()");

5831

}

5832

5833

5834

static void g_cclosure_user_marshal_VOID__SCAN_PAGE_INFO (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {

5835

typedef void (*GMarshalFunc_VOID__SCAN_PAGE_INFO) (gpointer data1, gpointer arg_1, gpointer data2);

5836

register GMarshalFunc_VOID__SCAN_PAGE_INFO callback;

5837

register GCClosure * cc;

5838

register gpointer data1;

5839

register gpointer data2;

5840

cc = (GCClosure *) closure;

5841

g_return_if_fail (n_param_values == 2);

5842

if (G_CCLOSURE_SWAP_DATA (closure)) {

5843

data1 = closure->data;

5844

data2 = param_values->data[0].v_pointer;

5845

} else {

5846

data1 = param_values->data[0].v_pointer;

5847

data2 = closure->data;

5848

}

5849

callback = (GMarshalFunc_VOID__SCAN_PAGE_INFO) (marshal_data ? marshal_data : cc->callback);

5850

callback (data1, value_get_scan_page_info (param_values + 1), data2);

5851

}

5852

5853

5854

static void g_cclosure_user_marshal_VOID__SCAN_LINE (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {

5855

typedef void (*GMarshalFunc_VOID__SCAN_LINE) (gpointer data1, gpointer arg_1, gpointer data2);

5856

register GMarshalFunc_VOID__SCAN_LINE callback;

5857

register GCClosure * cc;

5858

register gpointer data1;

5859

register gpointer data2;

5860

cc = (GCClosure *) closure;

5861

g_return_if_fail (n_param_values == 2);

5862

if (G_CCLOSURE_SWAP_DATA (closure)) {

5863

data1 = closure->data;

5864

data2 = param_values->data[0].v_pointer;

5865

} else {

5866

data1 = param_values->data[0].v_pointer;

5867

data2 = closure->data;

5868

}

5869

callback = (GMarshalFunc_VOID__SCAN_LINE) (marshal_data ? marshal_data : cc->callback);

5870

callback (data1, value_get_scan_line (param_values + 1), data2);

5871

}

5872

5873

5874

static void g_cclosure_user_marshal_VOID__INT_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {

5875

typedef void (*GMarshalFunc_VOID__INT_STRING) (gpointer data1, gint arg_1, const char* arg_2, gpointer data2);

5876

register GMarshalFunc_VOID__INT_STRING callback;

5877

register GCClosure * cc;

5878

register gpointer data1;

5879

register gpointer data2;

5880

cc = (GCClosure *) closure;

5881

g_return_if_fail (n_param_values == 3);

5882

if (G_CCLOSURE_SWAP_DATA (closure)) {

5883

data1 = closure->data;

5884

data2 = param_values->data[0].v_pointer;

5885

} else {

5886

data1 = param_values->data[0].v_pointer;

5887

data2 = closure->data;

5888

}

5889

callback = (GMarshalFunc_VOID__INT_STRING) (marshal_data ? marshal_data : cc->callback);

5890

callback (data1, g_value_get_int (param_values + 1), g_value_get_string (param_values + 2), data2);

5891

}

5892

5893

5894

static void value_scanner_init (GValue* value) {

5895

value->data[0].v_pointer = NULL;

5896

}

5897

5898

5899

static void value_scanner_free_value (GValue* value) {

5900

if (value->data[0].v_pointer) {

5901

scanner_unref (value->data[0].v_pointer);

5902

}

5903

}

5904

5905

5906

static void value_scanner_copy_value (const GValue* src_value, GValue* dest_value) {

5907

if (src_value->data[0].v_pointer) {

5908

dest_value->data[0].v_pointer = scanner_ref (src_value->data[0].v_pointer);

5909

} else {

5910

dest_value->data[0].v_pointer = NULL;

5911

}

5912

}

5913

5914

5915

static gpointer value_scanner_peek_pointer (const GValue* value) {

5916

return value->data[0].v_pointer;

5917

}

5918

5919

5920

static gchar* value_scanner_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

5921

if (collect_values[0].v_pointer) {

5922

Scanner* object;

5923

object = collect_values[0].v_pointer;

5924

if (object->parent_instance.g_class == NULL) {

5925

return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

5926

} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {

5927

return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);

5928

}

5929

value->data[0].v_pointer = scanner_ref (object);

5930

} else {

5931

value->data[0].v_pointer = NULL;

5932

}

5933

return NULL;

5934

}

5935

5936

5937

static gchar* value_scanner_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {

5938

Scanner** object_p;

5939

object_p = collect_values[0].v_pointer;

5940

if (!object_p) {

5941

return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));

5942

}

5943

if (!value->data[0].v_pointer) {

5944

*object_p = NULL;

5945

} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {

5946

*object_p = value->data[0].v_pointer;

5947

} else {

5948

*object_p = scanner_ref (value->data[0].v_pointer);

5949

}

5950

return NULL;

5951

}

5952

5953

5954

GParamSpec* param_spec_scanner (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {

5955

ParamSpecScanner* spec;

5956

g_return_val_if_fail (g_type_is_a (object_type, TYPE_SCANNER), NULL);

5957

spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);

5958

G_PARAM_SPEC (spec)->value_type = object_type;

5959

return G_PARAM_SPEC (spec);

5960

}

5961

5962

5963

gpointer value_get_scanner (const GValue* value) {

5964

g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCANNER), NULL);

5965

return value->data[0].v_pointer;

5966

}

5967

5968

5969

void value_set_scanner (GValue* value, gpointer v_object) {

5970

Scanner* old;

5971

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCANNER));

5972

old = value->data[0].v_pointer;

5973

if (v_object) {

5974

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCANNER));

5975

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

5976

value->data[0].v_pointer = v_object;

5977

scanner_ref (value->data[0].v_pointer);

5978

} else {

5979

value->data[0].v_pointer = NULL;

5980

}

5981

if (old) {

5982

scanner_unref (old);

5983

}

5984

}

5985

5986

5987

void value_take_scanner (GValue* value, gpointer v_object) {

5988

Scanner* old;

5989

g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_SCANNER));

5990

old = value->data[0].v_pointer;

5991

if (v_object) {

5992

g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_SCANNER));

5993

g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));

5994

value->data[0].v_pointer = v_object;

5995

} else {

5996

value->data[0].v_pointer = NULL;

5997

}

5998

if (old) {

5999

scanner_unref (old);

6000

}

6001

}

6002

6003

6004

static void scanner_class_init (ScannerClass * klass) {

6005

scanner_parent_class = g_type_class_peek_parent (klass);

6006

SCANNER_CLASS (klass)->finalize = scanner_finalize;

6007

g_type_class_add_private (klass, sizeof (ScannerPrivate));

6008

g_signal_new ("update_devices", TYPE_SCANNER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1, G_TYPE_POINTER);

6009

g_signal_new ("request_authorization", TYPE_SCANNER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);

6010

g_signal_new ("expect_page", TYPE_SCANNER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);

6011

g_signal_new ("got_page_info", TYPE_SCANNER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__SCAN_PAGE_INFO, G_TYPE_NONE, 1, TYPE_SCAN_PAGE_INFO);

6012

g_signal_new ("got_line", TYPE_SCANNER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__SCAN_LINE, G_TYPE_NONE, 1, TYPE_SCAN_LINE);

6013

g_signal_new ("scan_failed", TYPE_SCANNER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__INT_STRING, G_TYPE_NONE, 2, G_TYPE_INT, G_TYPE_STRING);

6014

g_signal_new ("page_done", TYPE_SCANNER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);

6015

g_signal_new ("document_done", TYPE_SCANNER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);

6016

g_signal_new ("scanning_changed", TYPE_SCANNER, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);

6017

}

6018

6019

6020

static void scanner_instance_init (Scanner * self) {

6021

self->priv = SCANNER_GET_PRIVATE (self);

6022

self->ref_count = 1;

6023

}

6024

6025

6026

static void scanner_finalize (Scanner* obj) {

6027

Scanner * self;

6028

self = SCANNER (obj);

6029

_g_async_queue_unref0 (self->priv->request_queue);

6030

_g_async_queue_unref0 (self->priv->notify_queue);

6031

_g_async_queue_unref0 (self->priv->authorize_queue);

6032

_g_free0 (self->priv->default_device);

6033

__g_list_free__scan_job_unref0_0 (self->priv->job_queue);

6034

_g_free0 (self->priv->current_device);

6035

self->priv->buffer = (g_free (self->priv->buffer), NULL);

6036

}

6037

6038

6039

GType scanner_get_type (void) {

6040

static volatile gsize scanner_type_id__volatile = 0;

6041

if (g_once_init_enter (&scanner_type_id__volatile)) {

6042

static const GTypeValueTable g_define_type_value_table = { value_scanner_init, value_scanner_free_value, value_scanner_copy_value, value_scanner_peek_pointer, "p", value_scanner_collect_value, "p", value_scanner_lcopy_value };

6043

static const GTypeInfo g_define_type_info = { sizeof (ScannerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) scanner_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Scanner), 0, (GInstanceInitFunc) scanner_instance_init, &g_define_type_value_table };

6044

static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };

6045

GType scanner_type_id;

6046

scanner_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Scanner", &g_define_type_info, &g_define_type_fundamental_info, 0);

6047

g_once_init_leave (&scanner_type_id__volatile, scanner_type_id);

6048

}

6049

return scanner_type_id__volatile;

6050

}

6051

6052

6053

gpointer scanner_ref (gpointer instance) {

6054

Scanner* self;

6055

self = instance;

6056

g_atomic_int_inc (&self->ref_count);

6057

return instance;

6058

}

6059

6060

6061

void scanner_unref (gpointer instance) {

6062

Scanner* self;

6063

self = instance;

6064

if (g_atomic_int_dec_and_test (&self->ref_count)) {

6065

SCANNER_GET_CLASS (self)->finalize (self);

6066

g_type_free_instance ((GTypeInstance *) self);

6067

}

6068

}

6069

6070

6071

static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {

6072

if ((array != NULL) && (destroy_func != NULL)) {

6073

int i;

6074

for (i = 0; i < array_length; i = i + 1) {

6075

if (((gpointer*) array)[i] != NULL) {

6076

destroy_func (((gpointer*) array)[i]);

6077

}

6078

}

6079

}

6080

}

6081

6082

6083

static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {

6084

_vala_array_destroy (array, array_length, destroy_func);

6085

g_free (array);

6086

}

6087

6088

6089