Trying very hard not to miss calendar events
Significant refactor
Co-authored-by: Claude <noreply@anthropic.com>
+11674
-773
+4
Cargo.toml
+4
Cargo.toml
+112
README.md
+112
README.md
···
1
+
# Alarma
2
+
3
+
Reads events from Evolution Data Server (EDS).
4
+
5
+
## Installation
6
+
7
+
### Requirements
8
+
9
+
- Linux with GNOME desktop environment
10
+
- Evolution Data Server (libedataserver-1.2)
11
+
- pkg-config
12
+
- Rust 1.70 or later
13
+
14
+
```bash
15
+
sudo apt-get install libedataserver1.2-dev pkg-config
16
+
```
17
+
18
+
## Usage
19
+
20
+
### List calendar sources
21
+
22
+
```bash
23
+
alarma sources list
24
+
```
25
+
26
+
### List events
27
+
28
+
```bash
29
+
# List all events for the next 60 days
30
+
alarma events list
31
+
32
+
# Filter by specific calendar source
33
+
alarma events list --source "my-calendar-uid"
34
+
35
+
# Custom date range
36
+
alarma events list --date-from 2026-01-01 --date-until 2026-12-31
37
+
38
+
# JSON output
39
+
alarma events list --format json
40
+
```
41
+
42
+
## Development
43
+
44
+
### Architecture
45
+
46
+
The project follows clean architecture principles:
47
+
- **Domain Layer**: Pure Rust business logic with no external dependencies
48
+
- **Infrastructure Layer**: Platform-specific implementations (EDS, future: CalDAV, Google Calendar)
49
+
- **Presentation Layer**: CLI and future UI implementations
50
+
51
+
```
52
+
crates/
53
+
├── alarma-core/
54
+
│ └── src/
55
+
│ ├── domain/ # Domain models (Event, CalendarSource, etc.)
56
+
│ ├── repository.rs # Repository trait definitions
57
+
│ ├── service.rs # Business logic layer
58
+
│ └── error.rs # Error types
59
+
├── alarma-eds/
60
+
│ └── src/
61
+
│ ├── bindings/ # Generated FFI bindings
62
+
│ ├── ffi/ # Safe FFI wrappers
63
+
│ └── repository.rs # EDS repository implementation
64
+
└── alarma-cli/
65
+
└── src/
66
+
├── commands/ # Command handlers
67
+
├── output/ # Output formatters
68
+
└── main.rs
69
+
```
70
+
71
+
```
72
+
┌─────────────────────────────────────────────────────────┐
73
+
│ Presentation Layer │
74
+
│ (alarma-cli) │
75
+
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
76
+
│ │ Commands │ │ Output │ │ CLI Args │ │
77
+
│ │ Handlers │ │ Formatters │ │ Parsing │ │
78
+
│ └──────────────┘ └──────────────┘ └──────────────┘ │
79
+
└─────────────────────────────────────────────────────────┘
80
+
│
81
+
↓
82
+
┌─────────────────────────────────────────────────────────┐
83
+
│ Domain Layer │
84
+
│ (alarma-core) │
85
+
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
86
+
│ │ Domain │ │ Repository │ │ Service │ │
87
+
│ │ Models │ │ Traits │ │ Layer │ │
88
+
│ └──────────────┘ └──────────────┘ └──────────────┘ │
89
+
│ │
90
+
│ • CalendarEvent • CalendarSource • DateRange │
91
+
│ • EventTime • AlarmaError • CalendarService │
92
+
└─────────────────────────────────────────────────────────┘
93
+
↑
94
+
│
95
+
┌─────────────────────────────────────────────────────────┐
96
+
│ Infrastructure Layer │
97
+
│ (alarma-eds) │
98
+
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
99
+
│ │ FFI │ │ Bindings │ │ Repository │ │
100
+
│ │ Wrappers │ │ (Generated) │ │ Impl │ │
101
+
│ └──────────────┘ └──────────────┘ └──────────────┘ │
102
+
│ │
103
+
│ • RAII Safety • Bindgen • EdsRepository │
104
+
│ • Error Mapping • Memory Mgmt • EDS Integration │
105
+
└─────────────────────────────────────────────────────────┘
106
+
│
107
+
↓
108
+
┌──────────────────────┐
109
+
│ Evolution Data │
110
+
│ Server (C library) │
111
+
└──────────────────────┘
112
+
```
+25
crates/alarma-cli/Cargo.toml
+25
crates/alarma-cli/Cargo.toml
···
1
+
[package]
2
+
name = "alarma-cli"
3
+
version = "0.1.0"
4
+
edition = "2021"
5
+
authors = ["juanlu"]
6
+
license = "MIT"
7
+
description = "Command-line interface for Alarma calendar tool"
8
+
repository = "https://github.com/juanlu/alarma"
9
+
10
+
[lib]
11
+
name = "alarma_cli"
12
+
path = "src/lib.rs"
13
+
14
+
[[bin]]
15
+
name = "alarma-cli"
16
+
path = "src/main.rs"
17
+
18
+
[dependencies]
19
+
alarma-core = { path = "../alarma-core", features = ["serde"] }
20
+
alarma-eds = { path = "../alarma-eds" }
21
+
clap = { version = "4.5", features = ["derive"] }
22
+
chrono = "0.4"
23
+
serde = { version = "1.0", features = ["derive"] }
24
+
serde_json = "1.0"
25
+
tabled = "0.17"
+78
crates/alarma-cli/src/commands/events.rs
+78
crates/alarma-cli/src/commands/events.rs
···
1
+
//! Events command implementation
2
+
3
+
use crate::output::{print_events, OutputFormat};
4
+
use alarma_core::{repository::DateRange, CalendarService, Result};
5
+
use chrono::{Local, NaiveDate};
6
+
7
+
/// Arguments for listing events
8
+
pub struct ListEventsArgs {
9
+
pub source: Option<String>,
10
+
pub date_from: Option<String>,
11
+
pub date_until: Option<String>,
12
+
pub format: OutputFormat,
13
+
}
14
+
15
+
/// Executes the events list command
16
+
pub fn execute_list(service: &CalendarService, args: ListEventsArgs) -> Result<()> {
17
+
// Parse date range
18
+
let range = parse_date_range(&args.date_from, &args.date_until)?;
19
+
20
+
// Get events
21
+
let events = if let Some(source_uid) = &args.source {
22
+
service.list_events(source_uid, range)?
23
+
} else {
24
+
service.list_all_events(range)?
25
+
};
26
+
27
+
// Print results
28
+
print_events(&events, args.format)?;
29
+
30
+
Ok(())
31
+
}
32
+
33
+
/// Parses date range from string arguments
34
+
fn parse_date_range(date_from: &Option<String>, date_until: &Option<String>) -> Result<DateRange> {
35
+
let start = if let Some(date_str) = date_from {
36
+
parse_date_to_timestamp(date_str)?
37
+
} else {
38
+
Local::now()
39
+
};
40
+
41
+
let end = if let Some(date_str) = date_until {
42
+
parse_date_to_timestamp(date_str)?
43
+
} else {
44
+
start + chrono::Duration::days(60)
45
+
};
46
+
47
+
DateRange::new(start, end)
48
+
}
49
+
50
+
/// Parses a date string (YYYY-MM-DD) to a DateTime
51
+
fn parse_date_to_timestamp(date_str: &str) -> Result<chrono::DateTime<Local>> {
52
+
let date = NaiveDate::parse_from_str(date_str, "%Y-%m-%d")?;
53
+
let datetime = date
54
+
.and_hms_opt(0, 0, 0)
55
+
.ok_or_else(|| alarma_core::AlarmaError::InvalidDateTime("Invalid time".to_string()))?;
56
+
57
+
datetime
58
+
.and_local_timezone(Local)
59
+
.single()
60
+
.ok_or_else(|| alarma_core::AlarmaError::InvalidDateTime("Ambiguous timezone".to_string()))
61
+
}
62
+
63
+
#[cfg(test)]
64
+
mod tests {
65
+
use super::*;
66
+
67
+
#[test]
68
+
fn test_parse_date() {
69
+
let result = parse_date_to_timestamp("2026-01-15");
70
+
assert!(result.is_ok());
71
+
}
72
+
73
+
#[test]
74
+
fn test_parse_invalid_date() {
75
+
let result = parse_date_to_timestamp("invalid-date");
76
+
assert!(result.is_err());
77
+
}
78
+
}
+4
crates/alarma-cli/src/commands/mod.rs
+4
crates/alarma-cli/src/commands/mod.rs
+11
crates/alarma-cli/src/commands/sources.rs
+11
crates/alarma-cli/src/commands/sources.rs
···
1
+
//! Sources command implementation
2
+
3
+
use crate::output::{print_sources, OutputFormat};
4
+
use alarma_core::{CalendarService, Result};
5
+
6
+
/// Executes the sources list command
7
+
pub fn execute_list(service: &CalendarService, format: OutputFormat) -> Result<()> {
8
+
let sources = service.list_sources()?;
9
+
print_sources(&sources, format)?;
10
+
Ok(())
11
+
}
+5
crates/alarma-cli/src/lib.rs
+5
crates/alarma-cli/src/lib.rs
+126
crates/alarma-cli/src/main.rs
+126
crates/alarma-cli/src/main.rs
···
1
+
//! Alarma CLI - Calendar management tool
2
+
//!
3
+
//! This is the command-line interface for Alarma, a calendar management system
4
+
//! with Evolution Data Server integration.
5
+
6
+
mod commands;
7
+
8
+
use std::error::Error;
9
+
10
+
use clap::{Args, Parser, Subcommand};
11
+
12
+
use alarma_core::CalendarService;
13
+
use alarma_eds::EdsRepository;
14
+
15
+
use alarma_cli::output::{self, OutputFormat};
16
+
17
+
#[derive(Parser)]
18
+
#[command(name = "alarma")]
19
+
#[command(about = "Calendar management tool with Evolution Data Server", long_about = None)]
20
+
#[command(version)]
21
+
struct Cli {
22
+
#[command(subcommand)]
23
+
command: Commands,
24
+
}
25
+
26
+
#[derive(Subcommand)]
27
+
enum Commands {
28
+
/// Calendar sources operations
29
+
Sources {
30
+
#[command(subcommand)]
31
+
action: SourcesCommands,
32
+
},
33
+
34
+
/// Calendar events operations
35
+
Events {
36
+
#[command(subcommand)]
37
+
action: EventsCommands,
38
+
},
39
+
}
40
+
41
+
#[derive(Subcommand)]
42
+
enum SourcesCommands {
43
+
/// List available calendar sources
44
+
List {
45
+
/// Output format (table, json, simple)
46
+
#[arg(short, long, default_value = "table")]
47
+
format: String,
48
+
},
49
+
}
50
+
51
+
#[derive(Subcommand)]
52
+
enum EventsCommands {
53
+
/// List events from calendars
54
+
List(ListEventsArgs),
55
+
}
56
+
57
+
#[derive(Args)]
58
+
struct ListEventsArgs {
59
+
/// Filter events by source UID
60
+
#[arg(short, long)]
61
+
source: Option<String>,
62
+
63
+
/// Start date (YYYY-MM-DD format). Defaults to now
64
+
#[arg(long)]
65
+
date_from: Option<String>,
66
+
67
+
/// End date (YYYY-MM-DD format). Defaults to 60 days from now
68
+
#[arg(long)]
69
+
date_until: Option<String>,
70
+
71
+
/// Output format (table, json, simple)
72
+
#[arg(short, long, default_value = "table")]
73
+
format: String,
74
+
}
75
+
76
+
fn main() -> Result<(), Box<dyn Error>> {
77
+
let cli = Cli::parse();
78
+
79
+
// Execute command
80
+
match cli.command {
81
+
Commands::Sources { action } => {
82
+
// Create service (only when needed)
83
+
let repository = EdsRepository::new()
84
+
.map_err(|e| format!("Failed to initialize Evolution Data Server: {}", e))?;
85
+
let service = CalendarService::new(Box::new(repository));
86
+
87
+
match action {
88
+
SourcesCommands::List { format } => {
89
+
let format = parse_output_format(&format)?;
90
+
commands::sources::execute_list(&service, format)?;
91
+
}
92
+
}
93
+
}
94
+
Commands::Events { action } => {
95
+
// Create service (only when needed)
96
+
let repository = EdsRepository::new()
97
+
.map_err(|e| format!("Failed to initialize Evolution Data Server: {}", e))?;
98
+
let service = CalendarService::new(Box::new(repository));
99
+
100
+
match action {
101
+
EventsCommands::List(args) => {
102
+
let format = parse_output_format(&args.format)?;
103
+
let cmd_args = commands::events::ListEventsArgs {
104
+
source: args.source,
105
+
date_from: args.date_from,
106
+
date_until: args.date_until,
107
+
format,
108
+
};
109
+
commands::events::execute_list(&service, cmd_args)?;
110
+
}
111
+
}
112
+
}
113
+
}
114
+
115
+
Ok(())
116
+
}
117
+
118
+
/// Parses output format string
119
+
fn parse_output_format(format_str: &str) -> Result<OutputFormat, String> {
120
+
OutputFormat::from_str(format_str).ok_or_else(|| {
121
+
format!(
122
+
"Invalid output format: {}. Use 'table', 'json', or 'simple'",
123
+
format_str
124
+
)
125
+
})
126
+
}
+197
crates/alarma-cli/src/output/mod.rs
+197
crates/alarma-cli/src/output/mod.rs
···
1
+
//! Output formatting for calendar data
2
+
//!
3
+
//! This module provides different output formats for displaying calendar data.
4
+
5
+
use alarma_core::{CalendarEvent, CalendarSource, EventTime};
6
+
use std::io;
7
+
use tabled::{settings::Style, Table, Tabled};
8
+
9
+
/// Output format for displaying data
10
+
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11
+
pub enum OutputFormat {
12
+
/// Human-readable table format
13
+
Table,
14
+
/// JSON format
15
+
Json,
16
+
/// Simple line-by-line format
17
+
Simple,
18
+
}
19
+
20
+
impl OutputFormat {
21
+
pub fn from_str(s: &str) -> Option<Self> {
22
+
match s.to_lowercase().as_str() {
23
+
"table" => Some(OutputFormat::Table),
24
+
"json" => Some(OutputFormat::Json),
25
+
"simple" => Some(OutputFormat::Simple),
26
+
_ => None,
27
+
}
28
+
}
29
+
}
30
+
31
+
/// Formats and prints calendar sources
32
+
pub fn print_sources(sources: &[CalendarSource], format: OutputFormat) -> io::Result<()> {
33
+
match format {
34
+
OutputFormat::Table => print_sources_table(sources),
35
+
OutputFormat::Json => print_sources_json(sources),
36
+
OutputFormat::Simple => print_sources_simple(sources),
37
+
}
38
+
}
39
+
40
+
/// Formats and prints calendar events
41
+
pub fn print_events(events: &[CalendarEvent], format: OutputFormat) -> io::Result<()> {
42
+
match format {
43
+
OutputFormat::Table => print_events_table(events),
44
+
OutputFormat::Json => print_events_json(events),
45
+
OutputFormat::Simple => print_events_simple(events),
46
+
}
47
+
}
48
+
49
+
#[derive(Tabled)]
50
+
struct SourceRow {
51
+
#[tabled(rename = "UID")]
52
+
uid: String,
53
+
#[tabled(rename = "Display Name")]
54
+
display_name: String,
55
+
#[tabled(rename = "Enabled")]
56
+
enabled: String,
57
+
}
58
+
59
+
fn print_sources_table(sources: &[CalendarSource]) -> io::Result<()> {
60
+
if sources.is_empty() {
61
+
println!("No calendar sources found.");
62
+
return Ok(());
63
+
}
64
+
65
+
let rows: Vec<SourceRow> = sources
66
+
.iter()
67
+
.map(|s| SourceRow {
68
+
uid: s.uid.clone(),
69
+
display_name: s.display_name.clone(),
70
+
enabled: if s.enabled { "Yes" } else { "No" }.to_string(),
71
+
})
72
+
.collect();
73
+
74
+
let mut table = Table::new(rows);
75
+
table.with(Style::modern());
76
+
println!("{}", table);
77
+
println!("\nTotal: {} source(s)", sources.len());
78
+
Ok(())
79
+
}
80
+
81
+
fn print_sources_json(sources: &[CalendarSource]) -> io::Result<()> {
82
+
let json = serde_json::to_string_pretty(sources).map_err(|e| {
83
+
io::Error::new(
84
+
io::ErrorKind::Other,
85
+
format!("JSON serialization error: {}", e),
86
+
)
87
+
})?;
88
+
println!("{}", json);
89
+
Ok(())
90
+
}
91
+
92
+
fn print_sources_simple(sources: &[CalendarSource]) -> io::Result<()> {
93
+
for source in sources {
94
+
println!("{} - {}", source.uid, source.display_name);
95
+
}
96
+
println!("\nTotal: {} source(s)", sources.len());
97
+
Ok(())
98
+
}
99
+
100
+
#[derive(Tabled)]
101
+
struct EventRow {
102
+
#[tabled(rename = "Calendar")]
103
+
source: String,
104
+
#[tabled(rename = "Summary")]
105
+
summary: String,
106
+
#[tabled(rename = "Start")]
107
+
start: String,
108
+
#[tabled(rename = "End")]
109
+
end: String,
110
+
#[tabled(rename = "Location")]
111
+
location: String,
112
+
}
113
+
114
+
fn print_events_table(events: &[CalendarEvent]) -> io::Result<()> {
115
+
if events.is_empty() {
116
+
println!("No events found.");
117
+
return Ok(());
118
+
}
119
+
120
+
let rows: Vec<EventRow> = events
121
+
.iter()
122
+
.map(|e| {
123
+
let (start_str, end_str) = format_event_times(&e.start, &e.end);
124
+
EventRow {
125
+
source: e.source_uid.clone(),
126
+
summary: e.summary.clone(),
127
+
start: start_str,
128
+
end: end_str,
129
+
location: e.location.clone().unwrap_or_else(|| "-".to_string()),
130
+
}
131
+
})
132
+
.collect();
133
+
134
+
let mut table = Table::new(rows);
135
+
table.with(Style::modern());
136
+
println!("{}", table);
137
+
println!("\nTotal: {} event(s)", events.len());
138
+
Ok(())
139
+
}
140
+
141
+
fn print_events_json(events: &[CalendarEvent]) -> io::Result<()> {
142
+
let json = serde_json::to_string_pretty(events).map_err(|e| {
143
+
io::Error::new(
144
+
io::ErrorKind::Other,
145
+
format!("JSON serialization error: {}", e),
146
+
)
147
+
})?;
148
+
println!("{}", json);
149
+
Ok(())
150
+
}
151
+
152
+
fn print_events_simple(events: &[CalendarEvent]) -> io::Result<()> {
153
+
for event in events {
154
+
let (start_str, end_str) = format_event_times(&event.start, &event.end);
155
+
println!(
156
+
"[{}] {} | {} - {}",
157
+
event.source_uid, event.summary, start_str, end_str
158
+
);
159
+
if let Some(location) = &event.location {
160
+
println!(" Location: {}", location);
161
+
}
162
+
}
163
+
println!("\nTotal: {} event(s)", events.len());
164
+
Ok(())
165
+
}
166
+
167
+
/// Formats event start and end times for display
168
+
fn format_event_times(start: &EventTime, end: &EventTime) -> (String, String) {
169
+
match (start, end) {
170
+
(EventTime::Date(start_date), EventTime::Date(end_date)) => {
171
+
// All-day event
172
+
let start = start_date.format("%Y-%m-%d").to_string();
173
+
let end = if start_date == end_date {
174
+
"(all day)".to_string()
175
+
} else {
176
+
end_date.format("%Y-%m-%d").to_string()
177
+
};
178
+
(start, end)
179
+
}
180
+
(EventTime::DateTime(start_dt), EventTime::DateTime(end_dt)) => {
181
+
// Timed event
182
+
let start = start_dt.format("%Y-%m-%d %H:%M").to_string();
183
+
let end = if start_dt.date_naive() == end_dt.date_naive() {
184
+
// Same day - just show time
185
+
end_dt.format("%H:%M").to_string()
186
+
} else {
187
+
// Different day - show full datetime
188
+
end_dt.format("%Y-%m-%d %H:%M").to_string()
189
+
};
190
+
(start, end)
191
+
}
192
+
_ => {
193
+
// Mixed types (shouldn't happen, but handle gracefully)
194
+
(start.format("%Y-%m-%d %H:%M"), end.format("%H:%M"))
195
+
}
196
+
}
197
+
}
+77
crates/alarma-cli/tests/output_tests.rs
+77
crates/alarma-cli/tests/output_tests.rs
···
1
+
//! Tests for alarma-cli output formatting
2
+
3
+
use alarma_cli::output::{print_events, print_sources, OutputFormat};
4
+
use alarma_core::domain::{CalendarEvent, CalendarSource, EventTime};
5
+
use chrono::{Local, TimeZone};
6
+
7
+
fn make_datetime(
8
+
year: i32,
9
+
month: u32,
10
+
day: u32,
11
+
hour: u32,
12
+
min: u32,
13
+
sec: u32,
14
+
) -> chrono::DateTime<Local> {
15
+
Local
16
+
.with_ymd_and_hms(year, month, day, hour, min, sec)
17
+
.unwrap()
18
+
}
19
+
20
+
#[test]
21
+
fn test_print_sources_table() {
22
+
let sources = vec![
23
+
CalendarSource::new("uid-1".to_string(), "Personal".to_string()),
24
+
CalendarSource::new("uid-2".to_string(), "Work".to_string()),
25
+
];
26
+
27
+
// Should not panic
28
+
let result = print_sources(&sources, OutputFormat::Table);
29
+
assert!(result.is_ok());
30
+
}
31
+
32
+
#[test]
33
+
fn test_print_sources_json() {
34
+
let sources = vec![CalendarSource::new(
35
+
"uid-1".to_string(),
36
+
"Personal".to_string(),
37
+
)];
38
+
39
+
let result = print_sources(&sources, OutputFormat::Json);
40
+
assert!(result.is_ok());
41
+
}
42
+
43
+
#[test]
44
+
fn test_print_events_table() {
45
+
let events = vec![CalendarEvent::new(
46
+
"event-1".to_string(),
47
+
"Meeting".to_string(),
48
+
EventTime::DateTime(make_datetime(2026, 1, 15, 10, 0, 0)),
49
+
EventTime::DateTime(make_datetime(2026, 1, 15, 11, 0, 0)),
50
+
"source-1".to_string(),
51
+
)];
52
+
53
+
let result = print_events(&events, OutputFormat::Table);
54
+
assert!(result.is_ok());
55
+
}
56
+
57
+
#[test]
58
+
fn test_print_events_json() {
59
+
let events = vec![CalendarEvent::new(
60
+
"event-1".to_string(),
61
+
"Meeting".to_string(),
62
+
EventTime::DateTime(make_datetime(2026, 1, 15, 10, 0, 0)),
63
+
EventTime::DateTime(make_datetime(2026, 1, 15, 11, 0, 0)),
64
+
"source-1".to_string(),
65
+
)];
66
+
67
+
let result = print_events(&events, OutputFormat::Json);
68
+
assert!(result.is_ok());
69
+
}
70
+
71
+
#[test]
72
+
fn test_output_format_from_str() {
73
+
assert_eq!(OutputFormat::from_str("table"), Some(OutputFormat::Table));
74
+
assert_eq!(OutputFormat::from_str("json"), Some(OutputFormat::Json));
75
+
assert_eq!(OutputFormat::from_str("simple"), Some(OutputFormat::Simple));
76
+
assert_eq!(OutputFormat::from_str("invalid"), None);
77
+
}
+13
crates/alarma-core/Cargo.toml
+13
crates/alarma-core/Cargo.toml
···
1
+
[package]
2
+
name = "alarma-core"
3
+
version = "0.1.0"
4
+
edition = "2021"
5
+
description = "Core domain models and business logic for Alarma calendar tool"
6
+
7
+
[dependencies]
8
+
chrono = { version = "0.4", default-features = false, features = ["clock", "std"] }
9
+
serde = { version = "1.0", features = ["derive"], optional = true }
10
+
11
+
[features]
12
+
default = []
13
+
serde = ["dep:serde", "chrono/serde"]
+196
crates/alarma-core/src/domain/event.rs
+196
crates/alarma-core/src/domain/event.rs
···
1
+
//! Domain model for calendar events
2
+
//!
3
+
//! This module defines the Event type and related structures.
4
+
5
+
use chrono::{DateTime, Local, NaiveDate};
6
+
7
+
#[cfg(feature = "serde")]
8
+
use serde::{Deserialize, Deserializer, Serialize, Serializer};
9
+
10
+
#[cfg(feature = "serde")]
11
+
mod datetime_local_serde {
12
+
use super::*;
13
+
use chrono::{DateTime, Local, TimeZone};
14
+
15
+
pub fn serialize<S>(dt: &DateTime<Local>, serializer: S) -> Result<S::Ok, S::Error>
16
+
where
17
+
S: Serializer,
18
+
{
19
+
serializer.serialize_str(&dt.to_rfc3339())
20
+
}
21
+
22
+
pub fn deserialize<'de, D>(deserializer: D) -> Result<DateTime<Local>, D::Error>
23
+
where
24
+
D: Deserializer<'de>,
25
+
{
26
+
let s = String::deserialize(deserializer)?;
27
+
DateTime::parse_from_rfc3339(&s)
28
+
.map(|dt| dt.with_timezone(&Local))
29
+
.map_err(serde::de::Error::custom)
30
+
}
31
+
}
32
+
33
+
/// Represents the time information for an event
34
+
///
35
+
/// Events can be either all-day (represented by a date) or timed (represented by a datetime).
36
+
#[derive(Debug, Clone, PartialEq, Eq)]
37
+
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
38
+
#[cfg_attr(
39
+
feature = "serde",
40
+
serde(tag = "type", content = "value", rename_all = "lowercase")
41
+
)]
42
+
pub enum EventTime {
43
+
/// All-day event (no specific time)
44
+
Date(NaiveDate),
45
+
/// Timed event with specific datetime
46
+
#[cfg_attr(feature = "serde", serde(with = "datetime_local_serde"))]
47
+
DateTime(DateTime<Local>),
48
+
}
49
+
50
+
impl EventTime {
51
+
/// Formats the event time using the given format string
52
+
pub fn format(&self, fmt: &str) -> String {
53
+
match self {
54
+
EventTime::DateTime(dt) => dt.format(fmt).to_string(),
55
+
EventTime::Date(date) => date.format(fmt).to_string(),
56
+
}
57
+
}
58
+
59
+
/// Converts to Unix timestamp (seconds since epoch)
60
+
pub fn timestamp(&self) -> i64 {
61
+
match self {
62
+
EventTime::DateTime(dt) => dt.timestamp(),
63
+
EventTime::Date(date) => date
64
+
.and_hms_opt(0, 0, 0)
65
+
.and_then(|dt| dt.and_local_timezone(Local).single())
66
+
.map(|dt| dt.timestamp())
67
+
.unwrap_or(0),
68
+
}
69
+
}
70
+
71
+
/// Returns true if this is an all-day event
72
+
pub fn is_all_day(&self) -> bool {
73
+
matches!(self, EventTime::Date(_))
74
+
}
75
+
}
76
+
77
+
/// Represents a calendar event
78
+
#[derive(Debug, Clone)]
79
+
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
80
+
pub struct CalendarEvent {
81
+
/// Unique identifier for the event
82
+
pub uid: String,
83
+
/// Event title/summary
84
+
pub summary: String,
85
+
/// Optional detailed description
86
+
pub description: Option<String>,
87
+
/// Optional location
88
+
pub location: Option<String>,
89
+
/// Start time
90
+
pub start: EventTime,
91
+
/// End time
92
+
pub end: EventTime,
93
+
/// Source UID (which calendar this event belongs to)
94
+
pub source_uid: String,
95
+
}
96
+
97
+
impl CalendarEvent {
98
+
/// Creates a new calendar event
99
+
pub fn new(
100
+
uid: String,
101
+
summary: String,
102
+
start: EventTime,
103
+
end: EventTime,
104
+
source_uid: String,
105
+
) -> Self {
106
+
Self {
107
+
uid,
108
+
summary,
109
+
description: None,
110
+
location: None,
111
+
start,
112
+
end,
113
+
source_uid,
114
+
}
115
+
}
116
+
117
+
/// Sets the description
118
+
pub fn with_description(mut self, description: Option<String>) -> Self {
119
+
self.description = description;
120
+
self
121
+
}
122
+
123
+
/// Sets the location
124
+
pub fn with_location(mut self, location: Option<String>) -> Self {
125
+
self.location = location;
126
+
self
127
+
}
128
+
129
+
/// Returns true if this is an all-day event
130
+
pub fn is_all_day(&self) -> bool {
131
+
self.start.is_all_day() && self.end.is_all_day()
132
+
}
133
+
134
+
/// Returns the duration of the event in seconds
135
+
pub fn duration_seconds(&self) -> i64 {
136
+
self.end.timestamp() - self.start.timestamp()
137
+
}
138
+
}
139
+
140
+
#[cfg(test)]
141
+
mod tests {
142
+
use super::*;
143
+
use chrono::TimeZone;
144
+
145
+
#[test]
146
+
fn test_all_day_event() {
147
+
let start = EventTime::Date(NaiveDate::from_ymd_opt(2026, 1, 15).unwrap());
148
+
let end = EventTime::Date(NaiveDate::from_ymd_opt(2026, 1, 15).unwrap());
149
+
150
+
let event = CalendarEvent::new(
151
+
"test-uid".to_string(),
152
+
"Test Event".to_string(),
153
+
start,
154
+
end,
155
+
"source-uid".to_string(),
156
+
);
157
+
158
+
assert!(event.is_all_day());
159
+
}
160
+
161
+
#[test]
162
+
fn test_timed_event() {
163
+
let start = EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 15, 10, 0, 0).unwrap());
164
+
let end = EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 15, 11, 0, 0).unwrap());
165
+
166
+
let event = CalendarEvent::new(
167
+
"test-uid".to_string(),
168
+
"Test Event".to_string(),
169
+
start,
170
+
end,
171
+
"source-uid".to_string(),
172
+
);
173
+
174
+
assert!(!event.is_all_day());
175
+
assert_eq!(event.duration_seconds(), 3600); // 1 hour
176
+
}
177
+
178
+
#[test]
179
+
fn test_event_with_details() {
180
+
let start = EventTime::Date(NaiveDate::from_ymd_opt(2026, 1, 15).unwrap());
181
+
let end = EventTime::Date(NaiveDate::from_ymd_opt(2026, 1, 15).unwrap());
182
+
183
+
let event = CalendarEvent::new(
184
+
"test-uid".to_string(),
185
+
"Test Event".to_string(),
186
+
start,
187
+
end,
188
+
"source-uid".to_string(),
189
+
)
190
+
.with_description(Some("Test description".to_string()))
191
+
.with_location(Some("Test location".to_string()));
192
+
193
+
assert_eq!(event.description, Some("Test description".to_string()));
194
+
assert_eq!(event.location, Some("Test location".to_string()));
195
+
}
196
+
}
+7
crates/alarma-core/src/domain/mod.rs
+7
crates/alarma-core/src/domain/mod.rs
+87
crates/alarma-core/src/domain/source.rs
+87
crates/alarma-core/src/domain/source.rs
···
1
+
//! Domain model for calendar sources
2
+
//!
3
+
//! This module defines the CalendarSource type representing a calendar.
4
+
5
+
#[cfg(feature = "serde")]
6
+
use serde::{Deserialize, Serialize};
7
+
8
+
/// Represents a calendar source (e.g., a calendar in EDS, CalDAV, etc.)
9
+
#[derive(Debug, Clone, PartialEq, Eq)]
10
+
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
11
+
pub struct CalendarSource {
12
+
/// Unique identifier for this source
13
+
pub uid: String,
14
+
/// Human-readable display name
15
+
pub display_name: String,
16
+
/// Optional description
17
+
pub description: Option<String>,
18
+
/// Color hint for UI (hex format, e.g., "#FF0000")
19
+
pub color: Option<String>,
20
+
/// Whether this source is enabled
21
+
pub enabled: bool,
22
+
/// Whether this source is read-only
23
+
pub read_only: bool,
24
+
}
25
+
26
+
impl CalendarSource {
27
+
/// Creates a new calendar source with minimal information
28
+
pub fn new(uid: String, display_name: String) -> Self {
29
+
Self {
30
+
uid,
31
+
display_name,
32
+
description: None,
33
+
color: None,
34
+
enabled: true,
35
+
read_only: false,
36
+
}
37
+
}
38
+
39
+
/// Creates a new calendar source with all fields
40
+
pub fn with_details(
41
+
uid: String,
42
+
display_name: String,
43
+
description: Option<String>,
44
+
color: Option<String>,
45
+
enabled: bool,
46
+
read_only: bool,
47
+
) -> Self {
48
+
Self {
49
+
uid,
50
+
display_name,
51
+
description,
52
+
color,
53
+
enabled,
54
+
read_only,
55
+
}
56
+
}
57
+
}
58
+
59
+
#[cfg(test)]
60
+
mod tests {
61
+
use super::*;
62
+
63
+
#[test]
64
+
fn test_create_minimal_source() {
65
+
let source = CalendarSource::new("uid-123".to_string(), "My Calendar".to_string());
66
+
67
+
assert_eq!(source.uid, "uid-123");
68
+
assert_eq!(source.display_name, "My Calendar");
69
+
assert!(source.enabled);
70
+
assert!(!source.read_only);
71
+
}
72
+
73
+
#[test]
74
+
fn test_create_detailed_source() {
75
+
let source = CalendarSource::with_details(
76
+
"uid-123".to_string(),
77
+
"My Calendar".to_string(),
78
+
Some("Personal calendar".to_string()),
79
+
Some("#FF0000".to_string()),
80
+
true,
81
+
false,
82
+
);
83
+
84
+
assert_eq!(source.description, Some("Personal calendar".to_string()));
85
+
assert_eq!(source.color, Some("#FF0000".to_string()));
86
+
}
87
+
}
+97
crates/alarma-core/src/error.rs
+97
crates/alarma-core/src/error.rs
···
1
+
//! Error types for Alarma
2
+
//!
3
+
//! This module defines all error types used throughout the application.
4
+
5
+
use std::fmt;
6
+
7
+
/// Main error type for Alarma operations
8
+
#[derive(Debug)]
9
+
pub enum AlarmaError {
10
+
/// Calendar source was not found
11
+
SourceNotFound(String),
12
+
13
+
/// Failed to connect to a calendar source
14
+
ConnectionFailed(String),
15
+
16
+
/// Failed to initialize the calendar system
17
+
InitializationFailed(String),
18
+
19
+
/// Failed to query events
20
+
QueryFailed(String),
21
+
22
+
/// Invalid date or time format
23
+
InvalidDateTime(String),
24
+
25
+
/// Invalid date range (end before start)
26
+
InvalidDateRange(String),
27
+
28
+
/// Date parsing error
29
+
DateParseError(chrono::ParseError),
30
+
31
+
/// Generic I/O error
32
+
IoError(std::io::Error),
33
+
34
+
/// Repository-specific error (from implementation layer)
35
+
RepositoryError(String),
36
+
37
+
/// Configuration error
38
+
ConfigError(String),
39
+
}
40
+
41
+
impl fmt::Display for AlarmaError {
42
+
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
43
+
match self {
44
+
AlarmaError::SourceNotFound(msg) => write!(f, "Calendar source not found: {}", msg),
45
+
AlarmaError::ConnectionFailed(msg) => {
46
+
write!(f, "Failed to connect to calendar: {}", msg)
47
+
}
48
+
AlarmaError::InitializationFailed(msg) => {
49
+
write!(f, "Failed to initialize calendar system: {}", msg)
50
+
}
51
+
AlarmaError::QueryFailed(msg) => write!(f, "Failed to query events: {}", msg),
52
+
AlarmaError::InvalidDateTime(msg) => write!(f, "Invalid date/time: {}", msg),
53
+
AlarmaError::InvalidDateRange(msg) => write!(f, "Invalid date range: {}", msg),
54
+
AlarmaError::DateParseError(err) => write!(f, "Failed to parse date: {}", err),
55
+
AlarmaError::IoError(err) => write!(f, "I/O error: {}", err),
56
+
AlarmaError::RepositoryError(msg) => write!(f, "Repository error: {}", msg),
57
+
AlarmaError::ConfigError(msg) => write!(f, "Configuration error: {}", msg),
58
+
}
59
+
}
60
+
}
61
+
62
+
impl std::error::Error for AlarmaError {
63
+
fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
64
+
match self {
65
+
AlarmaError::DateParseError(err) => Some(err),
66
+
AlarmaError::IoError(err) => Some(err),
67
+
_ => None,
68
+
}
69
+
}
70
+
}
71
+
72
+
impl From<chrono::ParseError> for AlarmaError {
73
+
fn from(err: chrono::ParseError) -> Self {
74
+
AlarmaError::DateParseError(err)
75
+
}
76
+
}
77
+
78
+
impl From<std::io::Error> for AlarmaError {
79
+
fn from(err: std::io::Error) -> Self {
80
+
AlarmaError::IoError(err)
81
+
}
82
+
}
83
+
84
+
/// Result type alias for Alarma operations
85
+
pub type Result<T> = std::result::Result<T, AlarmaError>;
86
+
87
+
impl AlarmaError {
88
+
/// Creates a repository error with a custom message
89
+
pub fn repository<S: Into<String>>(msg: S) -> Self {
90
+
AlarmaError::RepositoryError(msg.into())
91
+
}
92
+
93
+
/// Creates a configuration error with a custom message
94
+
pub fn config<S: Into<String>>(msg: S) -> Self {
95
+
AlarmaError::ConfigError(msg.into())
96
+
}
97
+
}
+38
crates/alarma-core/src/lib.rs
+38
crates/alarma-core/src/lib.rs
···
1
+
//! Alarma Core Library
2
+
//!
3
+
//! This library provides the core domain models, business logic, and abstractions
4
+
//! for the Alarma calendar management system. It is platform-agnostic and contains
5
+
//! no implementation-specific code.
6
+
//!
7
+
//! # Architecture
8
+
//!
9
+
//! - **domain**: Core domain models (Event, CalendarSource, etc.)
10
+
//! - **repository**: Abstract repository trait for data access
11
+
//! - **service**: Business logic and orchestration
12
+
//! - **error**: Error types and result aliases
13
+
//!
14
+
//! # Example
15
+
//!
16
+
//! ```rust,no_run
17
+
//! use alarma_core::{CalendarService, repository::DateRange};
18
+
//!
19
+
//! fn example(service: CalendarService) {
20
+
//! // List all calendar sources
21
+
//! let sources = service.list_sources().unwrap();
22
+
//!
23
+
//! // List events for the next 30 days
24
+
//! let range = DateRange::from_now_to_days_ahead(30);
25
+
//! let events = service.list_all_events(range).unwrap();
26
+
//! }
27
+
//! ```
28
+
29
+
pub mod domain;
30
+
pub mod error;
31
+
pub mod repository;
32
+
pub mod service;
33
+
34
+
// Re-export commonly used types
35
+
pub use domain::{CalendarEvent, CalendarSource, EventTime};
36
+
pub use error::{AlarmaError, Result};
37
+
pub use repository::{CalendarRepository, DateRange};
38
+
pub use service::CalendarService;
+152
crates/alarma-core/src/repository.rs
+152
crates/alarma-core/src/repository.rs
···
1
+
//! Repository trait defining calendar data access
2
+
//!
3
+
//! This module defines the abstract interface for calendar data access,
4
+
//! allowing different implementations (EDS, CalDAV, Google Calendar, etc.)
5
+
6
+
use crate::domain::{CalendarEvent, CalendarSource};
7
+
use crate::error::Result;
8
+
use chrono::{DateTime, Local};
9
+
10
+
/// Represents a date range for querying events
11
+
#[derive(Debug, Clone, Copy)]
12
+
pub struct DateRange {
13
+
/// Start of the range (inclusive)
14
+
pub start: DateTime<Local>,
15
+
/// End of the range (exclusive)
16
+
pub end: DateTime<Local>,
17
+
}
18
+
19
+
impl DateRange {
20
+
/// Creates a new date range
21
+
pub fn new(start: DateTime<Local>, end: DateTime<Local>) -> Result<Self> {
22
+
if end <= start {
23
+
return Err(crate::error::AlarmaError::InvalidDateRange(format!(
24
+
"end time {} is before start time {}",
25
+
end.to_rfc3339(),
26
+
start.to_rfc3339()
27
+
)));
28
+
}
29
+
Ok(Self { start, end })
30
+
}
31
+
32
+
/// Creates a date range from now to the specified duration ahead
33
+
pub fn from_now_to_days_ahead(days: u32) -> Self {
34
+
let start = Local::now();
35
+
let end = start + chrono::Duration::days(days as i64);
36
+
Self { start, end }
37
+
}
38
+
39
+
/// Converts start time to Unix timestamp
40
+
pub fn start_timestamp(&self) -> i64 {
41
+
self.start.timestamp()
42
+
}
43
+
44
+
/// Converts end time to Unix timestamp
45
+
pub fn end_timestamp(&self) -> i64 {
46
+
self.end.timestamp()
47
+
}
48
+
}
49
+
50
+
/// Abstract trait for calendar data access
51
+
///
52
+
/// This trait defines the interface that all calendar backends must implement.
53
+
/// It allows the application to work with different calendar systems without
54
+
/// coupling to any specific implementation.
55
+
pub trait CalendarRepository: Send + Sync {
56
+
/// Lists all available calendar sources
57
+
///
58
+
/// # Returns
59
+
///
60
+
/// A vector of calendar sources available in the system
61
+
fn list_sources(&self) -> Result<Vec<CalendarSource>>;
62
+
63
+
/// Finds a calendar source by its UID
64
+
///
65
+
/// # Arguments
66
+
///
67
+
/// * `uid` - The unique identifier of the source
68
+
///
69
+
/// # Returns
70
+
///
71
+
/// The calendar source if found, or an error if not found
72
+
fn find_source(&self, uid: &str) -> Result<CalendarSource> {
73
+
self.list_sources()?
74
+
.into_iter()
75
+
.find(|s| s.uid == uid)
76
+
.ok_or_else(|| crate::error::AlarmaError::SourceNotFound(uid.to_string()))
77
+
}
78
+
79
+
/// Lists events from a specific source within a date range
80
+
///
81
+
/// # Arguments
82
+
///
83
+
/// * `source_uid` - The UID of the calendar source
84
+
/// * `range` - The date range to query
85
+
///
86
+
/// # Returns
87
+
///
88
+
/// A vector of events within the specified range
89
+
fn list_events(&self, source_uid: &str, range: DateRange) -> Result<Vec<CalendarEvent>>;
90
+
91
+
/// Lists events from all sources within a date range
92
+
///
93
+
/// # Arguments
94
+
///
95
+
/// * `range` - The date range to query
96
+
///
97
+
/// # Returns
98
+
///
99
+
/// A vector of events from all sources within the specified range
100
+
fn list_all_events(&self, range: DateRange) -> Result<Vec<CalendarEvent>> {
101
+
let sources = self.list_sources()?;
102
+
let mut all_events = Vec::new();
103
+
104
+
for source in sources {
105
+
match self.list_events(&source.uid, range) {
106
+
Ok(mut events) => all_events.append(&mut events),
107
+
Err(e) => {
108
+
// Log error but continue with other sources
109
+
eprintln!(
110
+
"Warning: Failed to get events from '{}': {}",
111
+
source.display_name, e
112
+
);
113
+
}
114
+
}
115
+
}
116
+
117
+
Ok(all_events)
118
+
}
119
+
}
120
+
121
+
#[cfg(test)]
122
+
mod tests {
123
+
use super::*;
124
+
use chrono::TimeZone;
125
+
126
+
#[test]
127
+
fn test_date_range_creation() {
128
+
let start = Local.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap();
129
+
let end = Local.with_ymd_and_hms(2026, 12, 31, 23, 59, 59).unwrap();
130
+
131
+
let range = DateRange::new(start, end).unwrap();
132
+
assert_eq!(range.start, start);
133
+
assert_eq!(range.end, end);
134
+
}
135
+
136
+
#[test]
137
+
fn test_invalid_date_range() {
138
+
let start = Local.with_ymd_and_hms(2026, 12, 31, 0, 0, 0).unwrap();
139
+
let end = Local.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap();
140
+
141
+
let result = DateRange::new(start, end);
142
+
assert!(result.is_err());
143
+
}
144
+
145
+
#[test]
146
+
fn test_date_range_from_now() {
147
+
let range = DateRange::from_now_to_days_ahead(30);
148
+
let expected_duration = range.end.timestamp() - range.start.timestamp();
149
+
// Should be approximately 30 days (allowing for some milliseconds difference)
150
+
assert!((expected_duration - (30 * 24 * 3600)).abs() < 2);
151
+
}
152
+
}
+170
crates/alarma-core/src/service.rs
+170
crates/alarma-core/src/service.rs
···
1
+
//! Business logic and service layer
2
+
//!
3
+
//! This module provides high-level operations for calendar management.
4
+
5
+
use crate::domain::{CalendarEvent, CalendarSource};
6
+
use crate::error::Result;
7
+
use crate::repository::{CalendarRepository, DateRange};
8
+
9
+
/// Service for calendar operations
10
+
///
11
+
/// This service encapsulates business logic and coordinates between
12
+
/// the domain layer and repository implementations.
13
+
pub struct CalendarService {
14
+
repository: Box<dyn CalendarRepository>,
15
+
}
16
+
17
+
impl CalendarService {
18
+
/// Creates a new calendar service with the given repository
19
+
pub fn new(repository: Box<dyn CalendarRepository>) -> Self {
20
+
Self { repository }
21
+
}
22
+
23
+
/// Lists all available calendar sources
24
+
pub fn list_sources(&self) -> Result<Vec<CalendarSource>> {
25
+
self.repository.list_sources()
26
+
}
27
+
28
+
/// Finds a calendar source by UID
29
+
pub fn find_source(&self, uid: &str) -> Result<CalendarSource> {
30
+
self.repository.find_source(uid)
31
+
}
32
+
33
+
/// Lists events from a specific source
34
+
pub fn list_events(&self, source_uid: &str, range: DateRange) -> Result<Vec<CalendarEvent>> {
35
+
// Validate that the source exists first
36
+
let _source = self.repository.find_source(source_uid)?;
37
+
38
+
self.repository.list_events(source_uid, range)
39
+
}
40
+
41
+
/// Lists events from all sources
42
+
pub fn list_all_events(&self, range: DateRange) -> Result<Vec<CalendarEvent>> {
43
+
let mut events = self.repository.list_all_events(range)?;
44
+
45
+
// Sort events by start time
46
+
events.sort_by_key(|e| e.start.timestamp());
47
+
48
+
Ok(events)
49
+
}
50
+
51
+
/// Lists events from multiple specific sources
52
+
pub fn list_events_from_sources(
53
+
&self,
54
+
source_uids: &[String],
55
+
range: DateRange,
56
+
) -> Result<Vec<CalendarEvent>> {
57
+
let mut all_events = Vec::new();
58
+
59
+
for uid in source_uids {
60
+
match self.list_events(uid, range) {
61
+
Ok(mut events) => all_events.append(&mut events),
62
+
Err(e) => {
63
+
eprintln!("Warning: Failed to get events from '{}': {}", uid, e);
64
+
}
65
+
}
66
+
}
67
+
68
+
// Sort events by start time
69
+
all_events.sort_by_key(|e| e.start.timestamp());
70
+
71
+
Ok(all_events)
72
+
}
73
+
}
74
+
75
+
#[cfg(test)]
76
+
mod tests {
77
+
use super::*;
78
+
use crate::domain::{CalendarEvent, CalendarSource, EventTime};
79
+
use chrono::{Local, TimeZone};
80
+
81
+
// Mock repository for testing
82
+
struct MockRepository {
83
+
sources: Vec<CalendarSource>,
84
+
events: Vec<CalendarEvent>,
85
+
}
86
+
87
+
impl CalendarRepository for MockRepository {
88
+
fn list_sources(&self) -> Result<Vec<CalendarSource>> {
89
+
Ok(self.sources.clone())
90
+
}
91
+
92
+
fn list_events(&self, source_uid: &str, _range: DateRange) -> Result<Vec<CalendarEvent>> {
93
+
Ok(self
94
+
.events
95
+
.iter()
96
+
.filter(|e| e.source_uid == source_uid)
97
+
.cloned()
98
+
.collect())
99
+
}
100
+
}
101
+
102
+
fn create_test_service() -> CalendarService {
103
+
let sources = vec![
104
+
CalendarSource::new("source1".to_string(), "Calendar 1".to_string()),
105
+
CalendarSource::new("source2".to_string(), "Calendar 2".to_string()),
106
+
];
107
+
108
+
let events = vec![
109
+
CalendarEvent::new(
110
+
"event1".to_string(),
111
+
"Meeting".to_string(),
112
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 15, 10, 0, 0).unwrap()),
113
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 15, 11, 0, 0).unwrap()),
114
+
"source1".to_string(),
115
+
),
116
+
CalendarEvent::new(
117
+
"event2".to_string(),
118
+
"Lunch".to_string(),
119
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 15, 12, 0, 0).unwrap()),
120
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 15, 13, 0, 0).unwrap()),
121
+
"source2".to_string(),
122
+
),
123
+
];
124
+
125
+
let repo = MockRepository { sources, events };
126
+
CalendarService::new(Box::new(repo))
127
+
}
128
+
129
+
#[test]
130
+
fn test_list_sources() {
131
+
let service = create_test_service();
132
+
let sources = service.list_sources().unwrap();
133
+
assert_eq!(sources.len(), 2);
134
+
}
135
+
136
+
#[test]
137
+
fn test_find_source() {
138
+
let service = create_test_service();
139
+
let source = service.find_source("source1").unwrap();
140
+
assert_eq!(source.display_name, "Calendar 1");
141
+
}
142
+
143
+
#[test]
144
+
fn test_find_nonexistent_source() {
145
+
let service = create_test_service();
146
+
let result = service.find_source("nonexistent");
147
+
assert!(result.is_err());
148
+
}
149
+
150
+
#[test]
151
+
fn test_list_events() {
152
+
let service = create_test_service();
153
+
let range = DateRange::from_now_to_days_ahead(60);
154
+
let events = service.list_events("source1", range).unwrap();
155
+
assert_eq!(events.len(), 1);
156
+
assert_eq!(events[0].summary, "Meeting");
157
+
}
158
+
159
+
#[test]
160
+
fn test_list_all_events_sorted() {
161
+
let service = create_test_service();
162
+
let range = DateRange::from_now_to_days_ahead(60);
163
+
let events = service.list_all_events(range).unwrap();
164
+
165
+
// Events should be sorted by start time
166
+
assert_eq!(events.len(), 2);
167
+
assert_eq!(events[0].summary, "Meeting");
168
+
assert_eq!(events[1].summary, "Lunch");
169
+
}
170
+
}
+178
crates/alarma-core/tests/integration_tests.rs
+178
crates/alarma-core/tests/integration_tests.rs
···
1
+
//! Integration tests for alarma-core
2
+
3
+
use alarma_core::{
4
+
domain::{CalendarEvent, CalendarSource, EventTime},
5
+
repository::{CalendarRepository, DateRange},
6
+
CalendarService, Result,
7
+
};
8
+
use chrono::{Local, NaiveDate, TimeZone};
9
+
10
+
/// Mock repository for testing
11
+
struct MockRepository {
12
+
sources: Vec<CalendarSource>,
13
+
events: Vec<CalendarEvent>,
14
+
}
15
+
16
+
impl MockRepository {
17
+
fn new() -> Self {
18
+
let sources = vec![
19
+
CalendarSource::new("source-1".to_string(), "Personal".to_string()),
20
+
CalendarSource::new("source-2".to_string(), "Work".to_string()),
21
+
];
22
+
23
+
let events = vec![
24
+
CalendarEvent::new(
25
+
"event-1".to_string(),
26
+
"Team Meeting".to_string(),
27
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 20, 10, 0, 0).unwrap()),
28
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 20, 11, 0, 0).unwrap()),
29
+
"source-2".to_string(),
30
+
)
31
+
.with_location(Some("Conference Room A".to_string())),
32
+
CalendarEvent::new(
33
+
"event-2".to_string(),
34
+
"Birthday Party".to_string(),
35
+
EventTime::Date(NaiveDate::from_ymd_opt(2026, 1, 25).unwrap()),
36
+
EventTime::Date(NaiveDate::from_ymd_opt(2026, 1, 25).unwrap()),
37
+
"source-1".to_string(),
38
+
),
39
+
CalendarEvent::new(
40
+
"event-3".to_string(),
41
+
"Project Deadline".to_string(),
42
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 30, 17, 0, 0).unwrap()),
43
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 30, 18, 0, 0).unwrap()),
44
+
"source-2".to_string(),
45
+
)
46
+
.with_description(Some("Final submission".to_string())),
47
+
];
48
+
49
+
Self { sources, events }
50
+
}
51
+
}
52
+
53
+
impl CalendarRepository for MockRepository {
54
+
fn list_sources(&self) -> Result<Vec<CalendarSource>> {
55
+
Ok(self.sources.clone())
56
+
}
57
+
58
+
fn list_events(&self, source_uid: &str, _range: DateRange) -> Result<Vec<CalendarEvent>> {
59
+
Ok(self
60
+
.events
61
+
.iter()
62
+
.filter(|e| e.source_uid == source_uid)
63
+
.cloned()
64
+
.collect())
65
+
}
66
+
}
67
+
68
+
#[test]
69
+
fn test_service_list_sources() {
70
+
let repo = MockRepository::new();
71
+
let service = CalendarService::new(Box::new(repo));
72
+
73
+
let sources = service.list_sources().unwrap();
74
+
assert_eq!(sources.len(), 2);
75
+
assert_eq!(sources[0].display_name, "Personal");
76
+
assert_eq!(sources[1].display_name, "Work");
77
+
}
78
+
79
+
#[test]
80
+
fn test_service_find_source() {
81
+
let repo = MockRepository::new();
82
+
let service = CalendarService::new(Box::new(repo));
83
+
84
+
let source = service.find_source("source-1").unwrap();
85
+
assert_eq!(source.display_name, "Personal");
86
+
}
87
+
88
+
#[test]
89
+
fn test_service_find_nonexistent_source() {
90
+
let repo = MockRepository::new();
91
+
let service = CalendarService::new(Box::new(repo));
92
+
93
+
let result = service.find_source("nonexistent");
94
+
assert!(result.is_err());
95
+
}
96
+
97
+
#[test]
98
+
fn test_service_list_events_from_source() {
99
+
let repo = MockRepository::new();
100
+
let service = CalendarService::new(Box::new(repo));
101
+
102
+
let range = DateRange::from_now_to_days_ahead(60);
103
+
let events = service.list_events("source-2", range).unwrap();
104
+
105
+
assert_eq!(events.len(), 2);
106
+
assert!(events.iter().any(|e| e.summary == "Team Meeting"));
107
+
assert!(events.iter().any(|e| e.summary == "Project Deadline"));
108
+
}
109
+
110
+
#[test]
111
+
fn test_service_list_all_events_sorted() {
112
+
let repo = MockRepository::new();
113
+
let service = CalendarService::new(Box::new(repo));
114
+
115
+
let range = DateRange::from_now_to_days_ahead(60);
116
+
let events = service.list_all_events(range).unwrap();
117
+
118
+
assert_eq!(events.len(), 3);
119
+
120
+
// Should be sorted by start time
121
+
assert_eq!(events[0].summary, "Team Meeting"); // Jan 20
122
+
assert_eq!(events[1].summary, "Birthday Party"); // Jan 25
123
+
assert_eq!(events[2].summary, "Project Deadline"); // Jan 30
124
+
}
125
+
126
+
#[test]
127
+
fn test_event_is_all_day() {
128
+
let all_day = CalendarEvent::new(
129
+
"test".to_string(),
130
+
"Test".to_string(),
131
+
EventTime::Date(NaiveDate::from_ymd_opt(2026, 1, 1).unwrap()),
132
+
EventTime::Date(NaiveDate::from_ymd_opt(2026, 1, 1).unwrap()),
133
+
"source".to_string(),
134
+
);
135
+
assert!(all_day.is_all_day());
136
+
137
+
let timed = CalendarEvent::new(
138
+
"test".to_string(),
139
+
"Test".to_string(),
140
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 1, 10, 0, 0).unwrap()),
141
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 1, 11, 0, 0).unwrap()),
142
+
"source".to_string(),
143
+
);
144
+
assert!(!timed.is_all_day());
145
+
}
146
+
147
+
#[test]
148
+
fn test_event_duration() {
149
+
let event = CalendarEvent::new(
150
+
"test".to_string(),
151
+
"Test".to_string(),
152
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 1, 10, 0, 0).unwrap()),
153
+
EventTime::DateTime(Local.with_ymd_and_hms(2026, 1, 1, 12, 30, 0).unwrap()),
154
+
"source".to_string(),
155
+
);
156
+
157
+
// Duration should be 2.5 hours = 9000 seconds
158
+
assert_eq!(event.duration_seconds(), 9000);
159
+
}
160
+
161
+
#[test]
162
+
fn test_date_range_validation() {
163
+
let start = Local.with_ymd_and_hms(2026, 12, 31, 0, 0, 0).unwrap();
164
+
let end = Local.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap();
165
+
166
+
let result = DateRange::new(start, end);
167
+
assert!(result.is_err());
168
+
}
169
+
170
+
#[test]
171
+
fn test_date_range_timestamps() {
172
+
let start = Local.with_ymd_and_hms(2026, 1, 1, 0, 0, 0).unwrap();
173
+
let end = Local.with_ymd_and_hms(2026, 1, 31, 23, 59, 59).unwrap();
174
+
175
+
let range = DateRange::new(start, end).unwrap();
176
+
assert_eq!(range.start_timestamp(), start.timestamp());
177
+
assert_eq!(range.end_timestamp(), end.timestamp());
178
+
}
+14
crates/alarma-eds/Cargo.toml
+14
crates/alarma-eds/Cargo.toml
···
1
+
[package]
2
+
name = "alarma-eds"
3
+
version = "0.1.0"
4
+
edition = "2021"
5
+
description = "Evolution Data Server implementation for Alarma"
6
+
7
+
[dependencies]
8
+
alarma-core = { path = "../alarma-core" }
9
+
glib = "0.20"
10
+
chrono = "0.4"
11
+
libc = "0.2"
12
+
13
+
[build-dependencies]
14
+
pkg-config = "0.3"
+33
crates/alarma-eds/README.md
+33
crates/alarma-eds/README.md
···
1
+
# alarma-eds
2
+
3
+
Evolution Data Server implementation for Alarma calendar tool.
4
+
5
+
## Build Requirements
6
+
7
+
This crate requires the following system libraries:
8
+
- `libedataserver-1.2`
9
+
- `libecal-2.0`
10
+
- `libical-glib`
11
+
12
+
These are checked via `pkg-config` at build time.
13
+
14
+
## FFI Bindings
15
+
16
+
The FFI bindings are **checked into version control** in `src/bindings/eds_bindings.rs`. This means:
17
+
18
+
- **No need for bindgen or clang** during normal builds
19
+
- **Faster builds** - no binding generation step
20
+
- **More stable** - bindings don't change unless explicitly regenerated
21
+
22
+
### Regenerating Bindings
23
+
24
+
If you need to regenerate the bindings (e.g., after updating EDS version):
25
+
26
+
```bash
27
+
./generate_bindings.sh
28
+
```
29
+
30
+
This requires:
31
+
- `bindgen` CLI tool (`cargo install bindgen-cli`)
32
+
- EDS development headers
33
+
- `clang`/`libclang`
+14
crates/alarma-eds/build.rs
+14
crates/alarma-eds/build.rs
···
1
+
fn main() {
2
+
// Link to required libraries using pkg-config
3
+
pkg_config::Config::new()
4
+
.probe("libedataserver-1.2")
5
+
.expect("libedataserver-1.2 not found");
6
+
7
+
pkg_config::Config::new()
8
+
.probe("libecal-2.0")
9
+
.expect("libecal-2.0 not found");
10
+
11
+
pkg_config::Config::new()
12
+
.probe("libical-glib")
13
+
.expect("libical-glib not found");
14
+
}
+71
crates/alarma-eds/generate_bindings.sh
+71
crates/alarma-eds/generate_bindings.sh
···
1
+
#!/bin/bash
2
+
# Script to regenerate FFI bindings for Evolution Data Server
3
+
#
4
+
# This script generates the eds_bindings.rs file from the Evolution Data Server
5
+
# C headers. You only need to run this when updating to a new version of EDS
6
+
# or when changing which functions/types are exposed.
7
+
#
8
+
# Requirements:
9
+
# - libedataserver-1.2-dev
10
+
# - libecal-2.0-dev
11
+
# - libical-glib-dev
12
+
# - clang/libclang
13
+
#
14
+
# Usage:
15
+
# ./generate_bindings.sh
16
+
17
+
set -e
18
+
19
+
echo "Generating FFI bindings for Evolution Data Server..."
20
+
21
+
# Get include paths from pkg-config
22
+
EDS_CFLAGS=$(pkg-config --cflags libedataserver-1.2 libecal-2.0 libical-glib)
23
+
24
+
# Create temporary wrapper header
25
+
cat > /tmp/wrapper.h << 'EOF'
26
+
#include <libedataserver/libedataserver.h>
27
+
#include <libecal/libecal.h>
28
+
#include <libical-glib/libical-glib.h>
29
+
EOF
30
+
31
+
# Generate bindings using bindgen
32
+
bindgen /tmp/wrapper.h \
33
+
--output src/bindings/eds_bindings.rs \
34
+
--allowlist-function 'e_source_registry_.*' \
35
+
--allowlist-function 'e_source_.*' \
36
+
--allowlist-function 'e_cal_client_.*' \
37
+
--allowlist-function 'i_cal_.*' \
38
+
--allowlist-function 'isodate_from_time_t' \
39
+
--allowlist-var 'E_SOURCE_EXTENSION_.*' \
40
+
--allowlist-type 'ECalClientSourceType' \
41
+
--blocklist-type 'GError' \
42
+
--blocklist-type 'GList' \
43
+
--blocklist-type 'GSList' \
44
+
--raw-line 'pub use glib::ffi::GError;' \
45
+
--raw-line 'pub use glib::ffi::GList;' \
46
+
--raw-line 'pub use glib::ffi::GSList;' \
47
+
-- $EDS_CFLAGS
48
+
49
+
# Add header comment to generated file
50
+
cat > /tmp/header.txt << 'EOF'
51
+
// This file is generated by generate_bindings.sh
52
+
// DO NOT EDIT BY HAND - Run ./generate_bindings.sh to regenerate
53
+
//
54
+
// Generated FFI bindings for Evolution Data Server
55
+
56
+
#![allow(non_upper_case_globals)]
57
+
#![allow(non_camel_case_types)]
58
+
#![allow(non_snake_case)]
59
+
#![allow(dead_code)]
60
+
#![allow(improper_ctypes)]
61
+
62
+
EOF
63
+
64
+
cat /tmp/header.txt src/bindings/eds_bindings.rs > /tmp/eds_bindings_with_header.rs
65
+
mv /tmp/eds_bindings_with_header.rs src/bindings/eds_bindings.rs
66
+
67
+
echo "Bindings generated successfully in src/bindings/eds_bindings.rs"
68
+
echo "File size: $(wc -l < src/bindings/eds_bindings.rs) lines"
69
+
70
+
# Cleanup
71
+
rm -f /tmp/wrapper.h /tmp/header.txt
+9414
crates/alarma-eds/src/bindings/eds_bindings.rs
+9414
crates/alarma-eds/src/bindings/eds_bindings.rs
···
1
+
// This file is generated by generate_bindings.sh
2
+
// DO NOT EDIT BY HAND - Run ./generate_bindings.sh to regenerate
3
+
//
4
+
// Generated FFI bindings for Evolution Data Server
5
+
6
+
#![allow(non_upper_case_globals)]
7
+
#![allow(non_camel_case_types)]
8
+
#![allow(non_snake_case)]
9
+
#![allow(dead_code)]
10
+
#![allow(improper_ctypes)]
11
+
12
+
/* automatically generated by rust-bindgen 0.72.1 */
13
+
14
+
pub use glib::ffi::GError;
15
+
pub use glib::ffi::GList;
16
+
pub use glib::ffi::GSList;
17
+
18
+
#[repr(C)]
19
+
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
20
+
pub struct __BindgenBitfieldUnit<Storage> {
21
+
storage: Storage,
22
+
}
23
+
impl<Storage> __BindgenBitfieldUnit<Storage> {
24
+
#[inline]
25
+
pub const fn new(storage: Storage) -> Self {
26
+
Self { storage }
27
+
}
28
+
}
29
+
impl<Storage> __BindgenBitfieldUnit<Storage>
30
+
where
31
+
Storage: AsRef<[u8]> + AsMut<[u8]>,
32
+
{
33
+
#[inline]
34
+
fn extract_bit(byte: u8, index: usize) -> bool {
35
+
let bit_index = if cfg!(target_endian = "big") {
36
+
7 - (index % 8)
37
+
} else {
38
+
index % 8
39
+
};
40
+
let mask = 1 << bit_index;
41
+
byte & mask == mask
42
+
}
43
+
#[inline]
44
+
pub fn get_bit(&self, index: usize) -> bool {
45
+
debug_assert!(index / 8 < self.storage.as_ref().len());
46
+
let byte_index = index / 8;
47
+
let byte = self.storage.as_ref()[byte_index];
48
+
Self::extract_bit(byte, index)
49
+
}
50
+
#[inline]
51
+
pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
52
+
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
53
+
let byte_index = index / 8;
54
+
let byte = unsafe {
55
+
*(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
56
+
};
57
+
Self::extract_bit(byte, index)
58
+
}
59
+
#[inline]
60
+
fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
61
+
let bit_index = if cfg!(target_endian = "big") {
62
+
7 - (index % 8)
63
+
} else {
64
+
index % 8
65
+
};
66
+
let mask = 1 << bit_index;
67
+
if val {
68
+
byte | mask
69
+
} else {
70
+
byte & !mask
71
+
}
72
+
}
73
+
#[inline]
74
+
pub fn set_bit(&mut self, index: usize, val: bool) {
75
+
debug_assert!(index / 8 < self.storage.as_ref().len());
76
+
let byte_index = index / 8;
77
+
let byte = &mut self.storage.as_mut()[byte_index];
78
+
*byte = Self::change_bit(*byte, index, val);
79
+
}
80
+
#[inline]
81
+
pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
82
+
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
83
+
let byte_index = index / 8;
84
+
let byte = unsafe {
85
+
(core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
86
+
};
87
+
unsafe { *byte = Self::change_bit(*byte, index, val) };
88
+
}
89
+
#[inline]
90
+
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
91
+
debug_assert!(bit_width <= 64);
92
+
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
93
+
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
94
+
let mut val = 0;
95
+
for i in 0..(bit_width as usize) {
96
+
if self.get_bit(i + bit_offset) {
97
+
let index = if cfg!(target_endian = "big") {
98
+
bit_width as usize - 1 - i
99
+
} else {
100
+
i
101
+
};
102
+
val |= 1 << index;
103
+
}
104
+
}
105
+
val
106
+
}
107
+
#[inline]
108
+
pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
109
+
debug_assert!(bit_width <= 64);
110
+
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
111
+
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
112
+
let mut val = 0;
113
+
for i in 0..(bit_width as usize) {
114
+
if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
115
+
let index = if cfg!(target_endian = "big") {
116
+
bit_width as usize - 1 - i
117
+
} else {
118
+
i
119
+
};
120
+
val |= 1 << index;
121
+
}
122
+
}
123
+
val
124
+
}
125
+
#[inline]
126
+
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
127
+
debug_assert!(bit_width <= 64);
128
+
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
129
+
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
130
+
for i in 0..(bit_width as usize) {
131
+
let mask = 1 << i;
132
+
let val_bit_is_set = val & mask == mask;
133
+
let index = if cfg!(target_endian = "big") {
134
+
bit_width as usize - 1 - i
135
+
} else {
136
+
i
137
+
};
138
+
self.set_bit(index + bit_offset, val_bit_is_set);
139
+
}
140
+
}
141
+
#[inline]
142
+
pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
143
+
debug_assert!(bit_width <= 64);
144
+
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
145
+
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
146
+
for i in 0..(bit_width as usize) {
147
+
let mask = 1 << i;
148
+
let val_bit_is_set = val & mask == mask;
149
+
let index = if cfg!(target_endian = "big") {
150
+
bit_width as usize - 1 - i
151
+
} else {
152
+
i
153
+
};
154
+
unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
155
+
}
156
+
}
157
+
}
158
+
pub const E_SOURCE_EXTENSION_ADDRESS_BOOK: &[u8; 13] = b"Address Book\0";
159
+
pub const E_SOURCE_EXTENSION_ALARMS: &[u8; 7] = b"Alarms\0";
160
+
pub const E_SOURCE_EXTENSION_AUTHENTICATION: &[u8; 15] = b"Authentication\0";
161
+
pub const E_SOURCE_EXTENSION_AUTOCOMPLETE: &[u8; 13] = b"Autocomplete\0";
162
+
pub const E_SOURCE_EXTENSION_AUTOCONFIG: &[u8; 11] = b"Autoconfig\0";
163
+
pub const E_SOURCE_EXTENSION_CALENDAR: &[u8; 9] = b"Calendar\0";
164
+
pub const E_SOURCE_EXTENSION_COLLECTION: &[u8; 11] = b"Collection\0";
165
+
pub const E_SOURCE_EXTENSION_CONTACTS_BACKEND: &[u8; 17] = b"Contacts Backend\0";
166
+
pub const E_SOURCE_EXTENSION_GOA: &[u8; 22] = b"GNOME Online Accounts\0";
167
+
pub const E_SOURCE_EXTENSION_LDAP_BACKEND: &[u8; 13] = b"LDAP Backend\0";
168
+
pub const E_SOURCE_EXTENSION_LOCAL_BACKEND: &[u8; 14] = b"Local Backend\0";
169
+
pub const E_SOURCE_EXTENSION_MAIL_ACCOUNT: &[u8; 13] = b"Mail Account\0";
170
+
pub const E_SOURCE_EXTENSION_MAIL_COMPOSITION: &[u8; 17] = b"Mail Composition\0";
171
+
pub const E_SOURCE_EXTENSION_MAIL_IDENTITY: &[u8; 14] = b"Mail Identity\0";
172
+
pub const E_SOURCE_EXTENSION_MAIL_SIGNATURE: &[u8; 15] = b"Mail Signature\0";
173
+
pub const E_SOURCE_EXTENSION_MAIL_SUBMISSION: &[u8; 16] = b"Mail Submission\0";
174
+
pub const E_SOURCE_EXTENSION_MAIL_TRANSPORT: &[u8; 15] = b"Mail Transport\0";
175
+
pub const E_SOURCE_EXTENSION_MDN: &[u8; 34] = b"Message Disposition Notifications\0";
176
+
pub const E_SOURCE_EXTENSION_MEMO_LIST: &[u8; 10] = b"Memo List\0";
177
+
pub const E_SOURCE_EXTENSION_OFFLINE: &[u8; 8] = b"Offline\0";
178
+
pub const E_SOURCE_EXTENSION_OPENPGP: &[u8; 30] = b"Pretty Good Privacy (OpenPGP)\0";
179
+
pub const E_SOURCE_EXTENSION_PROXY: &[u8; 6] = b"Proxy\0";
180
+
pub const E_SOURCE_EXTENSION_REFRESH: &[u8; 8] = b"Refresh\0";
181
+
pub const E_SOURCE_EXTENSION_RESOURCE: &[u8; 9] = b"Resource\0";
182
+
pub const E_SOURCE_EXTENSION_REVISION_GUARDS: &[u8; 16] = b"Revision Guards\0";
183
+
pub const E_SOURCE_EXTENSION_SECURITY: &[u8; 9] = b"Security\0";
184
+
pub const E_SOURCE_EXTENSION_SMIME: &[u8; 21] = b"Secure MIME (S/MIME)\0";
185
+
pub const E_SOURCE_EXTENSION_TASK_LIST: &[u8; 10] = b"Task List\0";
186
+
pub const E_SOURCE_EXTENSION_UOA: &[u8; 23] = b"Ubuntu Online Accounts\0";
187
+
pub const E_SOURCE_EXTENSION_WEBDAV_BACKEND: &[u8; 15] = b"WebDAV Backend\0";
188
+
pub const E_SOURCE_EXTENSION_WEBDAV_NOTES: &[u8; 13] = b"WebDAV Notes\0";
189
+
pub const E_SOURCE_EXTENSION_WEATHER_BACKEND: &[u8; 16] = b"Weather Backend\0";
190
+
pub type guint16 = ::std::os::raw::c_ushort;
191
+
pub type guint32 = ::std::os::raw::c_uint;
192
+
pub type gsize = ::std::os::raw::c_ulong;
193
+
pub type __uint64_t = ::std::os::raw::c_ulong;
194
+
pub type __off_t = ::std::os::raw::c_long;
195
+
pub type __off64_t = ::std::os::raw::c_long;
196
+
pub type __time_t = ::std::os::raw::c_long;
197
+
pub type time_t = __time_t;
198
+
pub type gchar = ::std::os::raw::c_char;
199
+
pub type gshort = ::std::os::raw::c_short;
200
+
pub type gint = ::std::os::raw::c_int;
201
+
pub type gboolean = gint;
202
+
pub type guint = ::std::os::raw::c_uint;
203
+
pub type gdouble = f64;
204
+
pub type gpointer = *mut ::std::os::raw::c_void;
205
+
pub type GDestroyNotify = ::std::option::Option<unsafe extern "C" fn(data: gpointer)>;
206
+
pub type GFunc = ::std::option::Option<unsafe extern "C" fn(data: gpointer, user_data: gpointer)>;
207
+
#[repr(C)]
208
+
#[derive(Debug, Copy, Clone)]
209
+
pub struct _GBytes {
210
+
_unused: [u8; 0],
211
+
}
212
+
pub type GBytes = _GBytes;
213
+
pub type GArray = _GArray;
214
+
#[repr(C)]
215
+
#[derive(Debug, Copy, Clone)]
216
+
pub struct _GArray {
217
+
pub data: *mut gchar,
218
+
pub len: guint,
219
+
}
220
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
221
+
const _: () = {
222
+
["Size of _GArray"][::std::mem::size_of::<_GArray>() - 16usize];
223
+
["Alignment of _GArray"][::std::mem::align_of::<_GArray>() - 8usize];
224
+
["Offset of field: _GArray::data"][::std::mem::offset_of!(_GArray, data) - 0usize];
225
+
["Offset of field: _GArray::len"][::std::mem::offset_of!(_GArray, len) - 8usize];
226
+
};
227
+
pub type GQuark = guint32;
228
+
#[repr(C)]
229
+
#[derive(Debug, Copy, Clone)]
230
+
pub struct _GError {
231
+
pub domain: GQuark,
232
+
pub code: gint,
233
+
pub message: *mut gchar,
234
+
}
235
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
236
+
const _: () = {
237
+
["Size of _GError"][::std::mem::size_of::<_GError>() - 16usize];
238
+
["Alignment of _GError"][::std::mem::align_of::<_GError>() - 8usize];
239
+
["Offset of field: _GError::domain"][::std::mem::offset_of!(_GError, domain) - 0usize];
240
+
["Offset of field: _GError::code"][::std::mem::offset_of!(_GError, code) - 4usize];
241
+
["Offset of field: _GError::message"][::std::mem::offset_of!(_GError, message) - 8usize];
242
+
};
243
+
#[repr(C)]
244
+
#[derive(Debug, Copy, Clone)]
245
+
pub struct _GData {
246
+
_unused: [u8; 0],
247
+
}
248
+
pub type GData = _GData;
249
+
pub type GNode = _GNode;
250
+
#[repr(C)]
251
+
#[derive(Debug, Copy, Clone)]
252
+
pub struct _GNode {
253
+
pub data: gpointer,
254
+
pub next: *mut GNode,
255
+
pub prev: *mut GNode,
256
+
pub parent: *mut GNode,
257
+
pub children: *mut GNode,
258
+
}
259
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
260
+
const _: () = {
261
+
["Size of _GNode"][::std::mem::size_of::<_GNode>() - 40usize];
262
+
["Alignment of _GNode"][::std::mem::align_of::<_GNode>() - 8usize];
263
+
["Offset of field: _GNode::data"][::std::mem::offset_of!(_GNode, data) - 0usize];
264
+
["Offset of field: _GNode::next"][::std::mem::offset_of!(_GNode, next) - 8usize];
265
+
["Offset of field: _GNode::prev"][::std::mem::offset_of!(_GNode, prev) - 16usize];
266
+
["Offset of field: _GNode::parent"][::std::mem::offset_of!(_GNode, parent) - 24usize];
267
+
["Offset of field: _GNode::children"][::std::mem::offset_of!(_GNode, children) - 32usize];
268
+
};
269
+
#[repr(C)]
270
+
#[derive(Debug, Copy, Clone)]
271
+
pub struct _GList {
272
+
pub data: gpointer,
273
+
pub next: *mut GList,
274
+
pub prev: *mut GList,
275
+
}
276
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
277
+
const _: () = {
278
+
["Size of _GList"][::std::mem::size_of::<_GList>() - 24usize];
279
+
["Alignment of _GList"][::std::mem::align_of::<_GList>() - 8usize];
280
+
["Offset of field: _GList::data"][::std::mem::offset_of!(_GList, data) - 0usize];
281
+
["Offset of field: _GList::next"][::std::mem::offset_of!(_GList, next) - 8usize];
282
+
["Offset of field: _GList::prev"][::std::mem::offset_of!(_GList, prev) - 16usize];
283
+
};
284
+
#[repr(C)]
285
+
#[derive(Debug, Copy, Clone)]
286
+
pub struct _GHashTable {
287
+
_unused: [u8; 0],
288
+
}
289
+
pub type GHashTable = _GHashTable;
290
+
#[repr(C)]
291
+
#[derive(Debug, Copy, Clone)]
292
+
pub struct _GSList {
293
+
pub data: gpointer,
294
+
pub next: *mut GSList,
295
+
}
296
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
297
+
const _: () = {
298
+
["Size of _GSList"][::std::mem::size_of::<_GSList>() - 16usize];
299
+
["Alignment of _GSList"][::std::mem::align_of::<_GSList>() - 8usize];
300
+
["Offset of field: _GSList::data"][::std::mem::offset_of!(_GSList, data) - 0usize];
301
+
["Offset of field: _GSList::next"][::std::mem::offset_of!(_GSList, next) - 8usize];
302
+
};
303
+
#[repr(C)]
304
+
#[derive(Debug, Copy, Clone)]
305
+
pub struct _GMainContext {
306
+
_unused: [u8; 0],
307
+
}
308
+
#[doc = " GMainContext:\n\n The `GMainContext` struct is an opaque data\n type representing a set of sources to be handled in a main loop."]
309
+
pub type GMainContext = _GMainContext;
310
+
#[repr(C)]
311
+
#[derive(Debug, Copy, Clone)]
312
+
pub struct _GUri {
313
+
_unused: [u8; 0],
314
+
}
315
+
pub type GUri = _GUri;
316
+
pub type GType = gsize;
317
+
#[doc = " GTypeClass: (copy-func g_type_class_ref) (free-func g_type_class_unref)\n\n An opaque structure used as the base of all classes."]
318
+
pub type GTypeClass = _GTypeClass;
319
+
#[doc = " GTypeInstance:\n\n An opaque structure used as the base of all type instances."]
320
+
pub type GTypeInstance = _GTypeInstance;
321
+
#[doc = " GTypeClass: (copy-func g_type_class_ref) (free-func g_type_class_unref)\n\n An opaque structure used as the base of all classes."]
322
+
#[repr(C)]
323
+
#[derive(Debug, Copy, Clone)]
324
+
pub struct _GTypeClass {
325
+
pub g_type: GType,
326
+
}
327
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
328
+
const _: () = {
329
+
["Size of _GTypeClass"][::std::mem::size_of::<_GTypeClass>() - 8usize];
330
+
["Alignment of _GTypeClass"][::std::mem::align_of::<_GTypeClass>() - 8usize];
331
+
["Offset of field: _GTypeClass::g_type"][::std::mem::offset_of!(_GTypeClass, g_type) - 0usize];
332
+
};
333
+
#[doc = " GTypeInstance:\n\n An opaque structure used as the base of all type instances."]
334
+
#[repr(C)]
335
+
#[derive(Debug, Copy, Clone)]
336
+
pub struct _GTypeInstance {
337
+
pub g_class: *mut GTypeClass,
338
+
}
339
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
340
+
const _: () = {
341
+
["Size of _GTypeInstance"][::std::mem::size_of::<_GTypeInstance>() - 8usize];
342
+
["Alignment of _GTypeInstance"][::std::mem::align_of::<_GTypeInstance>() - 8usize];
343
+
["Offset of field: _GTypeInstance::g_class"]
344
+
[::std::mem::offset_of!(_GTypeInstance, g_class) - 0usize];
345
+
};
346
+
pub type GObject = _GObject;
347
+
#[repr(C)]
348
+
#[derive(Debug, Copy, Clone)]
349
+
pub struct _GObject {
350
+
pub g_type_instance: GTypeInstance,
351
+
pub ref_count: guint,
352
+
pub qdata: *mut GData,
353
+
}
354
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
355
+
const _: () = {
356
+
["Size of _GObject"][::std::mem::size_of::<_GObject>() - 24usize];
357
+
["Alignment of _GObject"][::std::mem::align_of::<_GObject>() - 8usize];
358
+
["Offset of field: _GObject::g_type_instance"]
359
+
[::std::mem::offset_of!(_GObject, g_type_instance) - 0usize];
360
+
["Offset of field: _GObject::ref_count"][::std::mem::offset_of!(_GObject, ref_count) - 8usize];
361
+
["Offset of field: _GObject::qdata"][::std::mem::offset_of!(_GObject, qdata) - 16usize];
362
+
};
363
+
pub const GTlsCertificateFlags_G_TLS_CERTIFICATE_NO_FLAGS: GTlsCertificateFlags = 0;
364
+
pub const GTlsCertificateFlags_G_TLS_CERTIFICATE_UNKNOWN_CA: GTlsCertificateFlags = 1;
365
+
pub const GTlsCertificateFlags_G_TLS_CERTIFICATE_BAD_IDENTITY: GTlsCertificateFlags = 2;
366
+
pub const GTlsCertificateFlags_G_TLS_CERTIFICATE_NOT_ACTIVATED: GTlsCertificateFlags = 4;
367
+
pub const GTlsCertificateFlags_G_TLS_CERTIFICATE_EXPIRED: GTlsCertificateFlags = 8;
368
+
pub const GTlsCertificateFlags_G_TLS_CERTIFICATE_REVOKED: GTlsCertificateFlags = 16;
369
+
pub const GTlsCertificateFlags_G_TLS_CERTIFICATE_INSECURE: GTlsCertificateFlags = 32;
370
+
pub const GTlsCertificateFlags_G_TLS_CERTIFICATE_GENERIC_ERROR: GTlsCertificateFlags = 64;
371
+
pub const GTlsCertificateFlags_G_TLS_CERTIFICATE_VALIDATE_ALL: GTlsCertificateFlags = 127;
372
+
#[doc = " GTlsCertificateFlags:\n @G_TLS_CERTIFICATE_NO_FLAGS: No flags set. Since: 2.74\n @G_TLS_CERTIFICATE_UNKNOWN_CA: The signing certificate authority is\n not known.\n @G_TLS_CERTIFICATE_BAD_IDENTITY: The certificate does not match the\n expected identity of the site that it was retrieved from.\n @G_TLS_CERTIFICATE_NOT_ACTIVATED: The certificate's activation time\n is still in the future\n @G_TLS_CERTIFICATE_EXPIRED: The certificate has expired\n @G_TLS_CERTIFICATE_REVOKED: The certificate has been revoked\n according to the #GTlsConnection's certificate revocation list.\n @G_TLS_CERTIFICATE_INSECURE: The certificate's algorithm is\n considered insecure.\n @G_TLS_CERTIFICATE_GENERIC_ERROR: Some other error occurred validating\n the certificate\n @G_TLS_CERTIFICATE_VALIDATE_ALL: the combination of all of the above\n flags\n\n A set of flags describing TLS certification validation. This can be\n used to describe why a particular certificate was rejected (for\n example, in #GTlsConnection::accept-certificate).\n\n GLib guarantees that if certificate verification fails, at least one\n flag will be set, but it does not guarantee that all possible flags\n will be set. Accordingly, you may not safely decide to ignore any\n particular type of error. For example, it would be incorrect to mask\n %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,\n because this could potentially be the only error flag set even if\n other problems exist with the certificate.\n\n Since: 2.28"]
373
+
pub type GTlsCertificateFlags = ::std::os::raw::c_uint;
374
+
#[repr(C)]
375
+
#[derive(Debug, Copy, Clone)]
376
+
pub struct _GAsyncResult {
377
+
_unused: [u8; 0],
378
+
}
379
+
pub type GAsyncResult = _GAsyncResult;
380
+
pub type GCancellable = _GCancellable;
381
+
#[repr(C)]
382
+
#[derive(Debug, Copy, Clone)]
383
+
pub struct _GFile {
384
+
_unused: [u8; 0],
385
+
}
386
+
pub type GFile = _GFile;
387
+
#[repr(C)]
388
+
#[derive(Debug, Copy, Clone)]
389
+
pub struct _GSocketConnectable {
390
+
_unused: [u8; 0],
391
+
}
392
+
pub type GSocketConnectable = _GSocketConnectable;
393
+
pub type GTlsCertificate = _GTlsCertificate;
394
+
#[doc = " GAsyncReadyCallback:\n @source_object: (nullable): the object the asynchronous operation was started with.\n @res: a #GAsyncResult.\n @data: user data passed to the callback.\n\n Type definition for a function that will be called back when an asynchronous\n operation within GIO has been completed. #GAsyncReadyCallback\n callbacks from #GTask are guaranteed to be invoked in a later\n iteration of the thread-default main context\n (see [method@GLib.MainContext.push_thread_default])\n where the #GTask was created. All other users of\n #GAsyncReadyCallback must likewise call it asynchronously in a\n later iteration of the main context.\n\n The asynchronous operation is guaranteed to have held a reference to\n @source_object from the time when the `*_async()` function was called, until\n after this callback returns."]
395
+
pub type GAsyncReadyCallback = ::std::option::Option<
396
+
unsafe extern "C" fn(source_object: *mut GObject, res: *mut GAsyncResult, data: gpointer),
397
+
>;
398
+
#[repr(C)]
399
+
#[derive(Debug, Copy, Clone)]
400
+
pub struct _GDBusConnection {
401
+
_unused: [u8; 0],
402
+
}
403
+
pub type GDBusConnection = _GDBusConnection;
404
+
#[repr(C)]
405
+
#[derive(Debug, Copy, Clone)]
406
+
pub struct _GDBusObject {
407
+
_unused: [u8; 0],
408
+
}
409
+
pub type GDBusObject = _GDBusObject;
410
+
#[repr(C)]
411
+
#[derive(Debug, Copy, Clone)]
412
+
pub struct _GCancellablePrivate {
413
+
_unused: [u8; 0],
414
+
}
415
+
pub type GCancellablePrivate = _GCancellablePrivate;
416
+
#[repr(C)]
417
+
#[derive(Debug, Copy, Clone)]
418
+
pub struct _GCancellable {
419
+
pub parent_instance: GObject,
420
+
pub priv_: *mut GCancellablePrivate,
421
+
}
422
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
423
+
const _: () = {
424
+
["Size of _GCancellable"][::std::mem::size_of::<_GCancellable>() - 32usize];
425
+
["Alignment of _GCancellable"][::std::mem::align_of::<_GCancellable>() - 8usize];
426
+
["Offset of field: _GCancellable::parent_instance"]
427
+
[::std::mem::offset_of!(_GCancellable, parent_instance) - 0usize];
428
+
["Offset of field: _GCancellable::priv_"]
429
+
[::std::mem::offset_of!(_GCancellable, priv_) - 24usize];
430
+
};
431
+
#[repr(C)]
432
+
#[derive(Debug, Copy, Clone)]
433
+
pub struct _GTlsCertificatePrivate {
434
+
_unused: [u8; 0],
435
+
}
436
+
pub type GTlsCertificatePrivate = _GTlsCertificatePrivate;
437
+
#[repr(C)]
438
+
#[derive(Debug, Copy, Clone)]
439
+
pub struct _GTlsCertificate {
440
+
pub parent_instance: GObject,
441
+
pub priv_: *mut GTlsCertificatePrivate,
442
+
}
443
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
444
+
const _: () = {
445
+
["Size of _GTlsCertificate"][::std::mem::size_of::<_GTlsCertificate>() - 32usize];
446
+
["Alignment of _GTlsCertificate"][::std::mem::align_of::<_GTlsCertificate>() - 8usize];
447
+
["Offset of field: _GTlsCertificate::parent_instance"]
448
+
[::std::mem::offset_of!(_GTlsCertificate, parent_instance) - 0usize];
449
+
["Offset of field: _GTlsCertificate::priv_"]
450
+
[::std::mem::offset_of!(_GTlsCertificate, priv_) - 24usize];
451
+
};
452
+
#[doc = " ENamedParameters:\n\n Since: 3.8"]
453
+
#[repr(C)]
454
+
#[derive(Debug, Copy, Clone)]
455
+
pub struct _ENamedParameters {
456
+
_unused: [u8; 0],
457
+
}
458
+
pub type ENamedParameters = _ENamedParameters;
459
+
pub const EMdnResponsePolicy_E_MDN_RESPONSE_POLICY_NEVER: EMdnResponsePolicy = 0;
460
+
pub const EMdnResponsePolicy_E_MDN_RESPONSE_POLICY_ALWAYS: EMdnResponsePolicy = 1;
461
+
pub const EMdnResponsePolicy_E_MDN_RESPONSE_POLICY_ASK: EMdnResponsePolicy = 2;
462
+
#[doc = " EMdnResponsePolicy:\n @E_MDN_RESPONSE_POLICY_NEVER:\n Never respond to an MDN request.\n @E_MDN_RESPONSE_POLICY_ALWAYS:\n Always respond to an MDN request.\n @E_MDN_RESPONSE_POLICY_ASK:\n Ask the user before responding to an MDN request.\n\n Policy for responding to Message Disposition Notification requests\n (i.e. a Disposition-Notification-To header) when receiving messages.\n See RFC 2298 for more information about MDN requests.\n\n Since: 3.6"]
463
+
pub type EMdnResponsePolicy = ::std::os::raw::c_uint;
464
+
pub const EProxyMethod_E_PROXY_METHOD_DEFAULT: EProxyMethod = 0;
465
+
pub const EProxyMethod_E_PROXY_METHOD_MANUAL: EProxyMethod = 1;
466
+
pub const EProxyMethod_E_PROXY_METHOD_AUTO: EProxyMethod = 2;
467
+
pub const EProxyMethod_E_PROXY_METHOD_NONE: EProxyMethod = 3;
468
+
#[doc = " EProxyMethod:\n @E_PROXY_METHOD_DEFAULT:\n Use the default #GProxyResolver (see g_proxy_resolver_get_default()).\n @E_PROXY_METHOD_MANUAL:\n Use the FTP/HTTP/HTTPS/SOCKS settings defined in #ESourceProxy.\n @E_PROXY_METHOD_AUTO:\n Use the autoconfiguration URL defined in #ESourceProxy.\n @E_PROXY_METHOD_NONE:\n Direct connection; do not use a network proxy.\n\n Network proxy configuration methods.\n\n Since: 3.12"]
469
+
pub type EProxyMethod = ::std::os::raw::c_uint;
470
+
pub const ETrustPromptResponse_E_TRUST_PROMPT_RESPONSE_UNKNOWN: ETrustPromptResponse = -1;
471
+
pub const ETrustPromptResponse_E_TRUST_PROMPT_RESPONSE_REJECT: ETrustPromptResponse = 0;
472
+
pub const ETrustPromptResponse_E_TRUST_PROMPT_RESPONSE_ACCEPT: ETrustPromptResponse = 1;
473
+
pub const ETrustPromptResponse_E_TRUST_PROMPT_RESPONSE_ACCEPT_TEMPORARILY: ETrustPromptResponse = 2;
474
+
pub const ETrustPromptResponse_E_TRUST_PROMPT_RESPONSE_REJECT_TEMPORARILY: ETrustPromptResponse = 3;
475
+
#[doc = " ETrustPromptResponse:\n @E_TRUST_PROMPT_RESPONSE_UNKNOWN: Unknown response, usually due to some error\n @E_TRUST_PROMPT_RESPONSE_REJECT: Reject permanently\n @E_TRUST_PROMPT_RESPONSE_ACCEPT: Accept permanently\n @E_TRUST_PROMPT_RESPONSE_ACCEPT_TEMPORARILY: Accept temporarily\n @E_TRUST_PROMPT_RESPONSE_REJECT_TEMPORARILY: Reject temporarily\n\n Response codes for the trust prompt.\n\n Since: 3.8"]
476
+
pub type ETrustPromptResponse = ::std::os::raw::c_int;
477
+
pub const ESourceConnectionStatus_E_SOURCE_CONNECTION_STATUS_DISCONNECTED: ESourceConnectionStatus =
478
+
0;
479
+
pub const ESourceConnectionStatus_E_SOURCE_CONNECTION_STATUS_AWAITING_CREDENTIALS:
480
+
ESourceConnectionStatus = 1;
481
+
pub const ESourceConnectionStatus_E_SOURCE_CONNECTION_STATUS_SSL_FAILED: ESourceConnectionStatus =
482
+
2;
483
+
pub const ESourceConnectionStatus_E_SOURCE_CONNECTION_STATUS_CONNECTING: ESourceConnectionStatus =
484
+
3;
485
+
pub const ESourceConnectionStatus_E_SOURCE_CONNECTION_STATUS_CONNECTED: ESourceConnectionStatus = 4;
486
+
#[doc = " ESourceConnectionStatus:\n @E_SOURCE_CONNECTION_STATUS_DISCONNECTED:\n The source is currently disconnected from its (possibly remote) data store.\n @E_SOURCE_CONNECTION_STATUS_AWAITING_CREDENTIALS:\n The source asked for credentials with a 'credentials-required' signal and\n is currently awaiting for them.\n @E_SOURCE_CONNECTION_STATUS_SSL_FAILED:\n A user rejected SSL certificate trust for the connection.\n @E_SOURCE_CONNECTION_STATUS_CONNECTING:\n The source is currently connecting to its (possibly remote) data store.\n @E_SOURCE_CONNECTION_STATUS_CONNECTED:\n The source is currently connected to its (possibly remote) data store.\n\n Connection status codes used by the #ESource to indicate its connection state.\n This is used in combination with authentication of the ESource. For example,\n if there are multiple clients asking for a password and a user enters the password\n in one of them, then the status will change into 'connecting', which is a signal\n do close the password prompt in the other client, because the credentials had\n been already provided.\n\n Since: 3.16"]
487
+
pub type ESourceConnectionStatus = ::std::os::raw::c_uint;
488
+
pub const ESourceCredentialsReason_E_SOURCE_CREDENTIALS_REASON_UNKNOWN: ESourceCredentialsReason =
489
+
0;
490
+
pub const ESourceCredentialsReason_E_SOURCE_CREDENTIALS_REASON_REQUIRED: ESourceCredentialsReason =
491
+
1;
492
+
pub const ESourceCredentialsReason_E_SOURCE_CREDENTIALS_REASON_REJECTED: ESourceCredentialsReason =
493
+
2;
494
+
pub const ESourceCredentialsReason_E_SOURCE_CREDENTIALS_REASON_SSL_FAILED:
495
+
ESourceCredentialsReason = 3;
496
+
pub const ESourceCredentialsReason_E_SOURCE_CREDENTIALS_REASON_ERROR: ESourceCredentialsReason = 4;
497
+
#[doc = " ESourceCredentialsReason:\n @E_SOURCE_CREDENTIALS_REASON_UNKNOWN:\n A return value when there was no 'credentials-required' signal emitted yet,\n or a pair 'authenticate' signal had been received. This value should not\n be used in the call of 'credentials-required'.\n @E_SOURCE_CREDENTIALS_REASON_REQUIRED:\n This is the first attempt to get credentials for the source. It's usually\n used right after the source is opened and the authentication continues with\n a stored credentials, if any.\n @E_SOURCE_CREDENTIALS_REASON_REJECTED:\n The previously used credentials had been rejected by the server. That\n usually means that the user should be asked to provide/correct the credentials.\n @E_SOURCE_CREDENTIALS_REASON_SSL_FAILED:\n A secured connection failed due to some server-side certificate issues.\n @E_SOURCE_CREDENTIALS_REASON_ERROR:\n The server returned an error. It is not possible to connect to it\n at the moment usually.\n\n An ESource's authentication reason, used by an ESource::CredentialsRequired method.\n\n Since: 3.16"]
498
+
pub type ESourceCredentialsReason = ::std::os::raw::c_uint;
499
+
pub const ESourceLDAPAuthentication_E_SOURCE_LDAP_AUTHENTICATION_NONE: ESourceLDAPAuthentication =
500
+
0;
501
+
pub const ESourceLDAPAuthentication_E_SOURCE_LDAP_AUTHENTICATION_EMAIL: ESourceLDAPAuthentication =
502
+
1;
503
+
pub const ESourceLDAPAuthentication_E_SOURCE_LDAP_AUTHENTICATION_BINDDN: ESourceLDAPAuthentication =
504
+
2;
505
+
#[doc = " ESourceLDAPAuthentication:\n @E_SOURCE_LDAP_AUTHENTICATION_NONE:\n Use none authentication type.\n @E_SOURCE_LDAP_AUTHENTICATION_EMAIL:\n Use an email address for authentication.\n @E_SOURCE_LDAP_AUTHENTICATION_BINDDN:\n Use a bind DN for authentication.\n\n Defines authentication types for LDAP sources.\n\n Since: 3.18"]
506
+
pub type ESourceLDAPAuthentication = ::std::os::raw::c_uint;
507
+
pub const ESourceLDAPScope_E_SOURCE_LDAP_SCOPE_ONELEVEL: ESourceLDAPScope = 0;
508
+
pub const ESourceLDAPScope_E_SOURCE_LDAP_SCOPE_SUBTREE: ESourceLDAPScope = 1;
509
+
#[doc = " ESourceLDAPScope:\n @E_SOURCE_LDAP_SCOPE_ONELEVEL:\n One level search scope.\n @E_SOURCE_LDAP_SCOPE_SUBTREE:\n Sub-tree search scope.\n\n Defines search scope for LDAP sources.\n\n Since: 3.18"]
510
+
pub type ESourceLDAPScope = ::std::os::raw::c_uint;
511
+
pub const ESourceLDAPSecurity_E_SOURCE_LDAP_SECURITY_NONE: ESourceLDAPSecurity = 0;
512
+
pub const ESourceLDAPSecurity_E_SOURCE_LDAP_SECURITY_LDAPS: ESourceLDAPSecurity = 1;
513
+
pub const ESourceLDAPSecurity_E_SOURCE_LDAP_SECURITY_STARTTLS: ESourceLDAPSecurity = 2;
514
+
#[doc = " ESourceLDAPSecurity:\n @E_SOURCE_LDAP_SECURITY_NONE:\n Connect insecurely.\n @E_SOURCE_LDAP_SECURITY_LDAPS:\n Connect using secure LDAP (LDAPS).\n @E_SOURCE_LDAP_SECURITY_STARTTLS:\n Connect using STARTTLS.\n\n Defines what connection security should be used for LDAP sources.\n\n Since: 3.18"]
515
+
pub type ESourceLDAPSecurity = ::std::os::raw::c_uint;
516
+
pub const ESourceWeatherUnits_E_SOURCE_WEATHER_UNITS_FAHRENHEIT: ESourceWeatherUnits = 0;
517
+
pub const ESourceWeatherUnits_E_SOURCE_WEATHER_UNITS_CENTIGRADE: ESourceWeatherUnits = 1;
518
+
pub const ESourceWeatherUnits_E_SOURCE_WEATHER_UNITS_KELVIN: ESourceWeatherUnits = 2;
519
+
#[doc = " ESourceWeatherUnits:\n @E_SOURCE_WEATHER_UNITS_FAHRENHEIT:\n Fahrenheit units\n @E_SOURCE_WEATHER_UNITS_CENTIGRADE:\n Centigrade units\n @E_SOURCE_WEATHER_UNITS_KELVIN:\n Kelvin units\n\n Units to be used in an #ESourceWeather extension.\n\n Since: 3.18"]
520
+
pub type ESourceWeatherUnits = ::std::os::raw::c_uint;
521
+
pub const ESourceMailCompositionReplyStyle_E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_DEFAULT:
522
+
ESourceMailCompositionReplyStyle = 0;
523
+
pub const ESourceMailCompositionReplyStyle_E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_QUOTED:
524
+
ESourceMailCompositionReplyStyle = 1;
525
+
pub const ESourceMailCompositionReplyStyle_E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_DO_NOT_QUOTE:
526
+
ESourceMailCompositionReplyStyle = 2;
527
+
pub const ESourceMailCompositionReplyStyle_E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_ATTACH:
528
+
ESourceMailCompositionReplyStyle = 3;
529
+
pub const ESourceMailCompositionReplyStyle_E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_OUTLOOK:
530
+
ESourceMailCompositionReplyStyle = 4;
531
+
#[doc = " ESourceMailCompositionReplyStyle:\n @E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_DEFAULT:\n Use default reply style.\n @E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_QUOTED:\n Use quoted reply style.\n @E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_DO_NOT_QUOTE:\n Do not quote anything in replies.\n @E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_ATTACH:\n Attach original message in replies.\n @E_SOURCE_MAIL_COMPOSITION_REPLY_STYLE_OUTLOOK:\n Use Outlook reply style.\n\n Set of preferred reply styles for an #ESourceMailComposition extension.\n\n Since: 3.20"]
532
+
pub type ESourceMailCompositionReplyStyle = ::std::os::raw::c_uint;
533
+
pub const EThreeState_E_THREE_STATE_OFF: EThreeState = 0;
534
+
pub const EThreeState_E_THREE_STATE_ON: EThreeState = 1;
535
+
pub const EThreeState_E_THREE_STATE_INCONSISTENT: EThreeState = 2;
536
+
#[doc = " EThreeState:\n @E_THREE_STATE_OFF: the three-state value is Off\n @E_THREE_STATE_ON: the three-state value is On\n @E_THREE_STATE_INCONSISTENT: the three-state value is neither On, nor Off\n\n Describes a three-state value, which can be either Off, On or Inconsistent.\n\n Since: 3.26"]
537
+
pub type EThreeState = ::std::os::raw::c_uint;
538
+
#[doc = " ESource:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
539
+
pub type ESource = _ESource;
540
+
#[repr(C)]
541
+
#[derive(Debug, Copy, Clone)]
542
+
pub struct _ESourcePrivate {
543
+
_unused: [u8; 0],
544
+
}
545
+
pub type ESourcePrivate = _ESourcePrivate;
546
+
#[doc = " ESource:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
547
+
#[repr(C)]
548
+
#[derive(Debug, Copy, Clone)]
549
+
pub struct _ESource {
550
+
pub parent: GObject,
551
+
pub priv_: *mut ESourcePrivate,
552
+
}
553
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
554
+
const _: () = {
555
+
["Size of _ESource"][::std::mem::size_of::<_ESource>() - 32usize];
556
+
["Alignment of _ESource"][::std::mem::align_of::<_ESource>() - 8usize];
557
+
["Offset of field: _ESource::parent"][::std::mem::offset_of!(_ESource, parent) - 0usize];
558
+
["Offset of field: _ESource::priv_"][::std::mem::offset_of!(_ESource, priv_) - 24usize];
559
+
};
560
+
unsafe extern "C" {
561
+
pub fn e_source_get_type() -> GType;
562
+
}
563
+
unsafe extern "C" {
564
+
pub fn e_source_new(
565
+
dbus_object: *mut GDBusObject,
566
+
main_context: *mut GMainContext,
567
+
error: *mut *mut GError,
568
+
) -> *mut ESource;
569
+
}
570
+
unsafe extern "C" {
571
+
pub fn e_source_new_with_uid(
572
+
uid: *const gchar,
573
+
main_context: *mut GMainContext,
574
+
error: *mut *mut GError,
575
+
) -> *mut ESource;
576
+
}
577
+
unsafe extern "C" {
578
+
pub fn e_source_hash(source: *mut ESource) -> guint;
579
+
}
580
+
unsafe extern "C" {
581
+
pub fn e_source_equal(source1: *mut ESource, source2: *mut ESource) -> gboolean;
582
+
}
583
+
unsafe extern "C" {
584
+
pub fn e_source_changed(source: *mut ESource);
585
+
}
586
+
unsafe extern "C" {
587
+
pub fn e_source_get_uid(source: *mut ESource) -> *const gchar;
588
+
}
589
+
unsafe extern "C" {
590
+
pub fn e_source_dup_uid(source: *mut ESource) -> *mut gchar;
591
+
}
592
+
unsafe extern "C" {
593
+
pub fn e_source_get_parent(source: *mut ESource) -> *const gchar;
594
+
}
595
+
unsafe extern "C" {
596
+
pub fn e_source_dup_parent(source: *mut ESource) -> *mut gchar;
597
+
}
598
+
unsafe extern "C" {
599
+
pub fn e_source_set_parent(source: *mut ESource, parent: *const gchar);
600
+
}
601
+
unsafe extern "C" {
602
+
pub fn e_source_get_enabled(source: *mut ESource) -> gboolean;
603
+
}
604
+
unsafe extern "C" {
605
+
pub fn e_source_set_enabled(source: *mut ESource, enabled: gboolean);
606
+
}
607
+
unsafe extern "C" {
608
+
pub fn e_source_get_writable(source: *mut ESource) -> gboolean;
609
+
}
610
+
unsafe extern "C" {
611
+
pub fn e_source_get_removable(source: *mut ESource) -> gboolean;
612
+
}
613
+
unsafe extern "C" {
614
+
pub fn e_source_get_remote_creatable(source: *mut ESource) -> gboolean;
615
+
}
616
+
unsafe extern "C" {
617
+
pub fn e_source_get_remote_deletable(source: *mut ESource) -> gboolean;
618
+
}
619
+
unsafe extern "C" {
620
+
pub fn e_source_get_extension(source: *mut ESource, extension_name: *const gchar) -> gpointer;
621
+
}
622
+
unsafe extern "C" {
623
+
pub fn e_source_has_extension(source: *mut ESource, extension_name: *const gchar) -> gboolean;
624
+
}
625
+
unsafe extern "C" {
626
+
pub fn e_source_ref_dbus_object(source: *mut ESource) -> *mut GDBusObject;
627
+
}
628
+
unsafe extern "C" {
629
+
pub fn e_source_ref_main_context(source: *mut ESource) -> *mut GMainContext;
630
+
}
631
+
unsafe extern "C" {
632
+
pub fn e_source_get_display_name(source: *mut ESource) -> *const gchar;
633
+
}
634
+
unsafe extern "C" {
635
+
pub fn e_source_dup_display_name(source: *mut ESource) -> *mut gchar;
636
+
}
637
+
unsafe extern "C" {
638
+
pub fn e_source_set_display_name(source: *mut ESource, display_name: *const gchar);
639
+
}
640
+
unsafe extern "C" {
641
+
pub fn e_source_dup_secret_label(source: *mut ESource) -> *mut gchar;
642
+
}
643
+
unsafe extern "C" {
644
+
pub fn e_source_compare_by_display_name(source1: *mut ESource, source2: *mut ESource) -> gint;
645
+
}
646
+
unsafe extern "C" {
647
+
pub fn e_source_to_string(source: *mut ESource, length: *mut gsize) -> *mut gchar;
648
+
}
649
+
unsafe extern "C" {
650
+
pub fn e_source_parameter_to_key(param_name: *const gchar) -> *mut gchar;
651
+
}
652
+
unsafe extern "C" {
653
+
pub fn e_source_get_connection_status(source: *mut ESource) -> ESourceConnectionStatus;
654
+
}
655
+
unsafe extern "C" {
656
+
pub fn e_source_set_connection_status(
657
+
source: *mut ESource,
658
+
connection_status: ESourceConnectionStatus,
659
+
);
660
+
}
661
+
unsafe extern "C" {
662
+
pub fn e_source_remove_sync(
663
+
source: *mut ESource,
664
+
cancellable: *mut GCancellable,
665
+
error: *mut *mut GError,
666
+
) -> gboolean;
667
+
}
668
+
unsafe extern "C" {
669
+
pub fn e_source_remove(
670
+
source: *mut ESource,
671
+
cancellable: *mut GCancellable,
672
+
callback: GAsyncReadyCallback,
673
+
user_data: gpointer,
674
+
);
675
+
}
676
+
unsafe extern "C" {
677
+
pub fn e_source_remove_finish(
678
+
source: *mut ESource,
679
+
result: *mut GAsyncResult,
680
+
error: *mut *mut GError,
681
+
) -> gboolean;
682
+
}
683
+
unsafe extern "C" {
684
+
pub fn e_source_write_sync(
685
+
source: *mut ESource,
686
+
cancellable: *mut GCancellable,
687
+
error: *mut *mut GError,
688
+
) -> gboolean;
689
+
}
690
+
unsafe extern "C" {
691
+
pub fn e_source_write(
692
+
source: *mut ESource,
693
+
cancellable: *mut GCancellable,
694
+
callback: GAsyncReadyCallback,
695
+
user_data: gpointer,
696
+
);
697
+
}
698
+
unsafe extern "C" {
699
+
pub fn e_source_write_finish(
700
+
source: *mut ESource,
701
+
result: *mut GAsyncResult,
702
+
error: *mut *mut GError,
703
+
) -> gboolean;
704
+
}
705
+
unsafe extern "C" {
706
+
pub fn e_source_remote_create_sync(
707
+
source: *mut ESource,
708
+
scratch_source: *mut ESource,
709
+
cancellable: *mut GCancellable,
710
+
error: *mut *mut GError,
711
+
) -> gboolean;
712
+
}
713
+
unsafe extern "C" {
714
+
pub fn e_source_remote_create(
715
+
source: *mut ESource,
716
+
scratch_source: *mut ESource,
717
+
cancellable: *mut GCancellable,
718
+
callback: GAsyncReadyCallback,
719
+
user_data: gpointer,
720
+
);
721
+
}
722
+
unsafe extern "C" {
723
+
pub fn e_source_remote_create_finish(
724
+
source: *mut ESource,
725
+
result: *mut GAsyncResult,
726
+
error: *mut *mut GError,
727
+
) -> gboolean;
728
+
}
729
+
unsafe extern "C" {
730
+
pub fn e_source_remote_delete_sync(
731
+
source: *mut ESource,
732
+
cancellable: *mut GCancellable,
733
+
error: *mut *mut GError,
734
+
) -> gboolean;
735
+
}
736
+
unsafe extern "C" {
737
+
pub fn e_source_remote_delete(
738
+
source: *mut ESource,
739
+
cancellable: *mut GCancellable,
740
+
callback: GAsyncReadyCallback,
741
+
user_data: gpointer,
742
+
);
743
+
}
744
+
unsafe extern "C" {
745
+
pub fn e_source_remote_delete_finish(
746
+
source: *mut ESource,
747
+
result: *mut GAsyncResult,
748
+
error: *mut *mut GError,
749
+
) -> gboolean;
750
+
}
751
+
unsafe extern "C" {
752
+
pub fn e_source_get_oauth2_access_token_sync(
753
+
source: *mut ESource,
754
+
cancellable: *mut GCancellable,
755
+
out_access_token: *mut *mut gchar,
756
+
out_expires_in: *mut gint,
757
+
error: *mut *mut GError,
758
+
) -> gboolean;
759
+
}
760
+
unsafe extern "C" {
761
+
pub fn e_source_get_oauth2_access_token(
762
+
source: *mut ESource,
763
+
cancellable: *mut GCancellable,
764
+
callback: GAsyncReadyCallback,
765
+
user_data: gpointer,
766
+
);
767
+
}
768
+
unsafe extern "C" {
769
+
pub fn e_source_get_oauth2_access_token_finish(
770
+
source: *mut ESource,
771
+
result: *mut GAsyncResult,
772
+
out_access_token: *mut *mut gchar,
773
+
out_expires_in: *mut gint,
774
+
error: *mut *mut GError,
775
+
) -> gboolean;
776
+
}
777
+
unsafe extern "C" {
778
+
pub fn e_source_store_password_sync(
779
+
source: *mut ESource,
780
+
password: *const gchar,
781
+
permanently: gboolean,
782
+
cancellable: *mut GCancellable,
783
+
error: *mut *mut GError,
784
+
) -> gboolean;
785
+
}
786
+
unsafe extern "C" {
787
+
pub fn e_source_store_password(
788
+
source: *mut ESource,
789
+
password: *const gchar,
790
+
permanently: gboolean,
791
+
cancellable: *mut GCancellable,
792
+
callback: GAsyncReadyCallback,
793
+
user_data: gpointer,
794
+
);
795
+
}
796
+
unsafe extern "C" {
797
+
pub fn e_source_store_password_finish(
798
+
source: *mut ESource,
799
+
result: *mut GAsyncResult,
800
+
error: *mut *mut GError,
801
+
) -> gboolean;
802
+
}
803
+
unsafe extern "C" {
804
+
pub fn e_source_lookup_password_sync(
805
+
source: *mut ESource,
806
+
cancellable: *mut GCancellable,
807
+
out_password: *mut *mut gchar,
808
+
error: *mut *mut GError,
809
+
) -> gboolean;
810
+
}
811
+
unsafe extern "C" {
812
+
pub fn e_source_lookup_password(
813
+
source: *mut ESource,
814
+
cancellable: *mut GCancellable,
815
+
callback: GAsyncReadyCallback,
816
+
user_data: gpointer,
817
+
);
818
+
}
819
+
unsafe extern "C" {
820
+
pub fn e_source_lookup_password_finish(
821
+
source: *mut ESource,
822
+
result: *mut GAsyncResult,
823
+
out_password: *mut *mut gchar,
824
+
error: *mut *mut GError,
825
+
) -> gboolean;
826
+
}
827
+
unsafe extern "C" {
828
+
pub fn e_source_delete_password_sync(
829
+
source: *mut ESource,
830
+
cancellable: *mut GCancellable,
831
+
error: *mut *mut GError,
832
+
) -> gboolean;
833
+
}
834
+
unsafe extern "C" {
835
+
pub fn e_source_delete_password(
836
+
source: *mut ESource,
837
+
cancellable: *mut GCancellable,
838
+
callback: GAsyncReadyCallback,
839
+
user_data: gpointer,
840
+
);
841
+
}
842
+
unsafe extern "C" {
843
+
pub fn e_source_delete_password_finish(
844
+
source: *mut ESource,
845
+
result: *mut GAsyncResult,
846
+
error: *mut *mut GError,
847
+
) -> gboolean;
848
+
}
849
+
unsafe extern "C" {
850
+
pub fn e_source_invoke_credentials_required_sync(
851
+
source: *mut ESource,
852
+
reason: ESourceCredentialsReason,
853
+
certificate_pem: *const gchar,
854
+
certificate_errors: GTlsCertificateFlags,
855
+
op_error: *const GError,
856
+
cancellable: *mut GCancellable,
857
+
error: *mut *mut GError,
858
+
) -> gboolean;
859
+
}
860
+
unsafe extern "C" {
861
+
pub fn e_source_invoke_credentials_required(
862
+
source: *mut ESource,
863
+
reason: ESourceCredentialsReason,
864
+
certificate_pem: *const gchar,
865
+
certificate_errors: GTlsCertificateFlags,
866
+
op_error: *const GError,
867
+
cancellable: *mut GCancellable,
868
+
callback: GAsyncReadyCallback,
869
+
user_data: gpointer,
870
+
);
871
+
}
872
+
unsafe extern "C" {
873
+
pub fn e_source_invoke_credentials_required_finish(
874
+
source: *mut ESource,
875
+
result: *mut GAsyncResult,
876
+
error: *mut *mut GError,
877
+
) -> gboolean;
878
+
}
879
+
unsafe extern "C" {
880
+
pub fn e_source_invoke_authenticate_sync(
881
+
source: *mut ESource,
882
+
credentials: *const ENamedParameters,
883
+
cancellable: *mut GCancellable,
884
+
error: *mut *mut GError,
885
+
) -> gboolean;
886
+
}
887
+
unsafe extern "C" {
888
+
pub fn e_source_invoke_authenticate(
889
+
source: *mut ESource,
890
+
credentials: *const ENamedParameters,
891
+
cancellable: *mut GCancellable,
892
+
callback: GAsyncReadyCallback,
893
+
user_data: gpointer,
894
+
);
895
+
}
896
+
unsafe extern "C" {
897
+
pub fn e_source_invoke_authenticate_finish(
898
+
source: *mut ESource,
899
+
result: *mut GAsyncResult,
900
+
error: *mut *mut GError,
901
+
) -> gboolean;
902
+
}
903
+
unsafe extern "C" {
904
+
pub fn e_source_emit_credentials_required(
905
+
source: *mut ESource,
906
+
reason: ESourceCredentialsReason,
907
+
certificate_pem: *const gchar,
908
+
certificate_errors: GTlsCertificateFlags,
909
+
op_error: *const GError,
910
+
);
911
+
}
912
+
unsafe extern "C" {
913
+
pub fn e_source_get_last_credentials_required_arguments_sync(
914
+
source: *mut ESource,
915
+
out_reason: *mut ESourceCredentialsReason,
916
+
out_certificate_pem: *mut *mut gchar,
917
+
out_certificate_errors: *mut GTlsCertificateFlags,
918
+
out_op_error: *mut *mut GError,
919
+
cancellable: *mut GCancellable,
920
+
error: *mut *mut GError,
921
+
) -> gboolean;
922
+
}
923
+
unsafe extern "C" {
924
+
pub fn e_source_get_last_credentials_required_arguments(
925
+
source: *mut ESource,
926
+
cancellable: *mut GCancellable,
927
+
callback: GAsyncReadyCallback,
928
+
user_data: gpointer,
929
+
);
930
+
}
931
+
unsafe extern "C" {
932
+
pub fn e_source_get_last_credentials_required_arguments_finish(
933
+
source: *mut ESource,
934
+
result: *mut GAsyncResult,
935
+
out_reason: *mut ESourceCredentialsReason,
936
+
out_certificate_pem: *mut *mut gchar,
937
+
out_certificate_errors: *mut GTlsCertificateFlags,
938
+
out_op_error: *mut *mut GError,
939
+
error: *mut *mut GError,
940
+
) -> gboolean;
941
+
}
942
+
unsafe extern "C" {
943
+
pub fn e_source_unset_last_credentials_required_arguments_sync(
944
+
source: *mut ESource,
945
+
cancellable: *mut GCancellable,
946
+
error: *mut *mut GError,
947
+
) -> gboolean;
948
+
}
949
+
unsafe extern "C" {
950
+
pub fn e_source_unset_last_credentials_required_arguments(
951
+
source: *mut ESource,
952
+
cancellable: *mut GCancellable,
953
+
callback: GAsyncReadyCallback,
954
+
user_data: gpointer,
955
+
);
956
+
}
957
+
unsafe extern "C" {
958
+
pub fn e_source_unset_last_credentials_required_arguments_finish(
959
+
source: *mut ESource,
960
+
result: *mut GAsyncResult,
961
+
error: *mut *mut GError,
962
+
) -> gboolean;
963
+
}
964
+
#[doc = " EClient:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.2"]
965
+
pub type EClient = _EClient;
966
+
#[repr(C)]
967
+
#[derive(Debug, Copy, Clone)]
968
+
pub struct _EClientPrivate {
969
+
_unused: [u8; 0],
970
+
}
971
+
pub type EClientPrivate = _EClientPrivate;
972
+
#[repr(C)]
973
+
#[derive(Debug, Copy, Clone)]
974
+
pub struct _EClient {
975
+
pub parent: GObject,
976
+
pub priv_: *mut EClientPrivate,
977
+
}
978
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
979
+
const _: () = {
980
+
["Size of _EClient"][::std::mem::size_of::<_EClient>() - 32usize];
981
+
["Alignment of _EClient"][::std::mem::align_of::<_EClient>() - 8usize];
982
+
["Offset of field: _EClient::parent"][::std::mem::offset_of!(_EClient, parent) - 0usize];
983
+
["Offset of field: _EClient::priv_"][::std::mem::offset_of!(_EClient, priv_) - 24usize];
984
+
};
985
+
unsafe extern "C" {
986
+
pub fn e_source_authentication_result_get_type() -> GType;
987
+
}
988
+
unsafe extern "C" {
989
+
pub fn e_source_connection_status_get_type() -> GType;
990
+
}
991
+
unsafe extern "C" {
992
+
pub fn e_source_credentials_reason_get_type() -> GType;
993
+
}
994
+
unsafe extern "C" {
995
+
pub fn e_source_ldap_authentication_get_type() -> GType;
996
+
}
997
+
unsafe extern "C" {
998
+
pub fn e_source_ldap_scope_get_type() -> GType;
999
+
}
1000
+
unsafe extern "C" {
1001
+
pub fn e_source_ldap_security_get_type() -> GType;
1002
+
}
1003
+
unsafe extern "C" {
1004
+
pub fn e_source_weather_units_get_type() -> GType;
1005
+
}
1006
+
unsafe extern "C" {
1007
+
pub fn e_source_mail_composition_reply_style_get_type() -> GType;
1008
+
}
1009
+
unsafe extern "C" {
1010
+
pub fn e_source_registry_debug_enabled() -> gboolean;
1011
+
}
1012
+
unsafe extern "C" {
1013
+
pub fn e_source_registry_debug_print(format: *const gchar, ...);
1014
+
}
1015
+
#[doc = " EExtension:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.4"]
1016
+
pub type EExtension = _EExtension;
1017
+
#[repr(C)]
1018
+
#[derive(Debug, Copy, Clone)]
1019
+
pub struct _EExtensionPrivate {
1020
+
_unused: [u8; 0],
1021
+
}
1022
+
pub type EExtensionPrivate = _EExtensionPrivate;
1023
+
#[doc = " EExtension:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.4"]
1024
+
#[repr(C)]
1025
+
#[derive(Debug, Copy, Clone)]
1026
+
pub struct _EExtension {
1027
+
pub parent: GObject,
1028
+
pub priv_: *mut EExtensionPrivate,
1029
+
}
1030
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1031
+
const _: () = {
1032
+
["Size of _EExtension"][::std::mem::size_of::<_EExtension>() - 32usize];
1033
+
["Alignment of _EExtension"][::std::mem::align_of::<_EExtension>() - 8usize];
1034
+
["Offset of field: _EExtension::parent"][::std::mem::offset_of!(_EExtension, parent) - 0usize];
1035
+
["Offset of field: _EExtension::priv_"][::std::mem::offset_of!(_EExtension, priv_) - 24usize];
1036
+
};
1037
+
pub type FILE = _IO_FILE;
1038
+
#[repr(C)]
1039
+
#[derive(Debug, Copy, Clone)]
1040
+
pub struct _IO_marker {
1041
+
_unused: [u8; 0],
1042
+
}
1043
+
#[repr(C)]
1044
+
#[derive(Debug, Copy, Clone)]
1045
+
pub struct _IO_codecvt {
1046
+
_unused: [u8; 0],
1047
+
}
1048
+
#[repr(C)]
1049
+
#[derive(Debug, Copy, Clone)]
1050
+
pub struct _IO_wide_data {
1051
+
_unused: [u8; 0],
1052
+
}
1053
+
pub type _IO_lock_t = ::std::os::raw::c_void;
1054
+
#[repr(C)]
1055
+
#[derive(Debug, Copy, Clone)]
1056
+
pub struct _IO_FILE {
1057
+
pub _flags: ::std::os::raw::c_int,
1058
+
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
1059
+
pub _IO_read_end: *mut ::std::os::raw::c_char,
1060
+
pub _IO_read_base: *mut ::std::os::raw::c_char,
1061
+
pub _IO_write_base: *mut ::std::os::raw::c_char,
1062
+
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
1063
+
pub _IO_write_end: *mut ::std::os::raw::c_char,
1064
+
pub _IO_buf_base: *mut ::std::os::raw::c_char,
1065
+
pub _IO_buf_end: *mut ::std::os::raw::c_char,
1066
+
pub _IO_save_base: *mut ::std::os::raw::c_char,
1067
+
pub _IO_backup_base: *mut ::std::os::raw::c_char,
1068
+
pub _IO_save_end: *mut ::std::os::raw::c_char,
1069
+
pub _markers: *mut _IO_marker,
1070
+
pub _chain: *mut _IO_FILE,
1071
+
pub _fileno: ::std::os::raw::c_int,
1072
+
pub _bitfield_align_1: [u32; 0],
1073
+
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 3usize]>,
1074
+
pub _short_backupbuf: [::std::os::raw::c_char; 1usize],
1075
+
pub _old_offset: __off_t,
1076
+
pub _cur_column: ::std::os::raw::c_ushort,
1077
+
pub _vtable_offset: ::std::os::raw::c_schar,
1078
+
pub _shortbuf: [::std::os::raw::c_char; 1usize],
1079
+
pub _lock: *mut _IO_lock_t,
1080
+
pub _offset: __off64_t,
1081
+
pub _codecvt: *mut _IO_codecvt,
1082
+
pub _wide_data: *mut _IO_wide_data,
1083
+
pub _freeres_list: *mut _IO_FILE,
1084
+
pub _freeres_buf: *mut ::std::os::raw::c_void,
1085
+
pub _prevchain: *mut *mut _IO_FILE,
1086
+
pub _mode: ::std::os::raw::c_int,
1087
+
pub _unused3: ::std::os::raw::c_int,
1088
+
pub _total_written: __uint64_t,
1089
+
pub _unused2: [::std::os::raw::c_char; 8usize],
1090
+
}
1091
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1092
+
const _: () = {
1093
+
["Size of _IO_FILE"][::std::mem::size_of::<_IO_FILE>() - 216usize];
1094
+
["Alignment of _IO_FILE"][::std::mem::align_of::<_IO_FILE>() - 8usize];
1095
+
["Offset of field: _IO_FILE::_flags"][::std::mem::offset_of!(_IO_FILE, _flags) - 0usize];
1096
+
["Offset of field: _IO_FILE::_IO_read_ptr"]
1097
+
[::std::mem::offset_of!(_IO_FILE, _IO_read_ptr) - 8usize];
1098
+
["Offset of field: _IO_FILE::_IO_read_end"]
1099
+
[::std::mem::offset_of!(_IO_FILE, _IO_read_end) - 16usize];
1100
+
["Offset of field: _IO_FILE::_IO_read_base"]
1101
+
[::std::mem::offset_of!(_IO_FILE, _IO_read_base) - 24usize];
1102
+
["Offset of field: _IO_FILE::_IO_write_base"]
1103
+
[::std::mem::offset_of!(_IO_FILE, _IO_write_base) - 32usize];
1104
+
["Offset of field: _IO_FILE::_IO_write_ptr"]
1105
+
[::std::mem::offset_of!(_IO_FILE, _IO_write_ptr) - 40usize];
1106
+
["Offset of field: _IO_FILE::_IO_write_end"]
1107
+
[::std::mem::offset_of!(_IO_FILE, _IO_write_end) - 48usize];
1108
+
["Offset of field: _IO_FILE::_IO_buf_base"]
1109
+
[::std::mem::offset_of!(_IO_FILE, _IO_buf_base) - 56usize];
1110
+
["Offset of field: _IO_FILE::_IO_buf_end"]
1111
+
[::std::mem::offset_of!(_IO_FILE, _IO_buf_end) - 64usize];
1112
+
["Offset of field: _IO_FILE::_IO_save_base"]
1113
+
[::std::mem::offset_of!(_IO_FILE, _IO_save_base) - 72usize];
1114
+
["Offset of field: _IO_FILE::_IO_backup_base"]
1115
+
[::std::mem::offset_of!(_IO_FILE, _IO_backup_base) - 80usize];
1116
+
["Offset of field: _IO_FILE::_IO_save_end"]
1117
+
[::std::mem::offset_of!(_IO_FILE, _IO_save_end) - 88usize];
1118
+
["Offset of field: _IO_FILE::_markers"][::std::mem::offset_of!(_IO_FILE, _markers) - 96usize];
1119
+
["Offset of field: _IO_FILE::_chain"][::std::mem::offset_of!(_IO_FILE, _chain) - 104usize];
1120
+
["Offset of field: _IO_FILE::_fileno"][::std::mem::offset_of!(_IO_FILE, _fileno) - 112usize];
1121
+
["Offset of field: _IO_FILE::_short_backupbuf"]
1122
+
[::std::mem::offset_of!(_IO_FILE, _short_backupbuf) - 119usize];
1123
+
["Offset of field: _IO_FILE::_old_offset"]
1124
+
[::std::mem::offset_of!(_IO_FILE, _old_offset) - 120usize];
1125
+
["Offset of field: _IO_FILE::_cur_column"]
1126
+
[::std::mem::offset_of!(_IO_FILE, _cur_column) - 128usize];
1127
+
["Offset of field: _IO_FILE::_vtable_offset"]
1128
+
[::std::mem::offset_of!(_IO_FILE, _vtable_offset) - 130usize];
1129
+
["Offset of field: _IO_FILE::_shortbuf"]
1130
+
[::std::mem::offset_of!(_IO_FILE, _shortbuf) - 131usize];
1131
+
["Offset of field: _IO_FILE::_lock"][::std::mem::offset_of!(_IO_FILE, _lock) - 136usize];
1132
+
["Offset of field: _IO_FILE::_offset"][::std::mem::offset_of!(_IO_FILE, _offset) - 144usize];
1133
+
["Offset of field: _IO_FILE::_codecvt"][::std::mem::offset_of!(_IO_FILE, _codecvt) - 152usize];
1134
+
["Offset of field: _IO_FILE::_wide_data"]
1135
+
[::std::mem::offset_of!(_IO_FILE, _wide_data) - 160usize];
1136
+
["Offset of field: _IO_FILE::_freeres_list"]
1137
+
[::std::mem::offset_of!(_IO_FILE, _freeres_list) - 168usize];
1138
+
["Offset of field: _IO_FILE::_freeres_buf"]
1139
+
[::std::mem::offset_of!(_IO_FILE, _freeres_buf) - 176usize];
1140
+
["Offset of field: _IO_FILE::_prevchain"]
1141
+
[::std::mem::offset_of!(_IO_FILE, _prevchain) - 184usize];
1142
+
["Offset of field: _IO_FILE::_mode"][::std::mem::offset_of!(_IO_FILE, _mode) - 192usize];
1143
+
["Offset of field: _IO_FILE::_unused3"][::std::mem::offset_of!(_IO_FILE, _unused3) - 196usize];
1144
+
["Offset of field: _IO_FILE::_total_written"]
1145
+
[::std::mem::offset_of!(_IO_FILE, _total_written) - 200usize];
1146
+
["Offset of field: _IO_FILE::_unused2"][::std::mem::offset_of!(_IO_FILE, _unused2) - 208usize];
1147
+
};
1148
+
impl _IO_FILE {
1149
+
#[inline]
1150
+
pub fn _flags2(&self) -> ::std::os::raw::c_int {
1151
+
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) }
1152
+
}
1153
+
#[inline]
1154
+
pub fn set__flags2(&mut self, val: ::std::os::raw::c_int) {
1155
+
unsafe {
1156
+
let val: u32 = ::std::mem::transmute(val);
1157
+
self._bitfield_1.set(0usize, 24u8, val as u64)
1158
+
}
1159
+
}
1160
+
#[inline]
1161
+
pub unsafe fn _flags2_raw(this: *const Self) -> ::std::os::raw::c_int {
1162
+
unsafe {
1163
+
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_get(
1164
+
::std::ptr::addr_of!((*this)._bitfield_1),
1165
+
0usize,
1166
+
24u8,
1167
+
) as u32)
1168
+
}
1169
+
}
1170
+
#[inline]
1171
+
pub unsafe fn set__flags2_raw(this: *mut Self, val: ::std::os::raw::c_int) {
1172
+
unsafe {
1173
+
let val: u32 = ::std::mem::transmute(val);
1174
+
<__BindgenBitfieldUnit<[u8; 3usize]>>::raw_set(
1175
+
::std::ptr::addr_of_mut!((*this)._bitfield_1),
1176
+
0usize,
1177
+
24u8,
1178
+
val as u64,
1179
+
)
1180
+
}
1181
+
}
1182
+
#[inline]
1183
+
pub fn new_bitfield_1(_flags2: ::std::os::raw::c_int) -> __BindgenBitfieldUnit<[u8; 3usize]> {
1184
+
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 3usize]> = Default::default();
1185
+
__bindgen_bitfield_unit.set(0usize, 24u8, {
1186
+
let _flags2: u32 = unsafe { ::std::mem::transmute(_flags2) };
1187
+
_flags2 as u64
1188
+
});
1189
+
__bindgen_bitfield_unit
1190
+
}
1191
+
}
1192
+
#[doc = " EOAuth2Services:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.28"]
1193
+
pub type EOAuth2Services = _EOAuth2Services;
1194
+
#[repr(C)]
1195
+
#[derive(Debug, Copy, Clone)]
1196
+
pub struct _EOAuth2ServicesPrivate {
1197
+
_unused: [u8; 0],
1198
+
}
1199
+
pub type EOAuth2ServicesPrivate = _EOAuth2ServicesPrivate;
1200
+
#[doc = " EOAuth2Services:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.28"]
1201
+
#[repr(C)]
1202
+
#[derive(Debug, Copy, Clone)]
1203
+
pub struct _EOAuth2Services {
1204
+
pub parent: GObject,
1205
+
pub priv_: *mut EOAuth2ServicesPrivate,
1206
+
}
1207
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1208
+
const _: () = {
1209
+
["Size of _EOAuth2Services"][::std::mem::size_of::<_EOAuth2Services>() - 32usize];
1210
+
["Alignment of _EOAuth2Services"][::std::mem::align_of::<_EOAuth2Services>() - 8usize];
1211
+
["Offset of field: _EOAuth2Services::parent"]
1212
+
[::std::mem::offset_of!(_EOAuth2Services, parent) - 0usize];
1213
+
["Offset of field: _EOAuth2Services::priv_"]
1214
+
[::std::mem::offset_of!(_EOAuth2Services, priv_) - 24usize];
1215
+
};
1216
+
#[doc = " ESourceExtension:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1217
+
pub type ESourceExtension = _ESourceExtension;
1218
+
#[repr(C)]
1219
+
#[derive(Debug, Copy, Clone)]
1220
+
pub struct _ESourceExtensionPrivate {
1221
+
_unused: [u8; 0],
1222
+
}
1223
+
pub type ESourceExtensionPrivate = _ESourceExtensionPrivate;
1224
+
#[doc = " ESourceExtension:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1225
+
#[repr(C)]
1226
+
#[derive(Debug, Copy, Clone)]
1227
+
pub struct _ESourceExtension {
1228
+
pub parent: GObject,
1229
+
pub priv_: *mut ESourceExtensionPrivate,
1230
+
}
1231
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1232
+
const _: () = {
1233
+
["Size of _ESourceExtension"][::std::mem::size_of::<_ESourceExtension>() - 32usize];
1234
+
["Alignment of _ESourceExtension"][::std::mem::align_of::<_ESourceExtension>() - 8usize];
1235
+
["Offset of field: _ESourceExtension::parent"]
1236
+
[::std::mem::offset_of!(_ESourceExtension, parent) - 0usize];
1237
+
["Offset of field: _ESourceExtension::priv_"]
1238
+
[::std::mem::offset_of!(_ESourceExtension, priv_) - 24usize];
1239
+
};
1240
+
unsafe extern "C" {
1241
+
pub fn e_source_extension_get_type() -> GType;
1242
+
}
1243
+
unsafe extern "C" {
1244
+
pub fn e_source_extension_ref_source(extension: *mut ESourceExtension) -> *mut ESource;
1245
+
}
1246
+
unsafe extern "C" {
1247
+
pub fn e_source_extension_property_lock(extension: *mut ESourceExtension);
1248
+
}
1249
+
unsafe extern "C" {
1250
+
pub fn e_source_extension_property_unlock(extension: *mut ESourceExtension);
1251
+
}
1252
+
unsafe extern "C" {
1253
+
pub fn e_source_extension_get_source(extension: *mut ESourceExtension) -> *mut ESource;
1254
+
}
1255
+
#[doc = " ESourceBackend:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1256
+
pub type ESourceBackend = _ESourceBackend;
1257
+
#[repr(C)]
1258
+
#[derive(Debug, Copy, Clone)]
1259
+
pub struct _ESourceBackendPrivate {
1260
+
_unused: [u8; 0],
1261
+
}
1262
+
pub type ESourceBackendPrivate = _ESourceBackendPrivate;
1263
+
#[doc = " ESourceBackend:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1264
+
#[repr(C)]
1265
+
#[derive(Debug, Copy, Clone)]
1266
+
pub struct _ESourceBackend {
1267
+
pub parent: ESourceExtension,
1268
+
pub priv_: *mut ESourceBackendPrivate,
1269
+
}
1270
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1271
+
const _: () = {
1272
+
["Size of _ESourceBackend"][::std::mem::size_of::<_ESourceBackend>() - 40usize];
1273
+
["Alignment of _ESourceBackend"][::std::mem::align_of::<_ESourceBackend>() - 8usize];
1274
+
["Offset of field: _ESourceBackend::parent"]
1275
+
[::std::mem::offset_of!(_ESourceBackend, parent) - 0usize];
1276
+
["Offset of field: _ESourceBackend::priv_"]
1277
+
[::std::mem::offset_of!(_ESourceBackend, priv_) - 32usize];
1278
+
};
1279
+
unsafe extern "C" {
1280
+
pub fn e_source_backend_get_type() -> GType;
1281
+
}
1282
+
unsafe extern "C" {
1283
+
pub fn e_source_backend_get_backend_name(extension: *mut ESourceBackend) -> *const gchar;
1284
+
}
1285
+
unsafe extern "C" {
1286
+
pub fn e_source_backend_dup_backend_name(extension: *mut ESourceBackend) -> *mut gchar;
1287
+
}
1288
+
unsafe extern "C" {
1289
+
pub fn e_source_backend_set_backend_name(
1290
+
extension: *mut ESourceBackend,
1291
+
backend_name: *const gchar,
1292
+
);
1293
+
}
1294
+
#[doc = " ESourceAddressBook:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1295
+
pub type ESourceAddressBook = _ESourceAddressBook;
1296
+
#[repr(C)]
1297
+
#[derive(Debug, Copy, Clone)]
1298
+
pub struct _ESourceAddressBookPrivate {
1299
+
_unused: [u8; 0],
1300
+
}
1301
+
pub type ESourceAddressBookPrivate = _ESourceAddressBookPrivate;
1302
+
#[doc = " ESourceAddressBook:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1303
+
#[repr(C)]
1304
+
#[derive(Debug, Copy, Clone)]
1305
+
pub struct _ESourceAddressBook {
1306
+
pub parent: ESourceBackend,
1307
+
pub priv_: *mut ESourceAddressBookPrivate,
1308
+
}
1309
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1310
+
const _: () = {
1311
+
["Size of _ESourceAddressBook"][::std::mem::size_of::<_ESourceAddressBook>() - 48usize];
1312
+
["Alignment of _ESourceAddressBook"][::std::mem::align_of::<_ESourceAddressBook>() - 8usize];
1313
+
["Offset of field: _ESourceAddressBook::parent"]
1314
+
[::std::mem::offset_of!(_ESourceAddressBook, parent) - 0usize];
1315
+
["Offset of field: _ESourceAddressBook::priv_"]
1316
+
[::std::mem::offset_of!(_ESourceAddressBook, priv_) - 40usize];
1317
+
};
1318
+
unsafe extern "C" {
1319
+
pub fn e_source_address_book_get_type() -> GType;
1320
+
}
1321
+
unsafe extern "C" {
1322
+
pub fn e_source_address_book_get_order(extension: *mut ESourceAddressBook) -> guint;
1323
+
}
1324
+
unsafe extern "C" {
1325
+
pub fn e_source_address_book_set_order(extension: *mut ESourceAddressBook, order: guint);
1326
+
}
1327
+
#[doc = " ESourceAlarms:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1328
+
pub type ESourceAlarms = _ESourceAlarms;
1329
+
#[repr(C)]
1330
+
#[derive(Debug, Copy, Clone)]
1331
+
pub struct _ESourceAlarmsPrivate {
1332
+
_unused: [u8; 0],
1333
+
}
1334
+
pub type ESourceAlarmsPrivate = _ESourceAlarmsPrivate;
1335
+
#[doc = " ESourceAlarms:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1336
+
#[repr(C)]
1337
+
#[derive(Debug, Copy, Clone)]
1338
+
pub struct _ESourceAlarms {
1339
+
pub parent: ESourceExtension,
1340
+
pub priv_: *mut ESourceAlarmsPrivate,
1341
+
}
1342
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1343
+
const _: () = {
1344
+
["Size of _ESourceAlarms"][::std::mem::size_of::<_ESourceAlarms>() - 40usize];
1345
+
["Alignment of _ESourceAlarms"][::std::mem::align_of::<_ESourceAlarms>() - 8usize];
1346
+
["Offset of field: _ESourceAlarms::parent"]
1347
+
[::std::mem::offset_of!(_ESourceAlarms, parent) - 0usize];
1348
+
["Offset of field: _ESourceAlarms::priv_"]
1349
+
[::std::mem::offset_of!(_ESourceAlarms, priv_) - 32usize];
1350
+
};
1351
+
unsafe extern "C" {
1352
+
pub fn e_source_alarms_get_type() -> GType;
1353
+
}
1354
+
unsafe extern "C" {
1355
+
pub fn e_source_alarms_get_include_me(extension: *mut ESourceAlarms) -> gboolean;
1356
+
}
1357
+
unsafe extern "C" {
1358
+
pub fn e_source_alarms_set_include_me(extension: *mut ESourceAlarms, include_me: gboolean);
1359
+
}
1360
+
unsafe extern "C" {
1361
+
pub fn e_source_alarms_get_last_notified(extension: *mut ESourceAlarms) -> *const gchar;
1362
+
}
1363
+
unsafe extern "C" {
1364
+
pub fn e_source_alarms_dup_last_notified(extension: *mut ESourceAlarms) -> *mut gchar;
1365
+
}
1366
+
unsafe extern "C" {
1367
+
pub fn e_source_alarms_set_last_notified(
1368
+
extension: *mut ESourceAlarms,
1369
+
last_notified: *const gchar,
1370
+
);
1371
+
}
1372
+
unsafe extern "C" {
1373
+
pub fn e_source_alarms_get_for_every_event(extension: *mut ESourceAlarms) -> gboolean;
1374
+
}
1375
+
unsafe extern "C" {
1376
+
pub fn e_source_alarms_set_for_every_event(
1377
+
extension: *mut ESourceAlarms,
1378
+
for_every_event: gboolean,
1379
+
);
1380
+
}
1381
+
#[doc = " ESourceAuthentication:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1382
+
pub type ESourceAuthentication = _ESourceAuthentication;
1383
+
#[repr(C)]
1384
+
#[derive(Debug, Copy, Clone)]
1385
+
pub struct _ESourceAuthenticationPrivate {
1386
+
_unused: [u8; 0],
1387
+
}
1388
+
pub type ESourceAuthenticationPrivate = _ESourceAuthenticationPrivate;
1389
+
#[doc = " ESourceAuthentication:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1390
+
#[repr(C)]
1391
+
#[derive(Debug, Copy, Clone)]
1392
+
pub struct _ESourceAuthentication {
1393
+
pub parent: ESourceExtension,
1394
+
pub priv_: *mut ESourceAuthenticationPrivate,
1395
+
}
1396
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1397
+
const _: () = {
1398
+
["Size of _ESourceAuthentication"][::std::mem::size_of::<_ESourceAuthentication>() - 40usize];
1399
+
["Alignment of _ESourceAuthentication"]
1400
+
[::std::mem::align_of::<_ESourceAuthentication>() - 8usize];
1401
+
["Offset of field: _ESourceAuthentication::parent"]
1402
+
[::std::mem::offset_of!(_ESourceAuthentication, parent) - 0usize];
1403
+
["Offset of field: _ESourceAuthentication::priv_"]
1404
+
[::std::mem::offset_of!(_ESourceAuthentication, priv_) - 32usize];
1405
+
};
1406
+
unsafe extern "C" {
1407
+
pub fn e_source_authentication_get_type() -> GType;
1408
+
}
1409
+
unsafe extern "C" {
1410
+
pub fn e_source_authentication_required(extension: *mut ESourceAuthentication) -> gboolean;
1411
+
}
1412
+
unsafe extern "C" {
1413
+
pub fn e_source_authentication_ref_connectable(
1414
+
extension: *mut ESourceAuthentication,
1415
+
) -> *mut GSocketConnectable;
1416
+
}
1417
+
unsafe extern "C" {
1418
+
pub fn e_source_authentication_get_host(extension: *mut ESourceAuthentication) -> *const gchar;
1419
+
}
1420
+
unsafe extern "C" {
1421
+
pub fn e_source_authentication_dup_host(extension: *mut ESourceAuthentication) -> *mut gchar;
1422
+
}
1423
+
unsafe extern "C" {
1424
+
pub fn e_source_authentication_set_host(
1425
+
extension: *mut ESourceAuthentication,
1426
+
host: *const gchar,
1427
+
);
1428
+
}
1429
+
unsafe extern "C" {
1430
+
pub fn e_source_authentication_get_method(
1431
+
extension: *mut ESourceAuthentication,
1432
+
) -> *const gchar;
1433
+
}
1434
+
unsafe extern "C" {
1435
+
pub fn e_source_authentication_dup_method(extension: *mut ESourceAuthentication) -> *mut gchar;
1436
+
}
1437
+
unsafe extern "C" {
1438
+
pub fn e_source_authentication_set_method(
1439
+
extension: *mut ESourceAuthentication,
1440
+
method: *const gchar,
1441
+
);
1442
+
}
1443
+
unsafe extern "C" {
1444
+
pub fn e_source_authentication_get_port(extension: *mut ESourceAuthentication) -> guint16;
1445
+
}
1446
+
unsafe extern "C" {
1447
+
pub fn e_source_authentication_set_port(extension: *mut ESourceAuthentication, port: guint16);
1448
+
}
1449
+
unsafe extern "C" {
1450
+
pub fn e_source_authentication_get_proxy_uid(
1451
+
extension: *mut ESourceAuthentication,
1452
+
) -> *const gchar;
1453
+
}
1454
+
unsafe extern "C" {
1455
+
pub fn e_source_authentication_dup_proxy_uid(
1456
+
extension: *mut ESourceAuthentication,
1457
+
) -> *mut gchar;
1458
+
}
1459
+
unsafe extern "C" {
1460
+
pub fn e_source_authentication_set_proxy_uid(
1461
+
extension: *mut ESourceAuthentication,
1462
+
proxy_uid: *const gchar,
1463
+
);
1464
+
}
1465
+
unsafe extern "C" {
1466
+
pub fn e_source_authentication_get_remember_password(
1467
+
extension: *mut ESourceAuthentication,
1468
+
) -> gboolean;
1469
+
}
1470
+
unsafe extern "C" {
1471
+
pub fn e_source_authentication_set_remember_password(
1472
+
extension: *mut ESourceAuthentication,
1473
+
remember_password: gboolean,
1474
+
);
1475
+
}
1476
+
unsafe extern "C" {
1477
+
pub fn e_source_authentication_get_user(extension: *mut ESourceAuthentication) -> *const gchar;
1478
+
}
1479
+
unsafe extern "C" {
1480
+
pub fn e_source_authentication_dup_user(extension: *mut ESourceAuthentication) -> *mut gchar;
1481
+
}
1482
+
unsafe extern "C" {
1483
+
pub fn e_source_authentication_set_user(
1484
+
extension: *mut ESourceAuthentication,
1485
+
user: *const gchar,
1486
+
);
1487
+
}
1488
+
unsafe extern "C" {
1489
+
pub fn e_source_authentication_get_credential_name(
1490
+
extension: *mut ESourceAuthentication,
1491
+
) -> *const gchar;
1492
+
}
1493
+
unsafe extern "C" {
1494
+
pub fn e_source_authentication_dup_credential_name(
1495
+
extension: *mut ESourceAuthentication,
1496
+
) -> *mut gchar;
1497
+
}
1498
+
unsafe extern "C" {
1499
+
pub fn e_source_authentication_set_credential_name(
1500
+
extension: *mut ESourceAuthentication,
1501
+
credential_name: *const gchar,
1502
+
);
1503
+
}
1504
+
unsafe extern "C" {
1505
+
pub fn e_source_authentication_get_is_external(
1506
+
extension: *mut ESourceAuthentication,
1507
+
) -> gboolean;
1508
+
}
1509
+
unsafe extern "C" {
1510
+
pub fn e_source_authentication_set_is_external(
1511
+
extension: *mut ESourceAuthentication,
1512
+
is_external: gboolean,
1513
+
);
1514
+
}
1515
+
#[doc = " ESourceAutocomplete:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1516
+
pub type ESourceAutocomplete = _ESourceAutocomplete;
1517
+
#[repr(C)]
1518
+
#[derive(Debug, Copy, Clone)]
1519
+
pub struct _ESourceAutocompletePrivate {
1520
+
_unused: [u8; 0],
1521
+
}
1522
+
pub type ESourceAutocompletePrivate = _ESourceAutocompletePrivate;
1523
+
#[doc = " ESourceAutocomplete:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1524
+
#[repr(C)]
1525
+
#[derive(Debug, Copy, Clone)]
1526
+
pub struct _ESourceAutocomplete {
1527
+
pub parent: ESourceExtension,
1528
+
pub priv_: *mut ESourceAutocompletePrivate,
1529
+
}
1530
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1531
+
const _: () = {
1532
+
["Size of _ESourceAutocomplete"][::std::mem::size_of::<_ESourceAutocomplete>() - 40usize];
1533
+
["Alignment of _ESourceAutocomplete"][::std::mem::align_of::<_ESourceAutocomplete>() - 8usize];
1534
+
["Offset of field: _ESourceAutocomplete::parent"]
1535
+
[::std::mem::offset_of!(_ESourceAutocomplete, parent) - 0usize];
1536
+
["Offset of field: _ESourceAutocomplete::priv_"]
1537
+
[::std::mem::offset_of!(_ESourceAutocomplete, priv_) - 32usize];
1538
+
};
1539
+
unsafe extern "C" {
1540
+
pub fn e_source_autocomplete_get_type() -> GType;
1541
+
}
1542
+
unsafe extern "C" {
1543
+
pub fn e_source_autocomplete_get_include_me(extension: *mut ESourceAutocomplete) -> gboolean;
1544
+
}
1545
+
unsafe extern "C" {
1546
+
pub fn e_source_autocomplete_set_include_me(
1547
+
extension: *mut ESourceAutocomplete,
1548
+
include_me: gboolean,
1549
+
);
1550
+
}
1551
+
#[doc = " ESourceAutoconfig:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.24"]
1552
+
pub type ESourceAutoconfig = _ESourceAutoconfig;
1553
+
#[repr(C)]
1554
+
#[derive(Debug, Copy, Clone)]
1555
+
pub struct _ESourceAutoconfigPrivate {
1556
+
_unused: [u8; 0],
1557
+
}
1558
+
pub type ESourceAutoconfigPrivate = _ESourceAutoconfigPrivate;
1559
+
#[doc = " ESourceAutoconfig:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.24"]
1560
+
#[repr(C)]
1561
+
#[derive(Debug, Copy, Clone)]
1562
+
pub struct _ESourceAutoconfig {
1563
+
pub parent: ESourceExtension,
1564
+
pub priv_: *mut ESourceAutoconfigPrivate,
1565
+
}
1566
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1567
+
const _: () = {
1568
+
["Size of _ESourceAutoconfig"][::std::mem::size_of::<_ESourceAutoconfig>() - 40usize];
1569
+
["Alignment of _ESourceAutoconfig"][::std::mem::align_of::<_ESourceAutoconfig>() - 8usize];
1570
+
["Offset of field: _ESourceAutoconfig::parent"]
1571
+
[::std::mem::offset_of!(_ESourceAutoconfig, parent) - 0usize];
1572
+
["Offset of field: _ESourceAutoconfig::priv_"]
1573
+
[::std::mem::offset_of!(_ESourceAutoconfig, priv_) - 32usize];
1574
+
};
1575
+
unsafe extern "C" {
1576
+
pub fn e_source_autoconfig_get_type() -> GType;
1577
+
}
1578
+
unsafe extern "C" {
1579
+
pub fn e_source_autoconfig_get_revision(extension: *mut ESourceAutoconfig) -> *const gchar;
1580
+
}
1581
+
unsafe extern "C" {
1582
+
pub fn e_source_autoconfig_dup_revision(extension: *mut ESourceAutoconfig) -> *mut gchar;
1583
+
}
1584
+
unsafe extern "C" {
1585
+
pub fn e_source_autoconfig_set_revision(
1586
+
extension: *mut ESourceAutoconfig,
1587
+
revision: *const gchar,
1588
+
);
1589
+
}
1590
+
#[doc = " ESourceSelectable:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1591
+
pub type ESourceSelectable = _ESourceSelectable;
1592
+
#[repr(C)]
1593
+
#[derive(Debug, Copy, Clone)]
1594
+
pub struct _ESourceSelectablePrivate {
1595
+
_unused: [u8; 0],
1596
+
}
1597
+
pub type ESourceSelectablePrivate = _ESourceSelectablePrivate;
1598
+
#[doc = " ESourceSelectable:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1599
+
#[repr(C)]
1600
+
#[derive(Debug, Copy, Clone)]
1601
+
pub struct _ESourceSelectable {
1602
+
pub parent: ESourceBackend,
1603
+
pub priv_: *mut ESourceSelectablePrivate,
1604
+
}
1605
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1606
+
const _: () = {
1607
+
["Size of _ESourceSelectable"][::std::mem::size_of::<_ESourceSelectable>() - 48usize];
1608
+
["Alignment of _ESourceSelectable"][::std::mem::align_of::<_ESourceSelectable>() - 8usize];
1609
+
["Offset of field: _ESourceSelectable::parent"]
1610
+
[::std::mem::offset_of!(_ESourceSelectable, parent) - 0usize];
1611
+
["Offset of field: _ESourceSelectable::priv_"]
1612
+
[::std::mem::offset_of!(_ESourceSelectable, priv_) - 40usize];
1613
+
};
1614
+
unsafe extern "C" {
1615
+
pub fn e_source_selectable_get_type() -> GType;
1616
+
}
1617
+
unsafe extern "C" {
1618
+
pub fn e_source_selectable_get_color(extension: *mut ESourceSelectable) -> *const gchar;
1619
+
}
1620
+
unsafe extern "C" {
1621
+
pub fn e_source_selectable_dup_color(extension: *mut ESourceSelectable) -> *mut gchar;
1622
+
}
1623
+
unsafe extern "C" {
1624
+
pub fn e_source_selectable_set_color(extension: *mut ESourceSelectable, color: *const gchar);
1625
+
}
1626
+
unsafe extern "C" {
1627
+
pub fn e_source_selectable_get_selected(extension: *mut ESourceSelectable) -> gboolean;
1628
+
}
1629
+
unsafe extern "C" {
1630
+
pub fn e_source_selectable_set_selected(extension: *mut ESourceSelectable, selected: gboolean);
1631
+
}
1632
+
unsafe extern "C" {
1633
+
pub fn e_source_selectable_get_order(extension: *mut ESourceSelectable) -> guint;
1634
+
}
1635
+
unsafe extern "C" {
1636
+
pub fn e_source_selectable_set_order(extension: *mut ESourceSelectable, order: guint);
1637
+
}
1638
+
unsafe extern "C" {
1639
+
pub fn e_source_calendar_get_type() -> GType;
1640
+
}
1641
+
pub type CamelObject = _CamelObject;
1642
+
#[repr(C)]
1643
+
#[derive(Debug, Copy, Clone)]
1644
+
pub struct _CamelObjectPrivate {
1645
+
_unused: [u8; 0],
1646
+
}
1647
+
pub type CamelObjectPrivate = _CamelObjectPrivate;
1648
+
#[repr(C)]
1649
+
#[derive(Debug, Copy, Clone)]
1650
+
pub struct _CamelObject {
1651
+
pub parent: GObject,
1652
+
pub priv_: *mut CamelObjectPrivate,
1653
+
}
1654
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1655
+
const _: () = {
1656
+
["Size of _CamelObject"][::std::mem::size_of::<_CamelObject>() - 32usize];
1657
+
["Alignment of _CamelObject"][::std::mem::align_of::<_CamelObject>() - 8usize];
1658
+
["Offset of field: _CamelObject::parent"]
1659
+
[::std::mem::offset_of!(_CamelObject, parent) - 0usize];
1660
+
["Offset of field: _CamelObject::priv_"][::std::mem::offset_of!(_CamelObject, priv_) - 24usize];
1661
+
};
1662
+
#[doc = " CamelSettings:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.2"]
1663
+
pub type CamelSettings = _CamelSettings;
1664
+
#[repr(C)]
1665
+
#[derive(Debug, Copy, Clone)]
1666
+
pub struct _CamelSettingsPrivate {
1667
+
_unused: [u8; 0],
1668
+
}
1669
+
pub type CamelSettingsPrivate = _CamelSettingsPrivate;
1670
+
#[repr(C)]
1671
+
#[derive(Debug, Copy, Clone)]
1672
+
pub struct _CamelSettings {
1673
+
pub parent: GObject,
1674
+
pub priv_: *mut CamelSettingsPrivate,
1675
+
}
1676
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1677
+
const _: () = {
1678
+
["Size of _CamelSettings"][::std::mem::size_of::<_CamelSettings>() - 32usize];
1679
+
["Alignment of _CamelSettings"][::std::mem::align_of::<_CamelSettings>() - 8usize];
1680
+
["Offset of field: _CamelSettings::parent"]
1681
+
[::std::mem::offset_of!(_CamelSettings, parent) - 0usize];
1682
+
["Offset of field: _CamelSettings::priv_"]
1683
+
[::std::mem::offset_of!(_CamelSettings, priv_) - 24usize];
1684
+
};
1685
+
pub type CamelService = _CamelService;
1686
+
#[repr(C)]
1687
+
#[derive(Debug, Copy, Clone)]
1688
+
pub struct _CamelServicePrivate {
1689
+
_unused: [u8; 0],
1690
+
}
1691
+
pub type CamelServicePrivate = _CamelServicePrivate;
1692
+
#[repr(C)]
1693
+
#[derive(Debug, Copy, Clone)]
1694
+
pub struct _CamelService {
1695
+
pub parent: CamelObject,
1696
+
pub priv_: *mut CamelServicePrivate,
1697
+
}
1698
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1699
+
const _: () = {
1700
+
["Size of _CamelService"][::std::mem::size_of::<_CamelService>() - 40usize];
1701
+
["Alignment of _CamelService"][::std::mem::align_of::<_CamelService>() - 8usize];
1702
+
["Offset of field: _CamelService::parent"]
1703
+
[::std::mem::offset_of!(_CamelService, parent) - 0usize];
1704
+
["Offset of field: _CamelService::priv_"]
1705
+
[::std::mem::offset_of!(_CamelService, priv_) - 32usize];
1706
+
};
1707
+
#[doc = " ESourceCamel:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1708
+
pub type ESourceCamel = _ESourceCamel;
1709
+
#[repr(C)]
1710
+
#[derive(Debug, Copy, Clone)]
1711
+
pub struct _ESourceCamelPrivate {
1712
+
_unused: [u8; 0],
1713
+
}
1714
+
pub type ESourceCamelPrivate = _ESourceCamelPrivate;
1715
+
#[doc = " ESourceCamel:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1716
+
#[repr(C)]
1717
+
#[derive(Debug, Copy, Clone)]
1718
+
pub struct _ESourceCamel {
1719
+
pub parent: ESourceExtension,
1720
+
pub priv_: *mut ESourceCamelPrivate,
1721
+
}
1722
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1723
+
const _: () = {
1724
+
["Size of _ESourceCamel"][::std::mem::size_of::<_ESourceCamel>() - 40usize];
1725
+
["Alignment of _ESourceCamel"][::std::mem::align_of::<_ESourceCamel>() - 8usize];
1726
+
["Offset of field: _ESourceCamel::parent"]
1727
+
[::std::mem::offset_of!(_ESourceCamel, parent) - 0usize];
1728
+
["Offset of field: _ESourceCamel::priv_"]
1729
+
[::std::mem::offset_of!(_ESourceCamel, priv_) - 32usize];
1730
+
};
1731
+
unsafe extern "C" {
1732
+
pub fn e_source_camel_get_type() -> GType;
1733
+
}
1734
+
unsafe extern "C" {
1735
+
pub fn e_source_camel_register_types();
1736
+
}
1737
+
unsafe extern "C" {
1738
+
pub fn e_source_camel_generate_subtype(protocol: *const gchar, settings_type: GType) -> GType;
1739
+
}
1740
+
unsafe extern "C" {
1741
+
pub fn e_source_camel_get_settings(extension: *mut ESourceCamel) -> *mut CamelSettings;
1742
+
}
1743
+
unsafe extern "C" {
1744
+
pub fn e_source_camel_get_type_name(protocol: *const gchar) -> *const gchar;
1745
+
}
1746
+
unsafe extern "C" {
1747
+
pub fn e_source_camel_get_extension_name(protocol: *const gchar) -> *const gchar;
1748
+
}
1749
+
unsafe extern "C" {
1750
+
pub fn e_source_camel_configure_service(source: *mut ESource, service: *mut CamelService);
1751
+
}
1752
+
#[doc = " ESourceCollection:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1753
+
pub type ESourceCollection = _ESourceCollection;
1754
+
#[repr(C)]
1755
+
#[derive(Debug, Copy, Clone)]
1756
+
pub struct _ESourceCollectionPrivate {
1757
+
_unused: [u8; 0],
1758
+
}
1759
+
pub type ESourceCollectionPrivate = _ESourceCollectionPrivate;
1760
+
#[doc = " ESourceCollection:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1761
+
#[repr(C)]
1762
+
#[derive(Debug, Copy, Clone)]
1763
+
pub struct _ESourceCollection {
1764
+
pub parent: ESourceBackend,
1765
+
pub priv_: *mut ESourceCollectionPrivate,
1766
+
}
1767
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1768
+
const _: () = {
1769
+
["Size of _ESourceCollection"][::std::mem::size_of::<_ESourceCollection>() - 48usize];
1770
+
["Alignment of _ESourceCollection"][::std::mem::align_of::<_ESourceCollection>() - 8usize];
1771
+
["Offset of field: _ESourceCollection::parent"]
1772
+
[::std::mem::offset_of!(_ESourceCollection, parent) - 0usize];
1773
+
["Offset of field: _ESourceCollection::priv_"]
1774
+
[::std::mem::offset_of!(_ESourceCollection, priv_) - 40usize];
1775
+
};
1776
+
unsafe extern "C" {
1777
+
pub fn e_source_collection_get_type() -> GType;
1778
+
}
1779
+
unsafe extern "C" {
1780
+
pub fn e_source_collection_get_identity(extension: *mut ESourceCollection) -> *const gchar;
1781
+
}
1782
+
unsafe extern "C" {
1783
+
pub fn e_source_collection_dup_identity(extension: *mut ESourceCollection) -> *mut gchar;
1784
+
}
1785
+
unsafe extern "C" {
1786
+
pub fn e_source_collection_set_identity(
1787
+
extension: *mut ESourceCollection,
1788
+
identity: *const gchar,
1789
+
);
1790
+
}
1791
+
unsafe extern "C" {
1792
+
pub fn e_source_collection_get_calendar_enabled(extension: *mut ESourceCollection) -> gboolean;
1793
+
}
1794
+
unsafe extern "C" {
1795
+
pub fn e_source_collection_set_calendar_enabled(
1796
+
extension: *mut ESourceCollection,
1797
+
calendar_enabled: gboolean,
1798
+
);
1799
+
}
1800
+
unsafe extern "C" {
1801
+
pub fn e_source_collection_get_contacts_enabled(extension: *mut ESourceCollection) -> gboolean;
1802
+
}
1803
+
unsafe extern "C" {
1804
+
pub fn e_source_collection_set_contacts_enabled(
1805
+
extension: *mut ESourceCollection,
1806
+
contacts_enabled: gboolean,
1807
+
);
1808
+
}
1809
+
unsafe extern "C" {
1810
+
pub fn e_source_collection_get_mail_enabled(extension: *mut ESourceCollection) -> gboolean;
1811
+
}
1812
+
unsafe extern "C" {
1813
+
pub fn e_source_collection_set_mail_enabled(
1814
+
extension: *mut ESourceCollection,
1815
+
mail_enabled: gboolean,
1816
+
);
1817
+
}
1818
+
unsafe extern "C" {
1819
+
pub fn e_source_collection_get_calendar_url(extension: *mut ESourceCollection) -> *const gchar;
1820
+
}
1821
+
unsafe extern "C" {
1822
+
pub fn e_source_collection_dup_calendar_url(extension: *mut ESourceCollection) -> *mut gchar;
1823
+
}
1824
+
unsafe extern "C" {
1825
+
pub fn e_source_collection_set_calendar_url(
1826
+
extension: *mut ESourceCollection,
1827
+
calendar_url: *const gchar,
1828
+
);
1829
+
}
1830
+
unsafe extern "C" {
1831
+
pub fn e_source_collection_get_contacts_url(extension: *mut ESourceCollection) -> *const gchar;
1832
+
}
1833
+
unsafe extern "C" {
1834
+
pub fn e_source_collection_dup_contacts_url(extension: *mut ESourceCollection) -> *mut gchar;
1835
+
}
1836
+
unsafe extern "C" {
1837
+
pub fn e_source_collection_set_contacts_url(
1838
+
extension: *mut ESourceCollection,
1839
+
contacts_url: *const gchar,
1840
+
);
1841
+
}
1842
+
unsafe extern "C" {
1843
+
pub fn e_source_collection_get_allow_sources_rename(
1844
+
extension: *mut ESourceCollection,
1845
+
) -> gboolean;
1846
+
}
1847
+
unsafe extern "C" {
1848
+
pub fn e_source_collection_set_allow_sources_rename(
1849
+
extension: *mut ESourceCollection,
1850
+
allow_sources_rename: gboolean,
1851
+
);
1852
+
}
1853
+
pub type ESourceContacts = _ESourceContacts;
1854
+
#[repr(C)]
1855
+
#[derive(Debug, Copy, Clone)]
1856
+
pub struct _ESourceContactsPrivate {
1857
+
_unused: [u8; 0],
1858
+
}
1859
+
pub type ESourceContactsPrivate = _ESourceContactsPrivate;
1860
+
#[repr(C)]
1861
+
#[derive(Debug, Copy, Clone)]
1862
+
pub struct _ESourceContacts {
1863
+
pub parent: ESourceExtension,
1864
+
pub priv_: *mut ESourceContactsPrivate,
1865
+
}
1866
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1867
+
const _: () = {
1868
+
["Size of _ESourceContacts"][::std::mem::size_of::<_ESourceContacts>() - 40usize];
1869
+
["Alignment of _ESourceContacts"][::std::mem::align_of::<_ESourceContacts>() - 8usize];
1870
+
["Offset of field: _ESourceContacts::parent"]
1871
+
[::std::mem::offset_of!(_ESourceContacts, parent) - 0usize];
1872
+
["Offset of field: _ESourceContacts::priv_"]
1873
+
[::std::mem::offset_of!(_ESourceContacts, priv_) - 32usize];
1874
+
};
1875
+
unsafe extern "C" {
1876
+
pub fn e_source_contacts_get_type() -> GType;
1877
+
}
1878
+
unsafe extern "C" {
1879
+
pub fn e_source_contacts_get_include_me(extension: *mut ESourceContacts) -> gboolean;
1880
+
}
1881
+
unsafe extern "C" {
1882
+
pub fn e_source_contacts_set_include_me(extension: *mut ESourceContacts, include_me: gboolean);
1883
+
}
1884
+
#[doc = " ESourceRegistry:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1885
+
pub type ESourceRegistry = _ESourceRegistry;
1886
+
#[repr(C)]
1887
+
#[derive(Debug, Copy, Clone)]
1888
+
pub struct _ESourceRegistryPrivate {
1889
+
_unused: [u8; 0],
1890
+
}
1891
+
pub type ESourceRegistryPrivate = _ESourceRegistryPrivate;
1892
+
#[doc = " ESourceRegistry:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
1893
+
#[repr(C)]
1894
+
#[derive(Debug, Copy, Clone)]
1895
+
pub struct _ESourceRegistry {
1896
+
pub parent: GObject,
1897
+
pub priv_: *mut ESourceRegistryPrivate,
1898
+
}
1899
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1900
+
const _: () = {
1901
+
["Size of _ESourceRegistry"][::std::mem::size_of::<_ESourceRegistry>() - 32usize];
1902
+
["Alignment of _ESourceRegistry"][::std::mem::align_of::<_ESourceRegistry>() - 8usize];
1903
+
["Offset of field: _ESourceRegistry::parent"]
1904
+
[::std::mem::offset_of!(_ESourceRegistry, parent) - 0usize];
1905
+
["Offset of field: _ESourceRegistry::priv_"]
1906
+
[::std::mem::offset_of!(_ESourceRegistry, priv_) - 24usize];
1907
+
};
1908
+
unsafe extern "C" {
1909
+
pub fn e_source_registry_get_type() -> GType;
1910
+
}
1911
+
unsafe extern "C" {
1912
+
pub fn e_source_registry_new_sync(
1913
+
cancellable: *mut GCancellable,
1914
+
error: *mut *mut GError,
1915
+
) -> *mut ESourceRegistry;
1916
+
}
1917
+
unsafe extern "C" {
1918
+
pub fn e_source_registry_new(
1919
+
cancellable: *mut GCancellable,
1920
+
callback: GAsyncReadyCallback,
1921
+
user_data: gpointer,
1922
+
);
1923
+
}
1924
+
unsafe extern "C" {
1925
+
pub fn e_source_registry_new_finish(
1926
+
result: *mut GAsyncResult,
1927
+
error: *mut *mut GError,
1928
+
) -> *mut ESourceRegistry;
1929
+
}
1930
+
unsafe extern "C" {
1931
+
pub fn e_source_registry_get_oauth2_services(
1932
+
registry: *mut ESourceRegistry,
1933
+
) -> *mut EOAuth2Services;
1934
+
}
1935
+
unsafe extern "C" {
1936
+
pub fn e_source_registry_commit_source_sync(
1937
+
registry: *mut ESourceRegistry,
1938
+
source: *mut ESource,
1939
+
cancellable: *mut GCancellable,
1940
+
error: *mut *mut GError,
1941
+
) -> gboolean;
1942
+
}
1943
+
unsafe extern "C" {
1944
+
pub fn e_source_registry_commit_source(
1945
+
registry: *mut ESourceRegistry,
1946
+
source: *mut ESource,
1947
+
cancellable: *mut GCancellable,
1948
+
callback: GAsyncReadyCallback,
1949
+
user_data: gpointer,
1950
+
);
1951
+
}
1952
+
unsafe extern "C" {
1953
+
pub fn e_source_registry_commit_source_finish(
1954
+
registry: *mut ESourceRegistry,
1955
+
result: *mut GAsyncResult,
1956
+
error: *mut *mut GError,
1957
+
) -> gboolean;
1958
+
}
1959
+
unsafe extern "C" {
1960
+
pub fn e_source_registry_create_sources_sync(
1961
+
registry: *mut ESourceRegistry,
1962
+
list_of_sources: *mut GList,
1963
+
cancellable: *mut GCancellable,
1964
+
error: *mut *mut GError,
1965
+
) -> gboolean;
1966
+
}
1967
+
unsafe extern "C" {
1968
+
pub fn e_source_registry_create_sources(
1969
+
registry: *mut ESourceRegistry,
1970
+
list_of_sources: *mut GList,
1971
+
cancellable: *mut GCancellable,
1972
+
callback: GAsyncReadyCallback,
1973
+
user_data: gpointer,
1974
+
);
1975
+
}
1976
+
unsafe extern "C" {
1977
+
pub fn e_source_registry_create_sources_finish(
1978
+
registry: *mut ESourceRegistry,
1979
+
result: *mut GAsyncResult,
1980
+
error: *mut *mut GError,
1981
+
) -> gboolean;
1982
+
}
1983
+
unsafe extern "C" {
1984
+
pub fn e_source_registry_refresh_backend_sync(
1985
+
registry: *mut ESourceRegistry,
1986
+
source_uid: *const gchar,
1987
+
cancellable: *mut GCancellable,
1988
+
error: *mut *mut GError,
1989
+
) -> gboolean;
1990
+
}
1991
+
unsafe extern "C" {
1992
+
pub fn e_source_registry_refresh_backend(
1993
+
registry: *mut ESourceRegistry,
1994
+
source_uid: *const gchar,
1995
+
cancellable: *mut GCancellable,
1996
+
callback: GAsyncReadyCallback,
1997
+
user_data: gpointer,
1998
+
);
1999
+
}
2000
+
unsafe extern "C" {
2001
+
pub fn e_source_registry_refresh_backend_finish(
2002
+
registry: *mut ESourceRegistry,
2003
+
result: *mut GAsyncResult,
2004
+
error: *mut *mut GError,
2005
+
) -> gboolean;
2006
+
}
2007
+
unsafe extern "C" {
2008
+
pub fn e_source_registry_ref_source(
2009
+
registry: *mut ESourceRegistry,
2010
+
uid: *const gchar,
2011
+
) -> *mut ESource;
2012
+
}
2013
+
unsafe extern "C" {
2014
+
pub fn e_source_registry_list_sources(
2015
+
registry: *mut ESourceRegistry,
2016
+
extension_name: *const gchar,
2017
+
) -> *mut GList;
2018
+
}
2019
+
unsafe extern "C" {
2020
+
pub fn e_source_registry_list_enabled(
2021
+
registry: *mut ESourceRegistry,
2022
+
extension_name: *const gchar,
2023
+
) -> *mut GList;
2024
+
}
2025
+
unsafe extern "C" {
2026
+
pub fn e_source_registry_find_extension(
2027
+
registry: *mut ESourceRegistry,
2028
+
source: *mut ESource,
2029
+
extension_name: *const gchar,
2030
+
) -> *mut ESource;
2031
+
}
2032
+
unsafe extern "C" {
2033
+
pub fn e_source_registry_check_enabled(
2034
+
registry: *mut ESourceRegistry,
2035
+
source: *mut ESource,
2036
+
) -> gboolean;
2037
+
}
2038
+
unsafe extern "C" {
2039
+
pub fn e_source_registry_build_display_tree(
2040
+
registry: *mut ESourceRegistry,
2041
+
extension_name: *const gchar,
2042
+
) -> *mut GNode;
2043
+
}
2044
+
unsafe extern "C" {
2045
+
pub fn e_source_registry_free_display_tree(display_tree: *mut GNode);
2046
+
}
2047
+
unsafe extern "C" {
2048
+
pub fn e_source_registry_dup_unique_display_name(
2049
+
registry: *mut ESourceRegistry,
2050
+
source: *mut ESource,
2051
+
extension_name: *const gchar,
2052
+
) -> *mut gchar;
2053
+
}
2054
+
unsafe extern "C" {
2055
+
pub fn e_source_registry_debug_dump(
2056
+
registry: *mut ESourceRegistry,
2057
+
extension_name: *const gchar,
2058
+
);
2059
+
}
2060
+
unsafe extern "C" {
2061
+
pub fn e_source_registry_ref_builtin_address_book(
2062
+
registry: *mut ESourceRegistry,
2063
+
) -> *mut ESource;
2064
+
}
2065
+
unsafe extern "C" {
2066
+
pub fn e_source_registry_ref_builtin_calendar(registry: *mut ESourceRegistry) -> *mut ESource;
2067
+
}
2068
+
unsafe extern "C" {
2069
+
pub fn e_source_registry_ref_builtin_mail_account(
2070
+
registry: *mut ESourceRegistry,
2071
+
) -> *mut ESource;
2072
+
}
2073
+
unsafe extern "C" {
2074
+
pub fn e_source_registry_ref_builtin_memo_list(registry: *mut ESourceRegistry) -> *mut ESource;
2075
+
}
2076
+
unsafe extern "C" {
2077
+
pub fn e_source_registry_ref_builtin_proxy(registry: *mut ESourceRegistry) -> *mut ESource;
2078
+
}
2079
+
unsafe extern "C" {
2080
+
pub fn e_source_registry_ref_builtin_task_list(registry: *mut ESourceRegistry) -> *mut ESource;
2081
+
}
2082
+
unsafe extern "C" {
2083
+
pub fn e_source_registry_ref_default_address_book(
2084
+
registry: *mut ESourceRegistry,
2085
+
) -> *mut ESource;
2086
+
}
2087
+
unsafe extern "C" {
2088
+
pub fn e_source_registry_set_default_address_book(
2089
+
registry: *mut ESourceRegistry,
2090
+
default_source: *mut ESource,
2091
+
);
2092
+
}
2093
+
unsafe extern "C" {
2094
+
pub fn e_source_registry_ref_default_calendar(registry: *mut ESourceRegistry) -> *mut ESource;
2095
+
}
2096
+
unsafe extern "C" {
2097
+
pub fn e_source_registry_set_default_calendar(
2098
+
registry: *mut ESourceRegistry,
2099
+
default_source: *mut ESource,
2100
+
);
2101
+
}
2102
+
unsafe extern "C" {
2103
+
pub fn e_source_registry_ref_default_mail_account(
2104
+
registry: *mut ESourceRegistry,
2105
+
) -> *mut ESource;
2106
+
}
2107
+
unsafe extern "C" {
2108
+
pub fn e_source_registry_set_default_mail_account(
2109
+
registry: *mut ESourceRegistry,
2110
+
default_source: *mut ESource,
2111
+
);
2112
+
}
2113
+
unsafe extern "C" {
2114
+
pub fn e_source_registry_ref_default_mail_identity(
2115
+
registry: *mut ESourceRegistry,
2116
+
) -> *mut ESource;
2117
+
}
2118
+
unsafe extern "C" {
2119
+
pub fn e_source_registry_set_default_mail_identity(
2120
+
registry: *mut ESourceRegistry,
2121
+
default_source: *mut ESource,
2122
+
);
2123
+
}
2124
+
unsafe extern "C" {
2125
+
pub fn e_source_registry_ref_default_memo_list(registry: *mut ESourceRegistry) -> *mut ESource;
2126
+
}
2127
+
unsafe extern "C" {
2128
+
pub fn e_source_registry_set_default_memo_list(
2129
+
registry: *mut ESourceRegistry,
2130
+
default_source: *mut ESource,
2131
+
);
2132
+
}
2133
+
unsafe extern "C" {
2134
+
pub fn e_source_registry_ref_default_task_list(registry: *mut ESourceRegistry) -> *mut ESource;
2135
+
}
2136
+
unsafe extern "C" {
2137
+
pub fn e_source_registry_set_default_task_list(
2138
+
registry: *mut ESourceRegistry,
2139
+
default_source: *mut ESource,
2140
+
);
2141
+
}
2142
+
unsafe extern "C" {
2143
+
pub fn e_source_registry_ref_default_for_extension_name(
2144
+
registry: *mut ESourceRegistry,
2145
+
extension_name: *const gchar,
2146
+
) -> *mut ESource;
2147
+
}
2148
+
unsafe extern "C" {
2149
+
pub fn e_source_registry_set_default_for_extension_name(
2150
+
registry: *mut ESourceRegistry,
2151
+
extension_name: *const gchar,
2152
+
default_source: *mut ESource,
2153
+
);
2154
+
}
2155
+
#[doc = " ESourceCredentialsProviderImpl:\n\n Credentials provider implementation base structure. The descendants\n implement the virtual methods. The descendants are automatically\n registered into an #ESourceCredentialsProvider.\n\n Since: 3.16"]
2156
+
pub type ESourceCredentialsProviderImpl = _ESourceCredentialsProviderImpl;
2157
+
#[repr(C)]
2158
+
#[derive(Debug, Copy, Clone)]
2159
+
pub struct _ESourceCredentialsProviderImplPrivate {
2160
+
_unused: [u8; 0],
2161
+
}
2162
+
pub type ESourceCredentialsProviderImplPrivate = _ESourceCredentialsProviderImplPrivate;
2163
+
#[doc = " ESourceCredentialsProviderImpl:\n\n Credentials provider implementation base structure. The descendants\n implement the virtual methods. The descendants are automatically\n registered into an #ESourceCredentialsProvider.\n\n Since: 3.16"]
2164
+
#[repr(C)]
2165
+
#[derive(Debug, Copy, Clone)]
2166
+
pub struct _ESourceCredentialsProviderImpl {
2167
+
pub parent: EExtension,
2168
+
pub priv_: *mut ESourceCredentialsProviderImplPrivate,
2169
+
}
2170
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2171
+
const _: () = {
2172
+
["Size of _ESourceCredentialsProviderImpl"]
2173
+
[::std::mem::size_of::<_ESourceCredentialsProviderImpl>() - 40usize];
2174
+
["Alignment of _ESourceCredentialsProviderImpl"]
2175
+
[::std::mem::align_of::<_ESourceCredentialsProviderImpl>() - 8usize];
2176
+
["Offset of field: _ESourceCredentialsProviderImpl::parent"]
2177
+
[::std::mem::offset_of!(_ESourceCredentialsProviderImpl, parent) - 0usize];
2178
+
["Offset of field: _ESourceCredentialsProviderImpl::priv_"]
2179
+
[::std::mem::offset_of!(_ESourceCredentialsProviderImpl, priv_) - 32usize];
2180
+
};
2181
+
unsafe extern "C" {
2182
+
pub fn e_source_credentials_provider_impl_get_type() -> GType;
2183
+
}
2184
+
unsafe extern "C" {
2185
+
pub fn e_source_credentials_provider_impl_get_provider(
2186
+
provider_impl: *mut ESourceCredentialsProviderImpl,
2187
+
) -> *mut _ESourceCredentialsProvider;
2188
+
}
2189
+
unsafe extern "C" {
2190
+
pub fn e_source_credentials_provider_impl_can_process(
2191
+
provider_impl: *mut ESourceCredentialsProviderImpl,
2192
+
source: *mut ESource,
2193
+
) -> gboolean;
2194
+
}
2195
+
unsafe extern "C" {
2196
+
pub fn e_source_credentials_provider_impl_can_store(
2197
+
provider_impl: *mut ESourceCredentialsProviderImpl,
2198
+
) -> gboolean;
2199
+
}
2200
+
unsafe extern "C" {
2201
+
pub fn e_source_credentials_provider_impl_can_prompt(
2202
+
provider_impl: *mut ESourceCredentialsProviderImpl,
2203
+
) -> gboolean;
2204
+
}
2205
+
unsafe extern "C" {
2206
+
pub fn e_source_credentials_provider_impl_lookup_sync(
2207
+
provider_impl: *mut ESourceCredentialsProviderImpl,
2208
+
source: *mut ESource,
2209
+
cancellable: *mut GCancellable,
2210
+
out_credentials: *mut *mut ENamedParameters,
2211
+
error: *mut *mut GError,
2212
+
) -> gboolean;
2213
+
}
2214
+
unsafe extern "C" {
2215
+
pub fn e_source_credentials_provider_impl_store_sync(
2216
+
provider_impl: *mut ESourceCredentialsProviderImpl,
2217
+
source: *mut ESource,
2218
+
credentials: *const ENamedParameters,
2219
+
permanently: gboolean,
2220
+
cancellable: *mut GCancellable,
2221
+
error: *mut *mut GError,
2222
+
) -> gboolean;
2223
+
}
2224
+
unsafe extern "C" {
2225
+
pub fn e_source_credentials_provider_impl_delete_sync(
2226
+
provider_impl: *mut ESourceCredentialsProviderImpl,
2227
+
source: *mut ESource,
2228
+
cancellable: *mut GCancellable,
2229
+
error: *mut *mut GError,
2230
+
) -> gboolean;
2231
+
}
2232
+
#[doc = " ESourceCredentialsProvider:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.16"]
2233
+
pub type ESourceCredentialsProvider = _ESourceCredentialsProvider;
2234
+
#[repr(C)]
2235
+
#[derive(Debug, Copy, Clone)]
2236
+
pub struct _ESourceCredentialsProviderPrivate {
2237
+
_unused: [u8; 0],
2238
+
}
2239
+
pub type ESourceCredentialsProviderPrivate = _ESourceCredentialsProviderPrivate;
2240
+
#[doc = " ESourceCredentialsProvider:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.16"]
2241
+
#[repr(C)]
2242
+
#[derive(Debug, Copy, Clone)]
2243
+
pub struct _ESourceCredentialsProvider {
2244
+
pub parent: GObject,
2245
+
pub priv_: *mut ESourceCredentialsProviderPrivate,
2246
+
}
2247
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2248
+
const _: () = {
2249
+
["Size of _ESourceCredentialsProvider"]
2250
+
[::std::mem::size_of::<_ESourceCredentialsProvider>() - 32usize];
2251
+
["Alignment of _ESourceCredentialsProvider"]
2252
+
[::std::mem::align_of::<_ESourceCredentialsProvider>() - 8usize];
2253
+
["Offset of field: _ESourceCredentialsProvider::parent"]
2254
+
[::std::mem::offset_of!(_ESourceCredentialsProvider, parent) - 0usize];
2255
+
["Offset of field: _ESourceCredentialsProvider::priv_"]
2256
+
[::std::mem::offset_of!(_ESourceCredentialsProvider, priv_) - 24usize];
2257
+
};
2258
+
unsafe extern "C" {
2259
+
pub fn e_source_credentials_provider_get_type() -> GType;
2260
+
}
2261
+
unsafe extern "C" {
2262
+
pub fn e_source_credentials_provider_new(
2263
+
registry: *mut ESourceRegistry,
2264
+
) -> *mut ESourceCredentialsProvider;
2265
+
}
2266
+
unsafe extern "C" {
2267
+
pub fn e_source_credentials_provider_ref_registry(
2268
+
provider: *mut ESourceCredentialsProvider,
2269
+
) -> *mut GObject;
2270
+
}
2271
+
unsafe extern "C" {
2272
+
pub fn e_source_credentials_provider_register_impl(
2273
+
provider: *mut ESourceCredentialsProvider,
2274
+
provider_impl: *mut ESourceCredentialsProviderImpl,
2275
+
) -> gboolean;
2276
+
}
2277
+
unsafe extern "C" {
2278
+
pub fn e_source_credentials_provider_unregister_impl(
2279
+
provider: *mut ESourceCredentialsProvider,
2280
+
provider_impl: *mut ESourceCredentialsProviderImpl,
2281
+
);
2282
+
}
2283
+
unsafe extern "C" {
2284
+
pub fn e_source_credentials_provider_ref_source(
2285
+
provider: *mut ESourceCredentialsProvider,
2286
+
uid: *const gchar,
2287
+
) -> *mut ESource;
2288
+
}
2289
+
unsafe extern "C" {
2290
+
pub fn e_source_credentials_provider_ref_credentials_source(
2291
+
provider: *mut ESourceCredentialsProvider,
2292
+
source: *mut ESource,
2293
+
) -> *mut ESource;
2294
+
}
2295
+
unsafe extern "C" {
2296
+
pub fn e_source_credentials_provider_can_store(
2297
+
provider: *mut ESourceCredentialsProvider,
2298
+
source: *mut ESource,
2299
+
) -> gboolean;
2300
+
}
2301
+
unsafe extern "C" {
2302
+
pub fn e_source_credentials_provider_can_prompt(
2303
+
provider: *mut ESourceCredentialsProvider,
2304
+
source: *mut ESource,
2305
+
) -> gboolean;
2306
+
}
2307
+
unsafe extern "C" {
2308
+
pub fn e_source_credentials_provider_lookup_sync(
2309
+
provider: *mut ESourceCredentialsProvider,
2310
+
source: *mut ESource,
2311
+
cancellable: *mut GCancellable,
2312
+
out_credentials: *mut *mut ENamedParameters,
2313
+
error: *mut *mut GError,
2314
+
) -> gboolean;
2315
+
}
2316
+
unsafe extern "C" {
2317
+
pub fn e_source_credentials_provider_lookup(
2318
+
provider: *mut ESourceCredentialsProvider,
2319
+
source: *mut ESource,
2320
+
cancellable: *mut GCancellable,
2321
+
callback: GAsyncReadyCallback,
2322
+
user_data: gpointer,
2323
+
);
2324
+
}
2325
+
unsafe extern "C" {
2326
+
pub fn e_source_credentials_provider_lookup_finish(
2327
+
provider: *mut ESourceCredentialsProvider,
2328
+
result: *mut GAsyncResult,
2329
+
out_credentials: *mut *mut ENamedParameters,
2330
+
error: *mut *mut GError,
2331
+
) -> gboolean;
2332
+
}
2333
+
unsafe extern "C" {
2334
+
pub fn e_source_credentials_provider_store_sync(
2335
+
provider: *mut ESourceCredentialsProvider,
2336
+
source: *mut ESource,
2337
+
credentials: *const ENamedParameters,
2338
+
permanently: gboolean,
2339
+
cancellable: *mut GCancellable,
2340
+
error: *mut *mut GError,
2341
+
) -> gboolean;
2342
+
}
2343
+
unsafe extern "C" {
2344
+
pub fn e_source_credentials_provider_store(
2345
+
provider: *mut ESourceCredentialsProvider,
2346
+
source: *mut ESource,
2347
+
credentials: *const ENamedParameters,
2348
+
permanently: gboolean,
2349
+
cancellable: *mut GCancellable,
2350
+
callback: GAsyncReadyCallback,
2351
+
user_data: gpointer,
2352
+
);
2353
+
}
2354
+
unsafe extern "C" {
2355
+
pub fn e_source_credentials_provider_store_finish(
2356
+
provider: *mut ESourceCredentialsProvider,
2357
+
result: *mut GAsyncResult,
2358
+
error: *mut *mut GError,
2359
+
) -> gboolean;
2360
+
}
2361
+
unsafe extern "C" {
2362
+
pub fn e_source_credentials_provider_delete_sync(
2363
+
provider: *mut ESourceCredentialsProvider,
2364
+
source: *mut ESource,
2365
+
cancellable: *mut GCancellable,
2366
+
error: *mut *mut GError,
2367
+
) -> gboolean;
2368
+
}
2369
+
unsafe extern "C" {
2370
+
pub fn e_source_credentials_provider_delete(
2371
+
provider: *mut ESourceCredentialsProvider,
2372
+
source: *mut ESource,
2373
+
cancellable: *mut GCancellable,
2374
+
callback: GAsyncReadyCallback,
2375
+
user_data: gpointer,
2376
+
);
2377
+
}
2378
+
unsafe extern "C" {
2379
+
pub fn e_source_credentials_provider_delete_finish(
2380
+
provider: *mut ESourceCredentialsProvider,
2381
+
result: *mut GAsyncResult,
2382
+
error: *mut *mut GError,
2383
+
) -> gboolean;
2384
+
}
2385
+
unsafe extern "C" {
2386
+
pub fn e_source_credentials_provider_impl_oauth2_get_type() -> GType;
2387
+
}
2388
+
unsafe extern "C" {
2389
+
pub fn e_source_credentials_provider_impl_password_get_type() -> GType;
2390
+
}
2391
+
#[doc = " ESourceGoa:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
2392
+
pub type ESourceGoa = _ESourceGoa;
2393
+
#[repr(C)]
2394
+
#[derive(Debug, Copy, Clone)]
2395
+
pub struct _ESourceGoaPrivate {
2396
+
_unused: [u8; 0],
2397
+
}
2398
+
pub type ESourceGoaPrivate = _ESourceGoaPrivate;
2399
+
#[doc = " ESourceGoa:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
2400
+
#[repr(C)]
2401
+
#[derive(Debug, Copy, Clone)]
2402
+
pub struct _ESourceGoa {
2403
+
pub parent: ESourceExtension,
2404
+
pub priv_: *mut ESourceGoaPrivate,
2405
+
}
2406
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2407
+
const _: () = {
2408
+
["Size of _ESourceGoa"][::std::mem::size_of::<_ESourceGoa>() - 40usize];
2409
+
["Alignment of _ESourceGoa"][::std::mem::align_of::<_ESourceGoa>() - 8usize];
2410
+
["Offset of field: _ESourceGoa::parent"][::std::mem::offset_of!(_ESourceGoa, parent) - 0usize];
2411
+
["Offset of field: _ESourceGoa::priv_"][::std::mem::offset_of!(_ESourceGoa, priv_) - 32usize];
2412
+
};
2413
+
unsafe extern "C" {
2414
+
pub fn e_source_goa_get_type() -> GType;
2415
+
}
2416
+
unsafe extern "C" {
2417
+
pub fn e_source_goa_get_account_id(extension: *mut ESourceGoa) -> *const gchar;
2418
+
}
2419
+
unsafe extern "C" {
2420
+
pub fn e_source_goa_dup_account_id(extension: *mut ESourceGoa) -> *mut gchar;
2421
+
}
2422
+
unsafe extern "C" {
2423
+
pub fn e_source_goa_set_account_id(extension: *mut ESourceGoa, account_id: *const gchar);
2424
+
}
2425
+
unsafe extern "C" {
2426
+
pub fn e_source_goa_get_calendar_url(extension: *mut ESourceGoa) -> *const gchar;
2427
+
}
2428
+
unsafe extern "C" {
2429
+
pub fn e_source_goa_dup_calendar_url(extension: *mut ESourceGoa) -> *mut gchar;
2430
+
}
2431
+
unsafe extern "C" {
2432
+
pub fn e_source_goa_set_calendar_url(extension: *mut ESourceGoa, calendar_url: *const gchar);
2433
+
}
2434
+
unsafe extern "C" {
2435
+
pub fn e_source_goa_get_contacts_url(extension: *mut ESourceGoa) -> *const gchar;
2436
+
}
2437
+
unsafe extern "C" {
2438
+
pub fn e_source_goa_dup_contacts_url(extension: *mut ESourceGoa) -> *mut gchar;
2439
+
}
2440
+
unsafe extern "C" {
2441
+
pub fn e_source_goa_set_contacts_url(extension: *mut ESourceGoa, contacts_url: *const gchar);
2442
+
}
2443
+
unsafe extern "C" {
2444
+
pub fn e_source_goa_get_name(extension: *mut ESourceGoa) -> *const gchar;
2445
+
}
2446
+
unsafe extern "C" {
2447
+
pub fn e_source_goa_dup_name(extension: *mut ESourceGoa) -> *mut gchar;
2448
+
}
2449
+
unsafe extern "C" {
2450
+
pub fn e_source_goa_set_name(extension: *mut ESourceGoa, name: *const gchar);
2451
+
}
2452
+
unsafe extern "C" {
2453
+
pub fn e_source_goa_get_address(extension: *mut ESourceGoa) -> *const gchar;
2454
+
}
2455
+
unsafe extern "C" {
2456
+
pub fn e_source_goa_dup_address(extension: *mut ESourceGoa) -> *mut gchar;
2457
+
}
2458
+
unsafe extern "C" {
2459
+
pub fn e_source_goa_set_address(extension: *mut ESourceGoa, address: *const gchar);
2460
+
}
2461
+
pub type ESourceLDAP = _ESourceLDAP;
2462
+
#[repr(C)]
2463
+
#[derive(Debug, Copy, Clone)]
2464
+
pub struct _ESourceLDAPPrivate {
2465
+
_unused: [u8; 0],
2466
+
}
2467
+
pub type ESourceLDAPPrivate = _ESourceLDAPPrivate;
2468
+
#[repr(C)]
2469
+
#[derive(Debug, Copy, Clone)]
2470
+
pub struct _ESourceLDAP {
2471
+
pub parent: ESourceExtension,
2472
+
pub priv_: *mut ESourceLDAPPrivate,
2473
+
}
2474
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2475
+
const _: () = {
2476
+
["Size of _ESourceLDAP"][::std::mem::size_of::<_ESourceLDAP>() - 40usize];
2477
+
["Alignment of _ESourceLDAP"][::std::mem::align_of::<_ESourceLDAP>() - 8usize];
2478
+
["Offset of field: _ESourceLDAP::parent"]
2479
+
[::std::mem::offset_of!(_ESourceLDAP, parent) - 0usize];
2480
+
["Offset of field: _ESourceLDAP::priv_"][::std::mem::offset_of!(_ESourceLDAP, priv_) - 32usize];
2481
+
};
2482
+
unsafe extern "C" {
2483
+
pub fn e_source_ldap_get_type() -> GType;
2484
+
}
2485
+
unsafe extern "C" {
2486
+
pub fn e_source_ldap_get_authentication(
2487
+
extension: *mut ESourceLDAP,
2488
+
) -> ESourceLDAPAuthentication;
2489
+
}
2490
+
unsafe extern "C" {
2491
+
pub fn e_source_ldap_set_authentication(
2492
+
extension: *mut ESourceLDAP,
2493
+
authentication: ESourceLDAPAuthentication,
2494
+
);
2495
+
}
2496
+
unsafe extern "C" {
2497
+
pub fn e_source_ldap_get_can_browse(extension: *mut ESourceLDAP) -> gboolean;
2498
+
}
2499
+
unsafe extern "C" {
2500
+
pub fn e_source_ldap_set_can_browse(extension: *mut ESourceLDAP, can_browse: gboolean);
2501
+
}
2502
+
unsafe extern "C" {
2503
+
pub fn e_source_ldap_get_filter(extension: *mut ESourceLDAP) -> *const gchar;
2504
+
}
2505
+
unsafe extern "C" {
2506
+
pub fn e_source_ldap_dup_filter(extension: *mut ESourceLDAP) -> *mut gchar;
2507
+
}
2508
+
unsafe extern "C" {
2509
+
pub fn e_source_ldap_set_filter(extension: *mut ESourceLDAP, filter: *const gchar);
2510
+
}
2511
+
unsafe extern "C" {
2512
+
pub fn e_source_ldap_get_limit(extension: *mut ESourceLDAP) -> guint;
2513
+
}
2514
+
unsafe extern "C" {
2515
+
pub fn e_source_ldap_set_limit(extension: *mut ESourceLDAP, limit: guint);
2516
+
}
2517
+
unsafe extern "C" {
2518
+
pub fn e_source_ldap_get_root_dn(extension: *mut ESourceLDAP) -> *const gchar;
2519
+
}
2520
+
unsafe extern "C" {
2521
+
pub fn e_source_ldap_dup_root_dn(extension: *mut ESourceLDAP) -> *mut gchar;
2522
+
}
2523
+
unsafe extern "C" {
2524
+
pub fn e_source_ldap_set_root_dn(extension: *mut ESourceLDAP, root_dn: *const gchar);
2525
+
}
2526
+
unsafe extern "C" {
2527
+
pub fn e_source_ldap_get_scope(extension: *mut ESourceLDAP) -> ESourceLDAPScope;
2528
+
}
2529
+
unsafe extern "C" {
2530
+
pub fn e_source_ldap_set_scope(extension: *mut ESourceLDAP, scope: ESourceLDAPScope);
2531
+
}
2532
+
unsafe extern "C" {
2533
+
pub fn e_source_ldap_get_security(extension: *mut ESourceLDAP) -> ESourceLDAPSecurity;
2534
+
}
2535
+
unsafe extern "C" {
2536
+
pub fn e_source_ldap_set_security(extension: *mut ESourceLDAP, security: ESourceLDAPSecurity);
2537
+
}
2538
+
pub type ESourceLocal = _ESourceLocal;
2539
+
#[repr(C)]
2540
+
#[derive(Debug, Copy, Clone)]
2541
+
pub struct _ESourceLocalPrivate {
2542
+
_unused: [u8; 0],
2543
+
}
2544
+
pub type ESourceLocalPrivate = _ESourceLocalPrivate;
2545
+
#[repr(C)]
2546
+
#[derive(Debug, Copy, Clone)]
2547
+
pub struct _ESourceLocal {
2548
+
pub parent: ESourceExtension,
2549
+
pub priv_: *mut ESourceLocalPrivate,
2550
+
}
2551
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2552
+
const _: () = {
2553
+
["Size of _ESourceLocal"][::std::mem::size_of::<_ESourceLocal>() - 40usize];
2554
+
["Alignment of _ESourceLocal"][::std::mem::align_of::<_ESourceLocal>() - 8usize];
2555
+
["Offset of field: _ESourceLocal::parent"]
2556
+
[::std::mem::offset_of!(_ESourceLocal, parent) - 0usize];
2557
+
["Offset of field: _ESourceLocal::priv_"]
2558
+
[::std::mem::offset_of!(_ESourceLocal, priv_) - 32usize];
2559
+
};
2560
+
unsafe extern "C" {
2561
+
pub fn e_source_local_get_type() -> GType;
2562
+
}
2563
+
unsafe extern "C" {
2564
+
pub fn e_source_local_get_custom_file(extension: *mut ESourceLocal) -> *mut GFile;
2565
+
}
2566
+
unsafe extern "C" {
2567
+
pub fn e_source_local_dup_custom_file(extension: *mut ESourceLocal) -> *mut GFile;
2568
+
}
2569
+
unsafe extern "C" {
2570
+
pub fn e_source_local_set_custom_file(extension: *mut ESourceLocal, custom_file: *mut GFile);
2571
+
}
2572
+
unsafe extern "C" {
2573
+
pub fn e_source_local_get_writable(extension: *mut ESourceLocal) -> gboolean;
2574
+
}
2575
+
unsafe extern "C" {
2576
+
pub fn e_source_local_set_writable(extension: *mut ESourceLocal, writable: gboolean);
2577
+
}
2578
+
unsafe extern "C" {
2579
+
pub fn e_source_local_get_email_address(extension: *mut ESourceLocal) -> *const gchar;
2580
+
}
2581
+
unsafe extern "C" {
2582
+
pub fn e_source_local_dup_email_address(extension: *mut ESourceLocal) -> *mut gchar;
2583
+
}
2584
+
unsafe extern "C" {
2585
+
pub fn e_source_local_set_email_address(
2586
+
extension: *mut ESourceLocal,
2587
+
email_address: *const gchar,
2588
+
);
2589
+
}
2590
+
#[doc = " ESourceMailAccount:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
2591
+
pub type ESourceMailAccount = _ESourceMailAccount;
2592
+
#[repr(C)]
2593
+
#[derive(Debug, Copy, Clone)]
2594
+
pub struct _ESourceMailAccountPrivate {
2595
+
_unused: [u8; 0],
2596
+
}
2597
+
pub type ESourceMailAccountPrivate = _ESourceMailAccountPrivate;
2598
+
#[doc = " ESourceMailAccount:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
2599
+
#[repr(C)]
2600
+
#[derive(Debug, Copy, Clone)]
2601
+
pub struct _ESourceMailAccount {
2602
+
pub parent: ESourceBackend,
2603
+
pub priv_: *mut ESourceMailAccountPrivate,
2604
+
}
2605
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2606
+
const _: () = {
2607
+
["Size of _ESourceMailAccount"][::std::mem::size_of::<_ESourceMailAccount>() - 48usize];
2608
+
["Alignment of _ESourceMailAccount"][::std::mem::align_of::<_ESourceMailAccount>() - 8usize];
2609
+
["Offset of field: _ESourceMailAccount::parent"]
2610
+
[::std::mem::offset_of!(_ESourceMailAccount, parent) - 0usize];
2611
+
["Offset of field: _ESourceMailAccount::priv_"]
2612
+
[::std::mem::offset_of!(_ESourceMailAccount, priv_) - 40usize];
2613
+
};
2614
+
unsafe extern "C" {
2615
+
pub fn e_source_mail_account_get_type() -> GType;
2616
+
}
2617
+
unsafe extern "C" {
2618
+
pub fn e_source_mail_account_get_identity_uid(
2619
+
extension: *mut ESourceMailAccount,
2620
+
) -> *const gchar;
2621
+
}
2622
+
unsafe extern "C" {
2623
+
pub fn e_source_mail_account_dup_identity_uid(extension: *mut ESourceMailAccount)
2624
+
-> *mut gchar;
2625
+
}
2626
+
unsafe extern "C" {
2627
+
pub fn e_source_mail_account_set_identity_uid(
2628
+
extension: *mut ESourceMailAccount,
2629
+
identity_uid: *const gchar,
2630
+
);
2631
+
}
2632
+
unsafe extern "C" {
2633
+
pub fn e_source_mail_account_get_archive_folder(
2634
+
extension: *mut ESourceMailAccount,
2635
+
) -> *const gchar;
2636
+
}
2637
+
unsafe extern "C" {
2638
+
pub fn e_source_mail_account_dup_archive_folder(
2639
+
extension: *mut ESourceMailAccount,
2640
+
) -> *mut gchar;
2641
+
}
2642
+
unsafe extern "C" {
2643
+
pub fn e_source_mail_account_set_archive_folder(
2644
+
extension: *mut ESourceMailAccount,
2645
+
archive_folder: *const gchar,
2646
+
);
2647
+
}
2648
+
unsafe extern "C" {
2649
+
pub fn e_source_mail_account_get_needs_initial_setup(
2650
+
extension: *mut ESourceMailAccount,
2651
+
) -> gboolean;
2652
+
}
2653
+
unsafe extern "C" {
2654
+
pub fn e_source_mail_account_set_needs_initial_setup(
2655
+
extension: *mut ESourceMailAccount,
2656
+
needs_initial_setup: gboolean,
2657
+
);
2658
+
}
2659
+
unsafe extern "C" {
2660
+
pub fn e_source_mail_account_get_mark_seen(extension: *mut ESourceMailAccount) -> EThreeState;
2661
+
}
2662
+
unsafe extern "C" {
2663
+
pub fn e_source_mail_account_set_mark_seen(
2664
+
extension: *mut ESourceMailAccount,
2665
+
mark_seen: EThreeState,
2666
+
);
2667
+
}
2668
+
unsafe extern "C" {
2669
+
pub fn e_source_mail_account_get_mark_seen_timeout(extension: *mut ESourceMailAccount) -> gint;
2670
+
}
2671
+
unsafe extern "C" {
2672
+
pub fn e_source_mail_account_set_mark_seen_timeout(
2673
+
extension: *mut ESourceMailAccount,
2674
+
timeout: gint,
2675
+
);
2676
+
}
2677
+
unsafe extern "C" {
2678
+
pub fn e_source_mail_account_get_builtin(extension: *mut ESourceMailAccount) -> gboolean;
2679
+
}
2680
+
unsafe extern "C" {
2681
+
pub fn e_source_mail_account_set_builtin(extension: *mut ESourceMailAccount, builtin: gint);
2682
+
}
2683
+
#[doc = " ESourceMailComposition:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
2684
+
pub type ESourceMailComposition = _ESourceMailComposition;
2685
+
#[repr(C)]
2686
+
#[derive(Debug, Copy, Clone)]
2687
+
pub struct _ESourceMailCompositionPrivate {
2688
+
_unused: [u8; 0],
2689
+
}
2690
+
pub type ESourceMailCompositionPrivate = _ESourceMailCompositionPrivate;
2691
+
#[doc = " ESourceMailComposition:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
2692
+
#[repr(C)]
2693
+
#[derive(Debug, Copy, Clone)]
2694
+
pub struct _ESourceMailComposition {
2695
+
pub parent: ESourceExtension,
2696
+
pub priv_: *mut ESourceMailCompositionPrivate,
2697
+
}
2698
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2699
+
const _: () = {
2700
+
["Size of _ESourceMailComposition"][::std::mem::size_of::<_ESourceMailComposition>() - 40usize];
2701
+
["Alignment of _ESourceMailComposition"]
2702
+
[::std::mem::align_of::<_ESourceMailComposition>() - 8usize];
2703
+
["Offset of field: _ESourceMailComposition::parent"]
2704
+
[::std::mem::offset_of!(_ESourceMailComposition, parent) - 0usize];
2705
+
["Offset of field: _ESourceMailComposition::priv_"]
2706
+
[::std::mem::offset_of!(_ESourceMailComposition, priv_) - 32usize];
2707
+
};
2708
+
unsafe extern "C" {
2709
+
pub fn e_source_mail_composition_get_type() -> GType;
2710
+
}
2711
+
unsafe extern "C" {
2712
+
pub fn e_source_mail_composition_get_bcc(
2713
+
extension: *mut ESourceMailComposition,
2714
+
) -> *const *const gchar;
2715
+
}
2716
+
unsafe extern "C" {
2717
+
pub fn e_source_mail_composition_dup_bcc(
2718
+
extension: *mut ESourceMailComposition,
2719
+
) -> *mut *mut gchar;
2720
+
}
2721
+
unsafe extern "C" {
2722
+
pub fn e_source_mail_composition_set_bcc(
2723
+
extension: *mut ESourceMailComposition,
2724
+
bcc: *const *const gchar,
2725
+
);
2726
+
}
2727
+
unsafe extern "C" {
2728
+
pub fn e_source_mail_composition_get_cc(
2729
+
extension: *mut ESourceMailComposition,
2730
+
) -> *const *const gchar;
2731
+
}
2732
+
unsafe extern "C" {
2733
+
pub fn e_source_mail_composition_dup_cc(
2734
+
extension: *mut ESourceMailComposition,
2735
+
) -> *mut *mut gchar;
2736
+
}
2737
+
unsafe extern "C" {
2738
+
pub fn e_source_mail_composition_set_cc(
2739
+
extension: *mut ESourceMailComposition,
2740
+
cc: *const *const gchar,
2741
+
);
2742
+
}
2743
+
unsafe extern "C" {
2744
+
pub fn e_source_mail_composition_get_drafts_folder(
2745
+
extension: *mut ESourceMailComposition,
2746
+
) -> *const gchar;
2747
+
}
2748
+
unsafe extern "C" {
2749
+
pub fn e_source_mail_composition_dup_drafts_folder(
2750
+
extension: *mut ESourceMailComposition,
2751
+
) -> *mut gchar;
2752
+
}
2753
+
unsafe extern "C" {
2754
+
pub fn e_source_mail_composition_set_drafts_folder(
2755
+
extension: *mut ESourceMailComposition,
2756
+
drafts_folder: *const gchar,
2757
+
);
2758
+
}
2759
+
unsafe extern "C" {
2760
+
pub fn e_source_mail_composition_get_sign_imip(
2761
+
extension: *mut ESourceMailComposition,
2762
+
) -> gboolean;
2763
+
}
2764
+
unsafe extern "C" {
2765
+
pub fn e_source_mail_composition_set_sign_imip(
2766
+
extension: *mut ESourceMailComposition,
2767
+
sign_imip: gboolean,
2768
+
);
2769
+
}
2770
+
unsafe extern "C" {
2771
+
pub fn e_source_mail_composition_get_templates_folder(
2772
+
extension: *mut ESourceMailComposition,
2773
+
) -> *const gchar;
2774
+
}
2775
+
unsafe extern "C" {
2776
+
pub fn e_source_mail_composition_dup_templates_folder(
2777
+
extension: *mut ESourceMailComposition,
2778
+
) -> *mut gchar;
2779
+
}
2780
+
unsafe extern "C" {
2781
+
pub fn e_source_mail_composition_set_templates_folder(
2782
+
extension: *mut ESourceMailComposition,
2783
+
templates_folder: *const gchar,
2784
+
);
2785
+
}
2786
+
unsafe extern "C" {
2787
+
pub fn e_source_mail_composition_get_reply_style(
2788
+
extension: *mut ESourceMailComposition,
2789
+
) -> ESourceMailCompositionReplyStyle;
2790
+
}
2791
+
unsafe extern "C" {
2792
+
pub fn e_source_mail_composition_set_reply_style(
2793
+
extension: *mut ESourceMailComposition,
2794
+
reply_style: ESourceMailCompositionReplyStyle,
2795
+
);
2796
+
}
2797
+
unsafe extern "C" {
2798
+
pub fn e_source_mail_composition_get_start_bottom(
2799
+
extension: *mut ESourceMailComposition,
2800
+
) -> EThreeState;
2801
+
}
2802
+
unsafe extern "C" {
2803
+
pub fn e_source_mail_composition_set_start_bottom(
2804
+
extension: *mut ESourceMailComposition,
2805
+
start_bottom: EThreeState,
2806
+
);
2807
+
}
2808
+
unsafe extern "C" {
2809
+
pub fn e_source_mail_composition_get_top_signature(
2810
+
extension: *mut ESourceMailComposition,
2811
+
) -> EThreeState;
2812
+
}
2813
+
unsafe extern "C" {
2814
+
pub fn e_source_mail_composition_set_top_signature(
2815
+
extension: *mut ESourceMailComposition,
2816
+
top_signature: EThreeState,
2817
+
);
2818
+
}
2819
+
unsafe extern "C" {
2820
+
pub fn e_source_mail_composition_get_language(
2821
+
extension: *mut ESourceMailComposition,
2822
+
) -> *const gchar;
2823
+
}
2824
+
unsafe extern "C" {
2825
+
pub fn e_source_mail_composition_dup_language(
2826
+
extension: *mut ESourceMailComposition,
2827
+
) -> *mut gchar;
2828
+
}
2829
+
unsafe extern "C" {
2830
+
pub fn e_source_mail_composition_set_language(
2831
+
extension: *mut ESourceMailComposition,
2832
+
language: *const gchar,
2833
+
);
2834
+
}
2835
+
#[doc = " ESourceMailIdentity:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
2836
+
pub type ESourceMailIdentity = _ESourceMailIdentity;
2837
+
#[repr(C)]
2838
+
#[derive(Debug, Copy, Clone)]
2839
+
pub struct _ESourceMailIdentityPrivate {
2840
+
_unused: [u8; 0],
2841
+
}
2842
+
pub type ESourceMailIdentityPrivate = _ESourceMailIdentityPrivate;
2843
+
#[doc = " ESourceMailIdentity:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
2844
+
#[repr(C)]
2845
+
#[derive(Debug, Copy, Clone)]
2846
+
pub struct _ESourceMailIdentity {
2847
+
pub parent: ESourceExtension,
2848
+
pub priv_: *mut ESourceMailIdentityPrivate,
2849
+
}
2850
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2851
+
const _: () = {
2852
+
["Size of _ESourceMailIdentity"][::std::mem::size_of::<_ESourceMailIdentity>() - 40usize];
2853
+
["Alignment of _ESourceMailIdentity"][::std::mem::align_of::<_ESourceMailIdentity>() - 8usize];
2854
+
["Offset of field: _ESourceMailIdentity::parent"]
2855
+
[::std::mem::offset_of!(_ESourceMailIdentity, parent) - 0usize];
2856
+
["Offset of field: _ESourceMailIdentity::priv_"]
2857
+
[::std::mem::offset_of!(_ESourceMailIdentity, priv_) - 32usize];
2858
+
};
2859
+
unsafe extern "C" {
2860
+
pub fn e_source_mail_identity_get_type() -> GType;
2861
+
}
2862
+
unsafe extern "C" {
2863
+
pub fn e_source_mail_identity_get_address(extension: *mut ESourceMailIdentity) -> *const gchar;
2864
+
}
2865
+
unsafe extern "C" {
2866
+
pub fn e_source_mail_identity_dup_address(extension: *mut ESourceMailIdentity) -> *mut gchar;
2867
+
}
2868
+
unsafe extern "C" {
2869
+
pub fn e_source_mail_identity_set_address(
2870
+
extension: *mut ESourceMailIdentity,
2871
+
address: *const gchar,
2872
+
);
2873
+
}
2874
+
unsafe extern "C" {
2875
+
pub fn e_source_mail_identity_get_name(extension: *mut ESourceMailIdentity) -> *const gchar;
2876
+
}
2877
+
unsafe extern "C" {
2878
+
pub fn e_source_mail_identity_dup_name(extension: *mut ESourceMailIdentity) -> *mut gchar;
2879
+
}
2880
+
unsafe extern "C" {
2881
+
pub fn e_source_mail_identity_set_name(extension: *mut ESourceMailIdentity, name: *const gchar);
2882
+
}
2883
+
unsafe extern "C" {
2884
+
pub fn e_source_mail_identity_get_organization(
2885
+
extension: *mut ESourceMailIdentity,
2886
+
) -> *const gchar;
2887
+
}
2888
+
unsafe extern "C" {
2889
+
pub fn e_source_mail_identity_dup_organization(
2890
+
extension: *mut ESourceMailIdentity,
2891
+
) -> *mut gchar;
2892
+
}
2893
+
unsafe extern "C" {
2894
+
pub fn e_source_mail_identity_set_organization(
2895
+
extension: *mut ESourceMailIdentity,
2896
+
organization: *const gchar,
2897
+
);
2898
+
}
2899
+
unsafe extern "C" {
2900
+
pub fn e_source_mail_identity_get_reply_to(extension: *mut ESourceMailIdentity)
2901
+
-> *const gchar;
2902
+
}
2903
+
unsafe extern "C" {
2904
+
pub fn e_source_mail_identity_dup_reply_to(extension: *mut ESourceMailIdentity) -> *mut gchar;
2905
+
}
2906
+
unsafe extern "C" {
2907
+
pub fn e_source_mail_identity_set_reply_to(
2908
+
extension: *mut ESourceMailIdentity,
2909
+
reply_to: *const gchar,
2910
+
);
2911
+
}
2912
+
unsafe extern "C" {
2913
+
pub fn e_source_mail_identity_get_signature_uid(
2914
+
extension: *mut ESourceMailIdentity,
2915
+
) -> *const gchar;
2916
+
}
2917
+
unsafe extern "C" {
2918
+
pub fn e_source_mail_identity_dup_signature_uid(
2919
+
extension: *mut ESourceMailIdentity,
2920
+
) -> *mut gchar;
2921
+
}
2922
+
unsafe extern "C" {
2923
+
pub fn e_source_mail_identity_set_signature_uid(
2924
+
extension: *mut ESourceMailIdentity,
2925
+
signature_uid: *const gchar,
2926
+
);
2927
+
}
2928
+
unsafe extern "C" {
2929
+
pub fn e_source_mail_identity_get_aliases(extension: *mut ESourceMailIdentity) -> *const gchar;
2930
+
}
2931
+
unsafe extern "C" {
2932
+
pub fn e_source_mail_identity_dup_aliases(extension: *mut ESourceMailIdentity) -> *mut gchar;
2933
+
}
2934
+
unsafe extern "C" {
2935
+
pub fn e_source_mail_identity_set_aliases(
2936
+
extension: *mut ESourceMailIdentity,
2937
+
aliases: *const gchar,
2938
+
);
2939
+
}
2940
+
unsafe extern "C" {
2941
+
pub fn e_source_mail_identity_get_aliases_as_hash_table(
2942
+
extension: *mut ESourceMailIdentity,
2943
+
) -> *mut GHashTable;
2944
+
}
2945
+
#[doc = " ESourceMailSignature:\n\n Contains only private data that should be read and manipulated using the\n function below.\n\n Since: 3.6"]
2946
+
pub type ESourceMailSignature = _ESourceMailSignature;
2947
+
#[repr(C)]
2948
+
#[derive(Debug, Copy, Clone)]
2949
+
pub struct _ESourceMailSignaturePrivate {
2950
+
_unused: [u8; 0],
2951
+
}
2952
+
pub type ESourceMailSignaturePrivate = _ESourceMailSignaturePrivate;
2953
+
#[doc = " ESourceMailSignature:\n\n Contains only private data that should be read and manipulated using the\n function below.\n\n Since: 3.6"]
2954
+
#[repr(C)]
2955
+
#[derive(Debug, Copy, Clone)]
2956
+
pub struct _ESourceMailSignature {
2957
+
pub parent: ESourceExtension,
2958
+
pub priv_: *mut ESourceMailSignaturePrivate,
2959
+
}
2960
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2961
+
const _: () = {
2962
+
["Size of _ESourceMailSignature"][::std::mem::size_of::<_ESourceMailSignature>() - 40usize];
2963
+
["Alignment of _ESourceMailSignature"]
2964
+
[::std::mem::align_of::<_ESourceMailSignature>() - 8usize];
2965
+
["Offset of field: _ESourceMailSignature::parent"]
2966
+
[::std::mem::offset_of!(_ESourceMailSignature, parent) - 0usize];
2967
+
["Offset of field: _ESourceMailSignature::priv_"]
2968
+
[::std::mem::offset_of!(_ESourceMailSignature, priv_) - 32usize];
2969
+
};
2970
+
unsafe extern "C" {
2971
+
pub fn e_source_mail_signature_get_type() -> GType;
2972
+
}
2973
+
unsafe extern "C" {
2974
+
pub fn e_source_mail_signature_get_file(extension: *mut ESourceMailSignature) -> *mut GFile;
2975
+
}
2976
+
unsafe extern "C" {
2977
+
pub fn e_source_mail_signature_get_mime_type(
2978
+
extension: *mut ESourceMailSignature,
2979
+
) -> *const gchar;
2980
+
}
2981
+
unsafe extern "C" {
2982
+
pub fn e_source_mail_signature_dup_mime_type(
2983
+
extension: *mut ESourceMailSignature,
2984
+
) -> *mut gchar;
2985
+
}
2986
+
unsafe extern "C" {
2987
+
pub fn e_source_mail_signature_set_mime_type(
2988
+
extension: *mut ESourceMailSignature,
2989
+
mime_type: *const gchar,
2990
+
);
2991
+
}
2992
+
unsafe extern "C" {
2993
+
pub fn e_source_mail_signature_load_sync(
2994
+
source: *mut ESource,
2995
+
contents: *mut *mut gchar,
2996
+
length: *mut gsize,
2997
+
cancellable: *mut GCancellable,
2998
+
error: *mut *mut GError,
2999
+
) -> gboolean;
3000
+
}
3001
+
unsafe extern "C" {
3002
+
pub fn e_source_mail_signature_load(
3003
+
source: *mut ESource,
3004
+
io_priority: gint,
3005
+
cancellable: *mut GCancellable,
3006
+
callback: GAsyncReadyCallback,
3007
+
user_data: gpointer,
3008
+
);
3009
+
}
3010
+
unsafe extern "C" {
3011
+
pub fn e_source_mail_signature_load_finish(
3012
+
source: *mut ESource,
3013
+
result: *mut GAsyncResult,
3014
+
contents: *mut *mut gchar,
3015
+
length: *mut gsize,
3016
+
error: *mut *mut GError,
3017
+
) -> gboolean;
3018
+
}
3019
+
unsafe extern "C" {
3020
+
pub fn e_source_mail_signature_replace_sync(
3021
+
source: *mut ESource,
3022
+
contents: *const gchar,
3023
+
length: gsize,
3024
+
cancellable: *mut GCancellable,
3025
+
error: *mut *mut GError,
3026
+
) -> gboolean;
3027
+
}
3028
+
unsafe extern "C" {
3029
+
pub fn e_source_mail_signature_replace(
3030
+
source: *mut ESource,
3031
+
contents: *const gchar,
3032
+
length: gsize,
3033
+
io_priority: gint,
3034
+
cancellable: *mut GCancellable,
3035
+
callback: GAsyncReadyCallback,
3036
+
user_data: gpointer,
3037
+
);
3038
+
}
3039
+
unsafe extern "C" {
3040
+
pub fn e_source_mail_signature_replace_finish(
3041
+
source: *mut ESource,
3042
+
result: *mut GAsyncResult,
3043
+
error: *mut *mut GError,
3044
+
) -> gboolean;
3045
+
}
3046
+
unsafe extern "C" {
3047
+
pub fn e_source_mail_signature_symlink_sync(
3048
+
source: *mut ESource,
3049
+
symlink_target: *const gchar,
3050
+
cancellable: *mut GCancellable,
3051
+
error: *mut *mut GError,
3052
+
) -> gboolean;
3053
+
}
3054
+
unsafe extern "C" {
3055
+
pub fn e_source_mail_signature_symlink(
3056
+
source: *mut ESource,
3057
+
symlink_target: *const gchar,
3058
+
io_priority: gint,
3059
+
cancellable: *mut GCancellable,
3060
+
callback: GAsyncReadyCallback,
3061
+
user_data: gpointer,
3062
+
);
3063
+
}
3064
+
unsafe extern "C" {
3065
+
pub fn e_source_mail_signature_symlink_finish(
3066
+
source: *mut ESource,
3067
+
result: *mut GAsyncResult,
3068
+
error: *mut *mut GError,
3069
+
) -> gboolean;
3070
+
}
3071
+
#[doc = " ESourceMailSubmission:\n\n Contains only private data that should be read and manipulated using the\n function below.\n\n Since: 3.6"]
3072
+
pub type ESourceMailSubmission = _ESourceMailSubmission;
3073
+
#[repr(C)]
3074
+
#[derive(Debug, Copy, Clone)]
3075
+
pub struct _ESourceMailSubmissionPrivate {
3076
+
_unused: [u8; 0],
3077
+
}
3078
+
pub type ESourceMailSubmissionPrivate = _ESourceMailSubmissionPrivate;
3079
+
#[doc = " ESourceMailSubmission:\n\n Contains only private data that should be read and manipulated using the\n function below.\n\n Since: 3.6"]
3080
+
#[repr(C)]
3081
+
#[derive(Debug, Copy, Clone)]
3082
+
pub struct _ESourceMailSubmission {
3083
+
pub parent: ESourceExtension,
3084
+
pub priv_: *mut ESourceMailSubmissionPrivate,
3085
+
}
3086
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3087
+
const _: () = {
3088
+
["Size of _ESourceMailSubmission"][::std::mem::size_of::<_ESourceMailSubmission>() - 40usize];
3089
+
["Alignment of _ESourceMailSubmission"]
3090
+
[::std::mem::align_of::<_ESourceMailSubmission>() - 8usize];
3091
+
["Offset of field: _ESourceMailSubmission::parent"]
3092
+
[::std::mem::offset_of!(_ESourceMailSubmission, parent) - 0usize];
3093
+
["Offset of field: _ESourceMailSubmission::priv_"]
3094
+
[::std::mem::offset_of!(_ESourceMailSubmission, priv_) - 32usize];
3095
+
};
3096
+
unsafe extern "C" {
3097
+
pub fn e_source_mail_submission_get_type() -> GType;
3098
+
}
3099
+
unsafe extern "C" {
3100
+
pub fn e_source_mail_submission_get_sent_folder(
3101
+
extension: *mut ESourceMailSubmission,
3102
+
) -> *const gchar;
3103
+
}
3104
+
unsafe extern "C" {
3105
+
pub fn e_source_mail_submission_dup_sent_folder(
3106
+
extension: *mut ESourceMailSubmission,
3107
+
) -> *mut gchar;
3108
+
}
3109
+
unsafe extern "C" {
3110
+
pub fn e_source_mail_submission_set_sent_folder(
3111
+
extension: *mut ESourceMailSubmission,
3112
+
sent_folder: *const gchar,
3113
+
);
3114
+
}
3115
+
unsafe extern "C" {
3116
+
pub fn e_source_mail_submission_get_use_sent_folder(
3117
+
extension: *mut ESourceMailSubmission,
3118
+
) -> gboolean;
3119
+
}
3120
+
unsafe extern "C" {
3121
+
pub fn e_source_mail_submission_set_use_sent_folder(
3122
+
extension: *mut ESourceMailSubmission,
3123
+
use_sent_folder: gboolean,
3124
+
);
3125
+
}
3126
+
unsafe extern "C" {
3127
+
pub fn e_source_mail_submission_get_transport_uid(
3128
+
extension: *mut ESourceMailSubmission,
3129
+
) -> *const gchar;
3130
+
}
3131
+
unsafe extern "C" {
3132
+
pub fn e_source_mail_submission_dup_transport_uid(
3133
+
extension: *mut ESourceMailSubmission,
3134
+
) -> *mut gchar;
3135
+
}
3136
+
unsafe extern "C" {
3137
+
pub fn e_source_mail_submission_set_transport_uid(
3138
+
extension: *mut ESourceMailSubmission,
3139
+
transport_uid: *const gchar,
3140
+
);
3141
+
}
3142
+
unsafe extern "C" {
3143
+
pub fn e_source_mail_submission_get_replies_to_origin_folder(
3144
+
extension: *mut ESourceMailSubmission,
3145
+
) -> gboolean;
3146
+
}
3147
+
unsafe extern "C" {
3148
+
pub fn e_source_mail_submission_set_replies_to_origin_folder(
3149
+
extension: *mut ESourceMailSubmission,
3150
+
replies_to_origin_folder: gboolean,
3151
+
);
3152
+
}
3153
+
unsafe extern "C" {
3154
+
pub fn e_source_mail_transport_get_type() -> GType;
3155
+
}
3156
+
#[doc = " ESourceMDN:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3157
+
pub type ESourceMDN = _ESourceMDN;
3158
+
#[repr(C)]
3159
+
#[derive(Debug, Copy, Clone)]
3160
+
pub struct _ESourceMDNPrivate {
3161
+
_unused: [u8; 0],
3162
+
}
3163
+
pub type ESourceMDNPrivate = _ESourceMDNPrivate;
3164
+
#[doc = " ESourceMDN:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3165
+
#[repr(C)]
3166
+
#[derive(Debug, Copy, Clone)]
3167
+
pub struct _ESourceMDN {
3168
+
pub parent: ESourceExtension,
3169
+
pub priv_: *mut ESourceMDNPrivate,
3170
+
}
3171
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3172
+
const _: () = {
3173
+
["Size of _ESourceMDN"][::std::mem::size_of::<_ESourceMDN>() - 40usize];
3174
+
["Alignment of _ESourceMDN"][::std::mem::align_of::<_ESourceMDN>() - 8usize];
3175
+
["Offset of field: _ESourceMDN::parent"][::std::mem::offset_of!(_ESourceMDN, parent) - 0usize];
3176
+
["Offset of field: _ESourceMDN::priv_"][::std::mem::offset_of!(_ESourceMDN, priv_) - 32usize];
3177
+
};
3178
+
unsafe extern "C" {
3179
+
pub fn e_source_mdn_get_type() -> GType;
3180
+
}
3181
+
unsafe extern "C" {
3182
+
pub fn e_source_mdn_get_response_policy(extension: *mut ESourceMDN) -> EMdnResponsePolicy;
3183
+
}
3184
+
unsafe extern "C" {
3185
+
pub fn e_source_mdn_set_response_policy(
3186
+
extension: *mut ESourceMDN,
3187
+
response_policy: EMdnResponsePolicy,
3188
+
);
3189
+
}
3190
+
unsafe extern "C" {
3191
+
pub fn e_source_memo_list_get_type() -> GType;
3192
+
}
3193
+
#[doc = " ESourceOffline:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3194
+
pub type ESourceOffline = _ESourceOffline;
3195
+
#[repr(C)]
3196
+
#[derive(Debug, Copy, Clone)]
3197
+
pub struct _ESourceOfflinePrivate {
3198
+
_unused: [u8; 0],
3199
+
}
3200
+
pub type ESourceOfflinePrivate = _ESourceOfflinePrivate;
3201
+
#[doc = " ESourceOffline:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3202
+
#[repr(C)]
3203
+
#[derive(Debug, Copy, Clone)]
3204
+
pub struct _ESourceOffline {
3205
+
pub parent: ESourceExtension,
3206
+
pub priv_: *mut ESourceOfflinePrivate,
3207
+
}
3208
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3209
+
const _: () = {
3210
+
["Size of _ESourceOffline"][::std::mem::size_of::<_ESourceOffline>() - 40usize];
3211
+
["Alignment of _ESourceOffline"][::std::mem::align_of::<_ESourceOffline>() - 8usize];
3212
+
["Offset of field: _ESourceOffline::parent"]
3213
+
[::std::mem::offset_of!(_ESourceOffline, parent) - 0usize];
3214
+
["Offset of field: _ESourceOffline::priv_"]
3215
+
[::std::mem::offset_of!(_ESourceOffline, priv_) - 32usize];
3216
+
};
3217
+
unsafe extern "C" {
3218
+
pub fn e_source_offline_get_type() -> GType;
3219
+
}
3220
+
unsafe extern "C" {
3221
+
pub fn e_source_offline_get_stay_synchronized(extension: *mut ESourceOffline) -> gboolean;
3222
+
}
3223
+
unsafe extern "C" {
3224
+
pub fn e_source_offline_set_stay_synchronized(
3225
+
extension: *mut ESourceOffline,
3226
+
stay_synchronized: gboolean,
3227
+
);
3228
+
}
3229
+
#[doc = " ESourceOpenPGP:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3230
+
pub type ESourceOpenPGP = _ESourceOpenPGP;
3231
+
#[repr(C)]
3232
+
#[derive(Debug, Copy, Clone)]
3233
+
pub struct _ESourceOpenPGPPrivate {
3234
+
_unused: [u8; 0],
3235
+
}
3236
+
pub type ESourceOpenPGPPrivate = _ESourceOpenPGPPrivate;
3237
+
#[doc = " ESourceOpenPGP:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3238
+
#[repr(C)]
3239
+
#[derive(Debug, Copy, Clone)]
3240
+
pub struct _ESourceOpenPGP {
3241
+
pub parent: ESourceExtension,
3242
+
pub priv_: *mut ESourceOpenPGPPrivate,
3243
+
}
3244
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3245
+
const _: () = {
3246
+
["Size of _ESourceOpenPGP"][::std::mem::size_of::<_ESourceOpenPGP>() - 40usize];
3247
+
["Alignment of _ESourceOpenPGP"][::std::mem::align_of::<_ESourceOpenPGP>() - 8usize];
3248
+
["Offset of field: _ESourceOpenPGP::parent"]
3249
+
[::std::mem::offset_of!(_ESourceOpenPGP, parent) - 0usize];
3250
+
["Offset of field: _ESourceOpenPGP::priv_"]
3251
+
[::std::mem::offset_of!(_ESourceOpenPGP, priv_) - 32usize];
3252
+
};
3253
+
unsafe extern "C" {
3254
+
pub fn e_source_openpgp_get_type() -> GType;
3255
+
}
3256
+
unsafe extern "C" {
3257
+
pub fn e_source_openpgp_get_always_trust(extension: *mut ESourceOpenPGP) -> gboolean;
3258
+
}
3259
+
unsafe extern "C" {
3260
+
pub fn e_source_openpgp_set_always_trust(
3261
+
extension: *mut ESourceOpenPGP,
3262
+
always_trust: gboolean,
3263
+
);
3264
+
}
3265
+
unsafe extern "C" {
3266
+
pub fn e_source_openpgp_get_encrypt_to_self(extension: *mut ESourceOpenPGP) -> gboolean;
3267
+
}
3268
+
unsafe extern "C" {
3269
+
pub fn e_source_openpgp_set_encrypt_to_self(
3270
+
extension: *mut ESourceOpenPGP,
3271
+
encrypt_to_self: gboolean,
3272
+
);
3273
+
}
3274
+
unsafe extern "C" {
3275
+
pub fn e_source_openpgp_get_key_id(extension: *mut ESourceOpenPGP) -> *const gchar;
3276
+
}
3277
+
unsafe extern "C" {
3278
+
pub fn e_source_openpgp_dup_key_id(extension: *mut ESourceOpenPGP) -> *mut gchar;
3279
+
}
3280
+
unsafe extern "C" {
3281
+
pub fn e_source_openpgp_set_key_id(extension: *mut ESourceOpenPGP, key_id: *const gchar);
3282
+
}
3283
+
unsafe extern "C" {
3284
+
pub fn e_source_openpgp_get_signing_algorithm(extension: *mut ESourceOpenPGP) -> *const gchar;
3285
+
}
3286
+
unsafe extern "C" {
3287
+
pub fn e_source_openpgp_dup_signing_algorithm(extension: *mut ESourceOpenPGP) -> *mut gchar;
3288
+
}
3289
+
unsafe extern "C" {
3290
+
pub fn e_source_openpgp_set_signing_algorithm(
3291
+
extension: *mut ESourceOpenPGP,
3292
+
signing_algorithm: *const gchar,
3293
+
);
3294
+
}
3295
+
unsafe extern "C" {
3296
+
pub fn e_source_openpgp_get_sign_by_default(extension: *mut ESourceOpenPGP) -> gboolean;
3297
+
}
3298
+
unsafe extern "C" {
3299
+
pub fn e_source_openpgp_set_sign_by_default(
3300
+
extension: *mut ESourceOpenPGP,
3301
+
sign_by_default: gboolean,
3302
+
);
3303
+
}
3304
+
unsafe extern "C" {
3305
+
pub fn e_source_openpgp_get_encrypt_by_default(extension: *mut ESourceOpenPGP) -> gboolean;
3306
+
}
3307
+
unsafe extern "C" {
3308
+
pub fn e_source_openpgp_set_encrypt_by_default(
3309
+
extension: *mut ESourceOpenPGP,
3310
+
encrypt_by_default: gboolean,
3311
+
);
3312
+
}
3313
+
unsafe extern "C" {
3314
+
pub fn e_source_openpgp_get_prefer_inline(extension: *mut ESourceOpenPGP) -> gboolean;
3315
+
}
3316
+
unsafe extern "C" {
3317
+
pub fn e_source_openpgp_set_prefer_inline(
3318
+
extension: *mut ESourceOpenPGP,
3319
+
prefer_inline: gboolean,
3320
+
);
3321
+
}
3322
+
unsafe extern "C" {
3323
+
pub fn e_source_openpgp_get_locate_keys(extension: *mut ESourceOpenPGP) -> gboolean;
3324
+
}
3325
+
unsafe extern "C" {
3326
+
pub fn e_source_openpgp_set_locate_keys(extension: *mut ESourceOpenPGP, locate_keys: gboolean);
3327
+
}
3328
+
unsafe extern "C" {
3329
+
pub fn e_source_openpgp_get_send_public_key(extension: *mut ESourceOpenPGP) -> gboolean;
3330
+
}
3331
+
unsafe extern "C" {
3332
+
pub fn e_source_openpgp_set_send_public_key(
3333
+
extension: *mut ESourceOpenPGP,
3334
+
send_public_key: gboolean,
3335
+
);
3336
+
}
3337
+
unsafe extern "C" {
3338
+
pub fn e_source_openpgp_get_send_prefer_encrypt(extension: *mut ESourceOpenPGP) -> gboolean;
3339
+
}
3340
+
unsafe extern "C" {
3341
+
pub fn e_source_openpgp_set_send_prefer_encrypt(
3342
+
extension: *mut ESourceOpenPGP,
3343
+
send_prefer_encrypt: gboolean,
3344
+
);
3345
+
}
3346
+
unsafe extern "C" {
3347
+
pub fn e_source_openpgp_get_ask_send_public_key(extension: *mut ESourceOpenPGP) -> gboolean;
3348
+
}
3349
+
unsafe extern "C" {
3350
+
pub fn e_source_openpgp_set_ask_send_public_key(
3351
+
extension: *mut ESourceOpenPGP,
3352
+
ask_send_public_key: gboolean,
3353
+
);
3354
+
}
3355
+
#[doc = " ESourceProxy:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.12"]
3356
+
pub type ESourceProxy = _ESourceProxy;
3357
+
#[repr(C)]
3358
+
#[derive(Debug, Copy, Clone)]
3359
+
pub struct _ESourceProxyPrivate {
3360
+
_unused: [u8; 0],
3361
+
}
3362
+
pub type ESourceProxyPrivate = _ESourceProxyPrivate;
3363
+
#[doc = " ESourceProxy:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.12"]
3364
+
#[repr(C)]
3365
+
#[derive(Debug, Copy, Clone)]
3366
+
pub struct _ESourceProxy {
3367
+
pub parent: ESourceExtension,
3368
+
pub priv_: *mut ESourceProxyPrivate,
3369
+
}
3370
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3371
+
const _: () = {
3372
+
["Size of _ESourceProxy"][::std::mem::size_of::<_ESourceProxy>() - 40usize];
3373
+
["Alignment of _ESourceProxy"][::std::mem::align_of::<_ESourceProxy>() - 8usize];
3374
+
["Offset of field: _ESourceProxy::parent"]
3375
+
[::std::mem::offset_of!(_ESourceProxy, parent) - 0usize];
3376
+
["Offset of field: _ESourceProxy::priv_"]
3377
+
[::std::mem::offset_of!(_ESourceProxy, priv_) - 32usize];
3378
+
};
3379
+
unsafe extern "C" {
3380
+
pub fn e_source_proxy_get_type() -> GType;
3381
+
}
3382
+
unsafe extern "C" {
3383
+
pub fn e_source_proxy_get_method(extension: *mut ESourceProxy) -> EProxyMethod;
3384
+
}
3385
+
unsafe extern "C" {
3386
+
pub fn e_source_proxy_set_method(extension: *mut ESourceProxy, method: EProxyMethod);
3387
+
}
3388
+
unsafe extern "C" {
3389
+
pub fn e_source_proxy_get_autoconfig_url(extension: *mut ESourceProxy) -> *const gchar;
3390
+
}
3391
+
unsafe extern "C" {
3392
+
pub fn e_source_proxy_dup_autoconfig_url(extension: *mut ESourceProxy) -> *mut gchar;
3393
+
}
3394
+
unsafe extern "C" {
3395
+
pub fn e_source_proxy_set_autoconfig_url(
3396
+
extension: *mut ESourceProxy,
3397
+
autoconfig_url: *const gchar,
3398
+
);
3399
+
}
3400
+
unsafe extern "C" {
3401
+
pub fn e_source_proxy_get_ignore_hosts(extension: *mut ESourceProxy) -> *const *const gchar;
3402
+
}
3403
+
unsafe extern "C" {
3404
+
pub fn e_source_proxy_dup_ignore_hosts(extension: *mut ESourceProxy) -> *mut *mut gchar;
3405
+
}
3406
+
unsafe extern "C" {
3407
+
pub fn e_source_proxy_set_ignore_hosts(
3408
+
extension: *mut ESourceProxy,
3409
+
ignore_hosts: *const *const gchar,
3410
+
);
3411
+
}
3412
+
unsafe extern "C" {
3413
+
pub fn e_source_proxy_get_ftp_host(extension: *mut ESourceProxy) -> *const gchar;
3414
+
}
3415
+
unsafe extern "C" {
3416
+
pub fn e_source_proxy_dup_ftp_host(extension: *mut ESourceProxy) -> *mut gchar;
3417
+
}
3418
+
unsafe extern "C" {
3419
+
pub fn e_source_proxy_set_ftp_host(extension: *mut ESourceProxy, ftp_host: *const gchar);
3420
+
}
3421
+
unsafe extern "C" {
3422
+
pub fn e_source_proxy_get_ftp_port(extension: *mut ESourceProxy) -> guint16;
3423
+
}
3424
+
unsafe extern "C" {
3425
+
pub fn e_source_proxy_set_ftp_port(extension: *mut ESourceProxy, ftp_port: guint16);
3426
+
}
3427
+
unsafe extern "C" {
3428
+
pub fn e_source_proxy_get_http_host(extension: *mut ESourceProxy) -> *const gchar;
3429
+
}
3430
+
unsafe extern "C" {
3431
+
pub fn e_source_proxy_dup_http_host(extension: *mut ESourceProxy) -> *mut gchar;
3432
+
}
3433
+
unsafe extern "C" {
3434
+
pub fn e_source_proxy_set_http_host(extension: *mut ESourceProxy, http_host: *const gchar);
3435
+
}
3436
+
unsafe extern "C" {
3437
+
pub fn e_source_proxy_get_http_port(extension: *mut ESourceProxy) -> guint16;
3438
+
}
3439
+
unsafe extern "C" {
3440
+
pub fn e_source_proxy_set_http_port(extension: *mut ESourceProxy, http_port: guint16);
3441
+
}
3442
+
unsafe extern "C" {
3443
+
pub fn e_source_proxy_get_http_use_auth(extension: *mut ESourceProxy) -> gboolean;
3444
+
}
3445
+
unsafe extern "C" {
3446
+
pub fn e_source_proxy_set_http_use_auth(extension: *mut ESourceProxy, http_use_auth: gboolean);
3447
+
}
3448
+
unsafe extern "C" {
3449
+
pub fn e_source_proxy_get_http_auth_user(extension: *mut ESourceProxy) -> *const gchar;
3450
+
}
3451
+
unsafe extern "C" {
3452
+
pub fn e_source_proxy_dup_http_auth_user(extension: *mut ESourceProxy) -> *mut gchar;
3453
+
}
3454
+
unsafe extern "C" {
3455
+
pub fn e_source_proxy_set_http_auth_user(
3456
+
extension: *mut ESourceProxy,
3457
+
http_auth_user: *const gchar,
3458
+
);
3459
+
}
3460
+
unsafe extern "C" {
3461
+
pub fn e_source_proxy_get_http_auth_password(extension: *mut ESourceProxy) -> *const gchar;
3462
+
}
3463
+
unsafe extern "C" {
3464
+
pub fn e_source_proxy_dup_http_auth_password(extension: *mut ESourceProxy) -> *mut gchar;
3465
+
}
3466
+
unsafe extern "C" {
3467
+
pub fn e_source_proxy_set_http_auth_password(
3468
+
extension: *mut ESourceProxy,
3469
+
http_auth_password: *const gchar,
3470
+
);
3471
+
}
3472
+
unsafe extern "C" {
3473
+
pub fn e_source_proxy_get_https_host(extension: *mut ESourceProxy) -> *const gchar;
3474
+
}
3475
+
unsafe extern "C" {
3476
+
pub fn e_source_proxy_dup_https_host(extension: *mut ESourceProxy) -> *mut gchar;
3477
+
}
3478
+
unsafe extern "C" {
3479
+
pub fn e_source_proxy_set_https_host(extension: *mut ESourceProxy, https_host: *const gchar);
3480
+
}
3481
+
unsafe extern "C" {
3482
+
pub fn e_source_proxy_get_https_port(extension: *mut ESourceProxy) -> guint16;
3483
+
}
3484
+
unsafe extern "C" {
3485
+
pub fn e_source_proxy_set_https_port(extension: *mut ESourceProxy, https_port: guint16);
3486
+
}
3487
+
unsafe extern "C" {
3488
+
pub fn e_source_proxy_get_socks_host(extension: *mut ESourceProxy) -> *const gchar;
3489
+
}
3490
+
unsafe extern "C" {
3491
+
pub fn e_source_proxy_dup_socks_host(extension: *mut ESourceProxy) -> *mut gchar;
3492
+
}
3493
+
unsafe extern "C" {
3494
+
pub fn e_source_proxy_set_socks_host(extension: *mut ESourceProxy, socks_host: *const gchar);
3495
+
}
3496
+
unsafe extern "C" {
3497
+
pub fn e_source_proxy_get_socks_port(extension: *mut ESourceProxy) -> guint16;
3498
+
}
3499
+
unsafe extern "C" {
3500
+
pub fn e_source_proxy_set_socks_port(extension: *mut ESourceProxy, socks_port: guint16);
3501
+
}
3502
+
unsafe extern "C" {
3503
+
pub fn e_source_proxy_lookup_sync(
3504
+
source: *mut ESource,
3505
+
uri: *const gchar,
3506
+
cancellable: *mut GCancellable,
3507
+
error: *mut *mut GError,
3508
+
) -> *mut *mut gchar;
3509
+
}
3510
+
unsafe extern "C" {
3511
+
pub fn e_source_proxy_lookup(
3512
+
source: *mut ESource,
3513
+
uri: *const gchar,
3514
+
cancellable: *mut GCancellable,
3515
+
callback: GAsyncReadyCallback,
3516
+
user_data: gpointer,
3517
+
);
3518
+
}
3519
+
unsafe extern "C" {
3520
+
pub fn e_source_proxy_lookup_finish(
3521
+
source: *mut ESource,
3522
+
result: *mut GAsyncResult,
3523
+
error: *mut *mut GError,
3524
+
) -> *mut *mut gchar;
3525
+
}
3526
+
#[doc = " ESourceRefresh:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3527
+
pub type ESourceRefresh = _ESourceRefresh;
3528
+
#[repr(C)]
3529
+
#[derive(Debug, Copy, Clone)]
3530
+
pub struct _ESourceRefreshPrivate {
3531
+
_unused: [u8; 0],
3532
+
}
3533
+
pub type ESourceRefreshPrivate = _ESourceRefreshPrivate;
3534
+
#[doc = " ESourceRefresh:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3535
+
#[repr(C)]
3536
+
#[derive(Debug, Copy, Clone)]
3537
+
pub struct _ESourceRefresh {
3538
+
pub parent: ESourceExtension,
3539
+
pub priv_: *mut ESourceRefreshPrivate,
3540
+
}
3541
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3542
+
const _: () = {
3543
+
["Size of _ESourceRefresh"][::std::mem::size_of::<_ESourceRefresh>() - 40usize];
3544
+
["Alignment of _ESourceRefresh"][::std::mem::align_of::<_ESourceRefresh>() - 8usize];
3545
+
["Offset of field: _ESourceRefresh::parent"]
3546
+
[::std::mem::offset_of!(_ESourceRefresh, parent) - 0usize];
3547
+
["Offset of field: _ESourceRefresh::priv_"]
3548
+
[::std::mem::offset_of!(_ESourceRefresh, priv_) - 32usize];
3549
+
};
3550
+
#[doc = " ESourceRefreshFunc:\n @source: an #ESource\n @user_data: user data provided to the callback function\n\n Since: 3.6"]
3551
+
pub type ESourceRefreshFunc =
3552
+
::std::option::Option<unsafe extern "C" fn(source: *mut ESource, user_data: gpointer)>;
3553
+
unsafe extern "C" {
3554
+
pub fn e_source_refresh_get_type() -> GType;
3555
+
}
3556
+
unsafe extern "C" {
3557
+
pub fn e_source_refresh_get_enabled(extension: *mut ESourceRefresh) -> gboolean;
3558
+
}
3559
+
unsafe extern "C" {
3560
+
pub fn e_source_refresh_set_enabled(extension: *mut ESourceRefresh, enabled: gboolean);
3561
+
}
3562
+
unsafe extern "C" {
3563
+
pub fn e_source_refresh_get_enabled_on_metered_network(
3564
+
extension: *mut ESourceRefresh,
3565
+
) -> gboolean;
3566
+
}
3567
+
unsafe extern "C" {
3568
+
pub fn e_source_refresh_set_enabled_on_metered_network(
3569
+
extension: *mut ESourceRefresh,
3570
+
enabled: gboolean,
3571
+
);
3572
+
}
3573
+
unsafe extern "C" {
3574
+
pub fn e_source_refresh_get_interval_minutes(extension: *mut ESourceRefresh) -> guint;
3575
+
}
3576
+
unsafe extern "C" {
3577
+
pub fn e_source_refresh_set_interval_minutes(
3578
+
extension: *mut ESourceRefresh,
3579
+
interval_minutes: guint,
3580
+
);
3581
+
}
3582
+
unsafe extern "C" {
3583
+
pub fn e_source_refresh_add_timeout(
3584
+
source: *mut ESource,
3585
+
context: *mut GMainContext,
3586
+
callback: ESourceRefreshFunc,
3587
+
user_data: gpointer,
3588
+
notify: GDestroyNotify,
3589
+
) -> guint;
3590
+
}
3591
+
unsafe extern "C" {
3592
+
pub fn e_source_refresh_force_timeout(source: *mut ESource);
3593
+
}
3594
+
unsafe extern "C" {
3595
+
pub fn e_source_refresh_remove_timeout(
3596
+
source: *mut ESource,
3597
+
refresh_timeout_id: guint,
3598
+
) -> gboolean;
3599
+
}
3600
+
unsafe extern "C" {
3601
+
pub fn e_source_refresh_remove_timeouts_by_data(
3602
+
source: *mut ESource,
3603
+
user_data: gpointer,
3604
+
) -> guint;
3605
+
}
3606
+
#[doc = " ESourceRegistryWatcher:\n\n Contains only private data that should be read and manipulated using the\n functions below."]
3607
+
pub type ESourceRegistryWatcher = _ESourceRegistryWatcher;
3608
+
#[repr(C)]
3609
+
#[derive(Debug, Copy, Clone)]
3610
+
pub struct _ESourceRegistryWatcherPrivate {
3611
+
_unused: [u8; 0],
3612
+
}
3613
+
pub type ESourceRegistryWatcherPrivate = _ESourceRegistryWatcherPrivate;
3614
+
#[doc = " ESourceRegistryWatcher:\n\n Contains only private data that should be read and manipulated using the\n functions below."]
3615
+
#[repr(C)]
3616
+
#[derive(Debug, Copy, Clone)]
3617
+
pub struct _ESourceRegistryWatcher {
3618
+
pub parent: GObject,
3619
+
pub priv_: *mut ESourceRegistryWatcherPrivate,
3620
+
}
3621
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3622
+
const _: () = {
3623
+
["Size of _ESourceRegistryWatcher"][::std::mem::size_of::<_ESourceRegistryWatcher>() - 32usize];
3624
+
["Alignment of _ESourceRegistryWatcher"]
3625
+
[::std::mem::align_of::<_ESourceRegistryWatcher>() - 8usize];
3626
+
["Offset of field: _ESourceRegistryWatcher::parent"]
3627
+
[::std::mem::offset_of!(_ESourceRegistryWatcher, parent) - 0usize];
3628
+
["Offset of field: _ESourceRegistryWatcher::priv_"]
3629
+
[::std::mem::offset_of!(_ESourceRegistryWatcher, priv_) - 24usize];
3630
+
};
3631
+
unsafe extern "C" {
3632
+
pub fn e_source_registry_watcher_get_type() -> GType;
3633
+
}
3634
+
unsafe extern "C" {
3635
+
pub fn e_source_registry_watcher_new(
3636
+
registry: *mut ESourceRegistry,
3637
+
extension_name: *const gchar,
3638
+
) -> *mut ESourceRegistryWatcher;
3639
+
}
3640
+
unsafe extern "C" {
3641
+
pub fn e_source_registry_watcher_get_registry(
3642
+
watcher: *mut ESourceRegistryWatcher,
3643
+
) -> *mut ESourceRegistry;
3644
+
}
3645
+
unsafe extern "C" {
3646
+
pub fn e_source_registry_watcher_get_extension_name(
3647
+
watcher: *mut ESourceRegistryWatcher,
3648
+
) -> *const gchar;
3649
+
}
3650
+
unsafe extern "C" {
3651
+
pub fn e_source_registry_watcher_reclaim(watcher: *mut ESourceRegistryWatcher);
3652
+
}
3653
+
#[doc = " ESourceResource:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3654
+
pub type ESourceResource = _ESourceResource;
3655
+
#[repr(C)]
3656
+
#[derive(Debug, Copy, Clone)]
3657
+
pub struct _ESourceResourcePrivate {
3658
+
_unused: [u8; 0],
3659
+
}
3660
+
pub type ESourceResourcePrivate = _ESourceResourcePrivate;
3661
+
#[doc = " ESourceResource:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3662
+
#[repr(C)]
3663
+
#[derive(Debug, Copy, Clone)]
3664
+
pub struct _ESourceResource {
3665
+
pub parent: ESourceExtension,
3666
+
pub priv_: *mut ESourceResourcePrivate,
3667
+
}
3668
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3669
+
const _: () = {
3670
+
["Size of _ESourceResource"][::std::mem::size_of::<_ESourceResource>() - 40usize];
3671
+
["Alignment of _ESourceResource"][::std::mem::align_of::<_ESourceResource>() - 8usize];
3672
+
["Offset of field: _ESourceResource::parent"]
3673
+
[::std::mem::offset_of!(_ESourceResource, parent) - 0usize];
3674
+
["Offset of field: _ESourceResource::priv_"]
3675
+
[::std::mem::offset_of!(_ESourceResource, priv_) - 32usize];
3676
+
};
3677
+
unsafe extern "C" {
3678
+
pub fn e_source_resource_get_type() -> GType;
3679
+
}
3680
+
unsafe extern "C" {
3681
+
pub fn e_source_resource_get_identity(extension: *mut ESourceResource) -> *const gchar;
3682
+
}
3683
+
unsafe extern "C" {
3684
+
pub fn e_source_resource_dup_identity(extension: *mut ESourceResource) -> *mut gchar;
3685
+
}
3686
+
unsafe extern "C" {
3687
+
pub fn e_source_resource_set_identity(extension: *mut ESourceResource, identity: *const gchar);
3688
+
}
3689
+
#[doc = " ESourceRevisionGuards:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.8"]
3690
+
pub type ESourceRevisionGuards = _ESourceRevisionGuards;
3691
+
#[repr(C)]
3692
+
#[derive(Debug, Copy, Clone)]
3693
+
pub struct _ESourceRevisionGuardsPrivate {
3694
+
_unused: [u8; 0],
3695
+
}
3696
+
pub type ESourceRevisionGuardsPrivate = _ESourceRevisionGuardsPrivate;
3697
+
#[doc = " ESourceRevisionGuards:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.8"]
3698
+
#[repr(C)]
3699
+
#[derive(Debug, Copy, Clone)]
3700
+
pub struct _ESourceRevisionGuards {
3701
+
pub parent: ESourceExtension,
3702
+
pub priv_: *mut ESourceRevisionGuardsPrivate,
3703
+
}
3704
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3705
+
const _: () = {
3706
+
["Size of _ESourceRevisionGuards"][::std::mem::size_of::<_ESourceRevisionGuards>() - 40usize];
3707
+
["Alignment of _ESourceRevisionGuards"]
3708
+
[::std::mem::align_of::<_ESourceRevisionGuards>() - 8usize];
3709
+
["Offset of field: _ESourceRevisionGuards::parent"]
3710
+
[::std::mem::offset_of!(_ESourceRevisionGuards, parent) - 0usize];
3711
+
["Offset of field: _ESourceRevisionGuards::priv_"]
3712
+
[::std::mem::offset_of!(_ESourceRevisionGuards, priv_) - 32usize];
3713
+
};
3714
+
unsafe extern "C" {
3715
+
pub fn e_source_revision_guards_get_type() -> GType;
3716
+
}
3717
+
unsafe extern "C" {
3718
+
pub fn e_source_revision_guards_get_enabled(extension: *mut ESourceRevisionGuards) -> gboolean;
3719
+
}
3720
+
unsafe extern "C" {
3721
+
pub fn e_source_revision_guards_set_enabled(
3722
+
extension: *mut ESourceRevisionGuards,
3723
+
enabled: gboolean,
3724
+
);
3725
+
}
3726
+
#[doc = " ESourceSecurity:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3727
+
pub type ESourceSecurity = _ESourceSecurity;
3728
+
#[repr(C)]
3729
+
#[derive(Debug, Copy, Clone)]
3730
+
pub struct _ESourceSecurityPrivate {
3731
+
_unused: [u8; 0],
3732
+
}
3733
+
pub type ESourceSecurityPrivate = _ESourceSecurityPrivate;
3734
+
#[doc = " ESourceSecurity:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3735
+
#[repr(C)]
3736
+
#[derive(Debug, Copy, Clone)]
3737
+
pub struct _ESourceSecurity {
3738
+
pub parent: ESourceExtension,
3739
+
pub priv_: *mut ESourceSecurityPrivate,
3740
+
}
3741
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3742
+
const _: () = {
3743
+
["Size of _ESourceSecurity"][::std::mem::size_of::<_ESourceSecurity>() - 40usize];
3744
+
["Alignment of _ESourceSecurity"][::std::mem::align_of::<_ESourceSecurity>() - 8usize];
3745
+
["Offset of field: _ESourceSecurity::parent"]
3746
+
[::std::mem::offset_of!(_ESourceSecurity, parent) - 0usize];
3747
+
["Offset of field: _ESourceSecurity::priv_"]
3748
+
[::std::mem::offset_of!(_ESourceSecurity, priv_) - 32usize];
3749
+
};
3750
+
unsafe extern "C" {
3751
+
pub fn e_source_security_get_type() -> GType;
3752
+
}
3753
+
unsafe extern "C" {
3754
+
pub fn e_source_security_get_method(extension: *mut ESourceSecurity) -> *const gchar;
3755
+
}
3756
+
unsafe extern "C" {
3757
+
pub fn e_source_security_dup_method(extension: *mut ESourceSecurity) -> *mut gchar;
3758
+
}
3759
+
unsafe extern "C" {
3760
+
pub fn e_source_security_set_method(extension: *mut ESourceSecurity, method: *const gchar);
3761
+
}
3762
+
unsafe extern "C" {
3763
+
pub fn e_source_security_get_secure(extension: *mut ESourceSecurity) -> gboolean;
3764
+
}
3765
+
unsafe extern "C" {
3766
+
pub fn e_source_security_set_secure(extension: *mut ESourceSecurity, secure: gboolean);
3767
+
}
3768
+
#[doc = " ESourceSMIME:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3769
+
pub type ESourceSMIME = _ESourceSMIME;
3770
+
#[repr(C)]
3771
+
#[derive(Debug, Copy, Clone)]
3772
+
pub struct _ESourceSMIMEPrivate {
3773
+
_unused: [u8; 0],
3774
+
}
3775
+
pub type ESourceSMIMEPrivate = _ESourceSMIMEPrivate;
3776
+
#[doc = " ESourceSMIME:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3777
+
#[repr(C)]
3778
+
#[derive(Debug, Copy, Clone)]
3779
+
pub struct _ESourceSMIME {
3780
+
pub parent: ESourceExtension,
3781
+
pub priv_: *mut ESourceSMIMEPrivate,
3782
+
}
3783
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3784
+
const _: () = {
3785
+
["Size of _ESourceSMIME"][::std::mem::size_of::<_ESourceSMIME>() - 40usize];
3786
+
["Alignment of _ESourceSMIME"][::std::mem::align_of::<_ESourceSMIME>() - 8usize];
3787
+
["Offset of field: _ESourceSMIME::parent"]
3788
+
[::std::mem::offset_of!(_ESourceSMIME, parent) - 0usize];
3789
+
["Offset of field: _ESourceSMIME::priv_"]
3790
+
[::std::mem::offset_of!(_ESourceSMIME, priv_) - 32usize];
3791
+
};
3792
+
unsafe extern "C" {
3793
+
pub fn e_source_smime_get_type() -> GType;
3794
+
}
3795
+
unsafe extern "C" {
3796
+
pub fn e_source_smime_get_encryption_certificate(extension: *mut ESourceSMIME) -> *const gchar;
3797
+
}
3798
+
unsafe extern "C" {
3799
+
pub fn e_source_smime_dup_encryption_certificate(extension: *mut ESourceSMIME) -> *mut gchar;
3800
+
}
3801
+
unsafe extern "C" {
3802
+
pub fn e_source_smime_set_encryption_certificate(
3803
+
extension: *mut ESourceSMIME,
3804
+
encryption_certificate: *const gchar,
3805
+
);
3806
+
}
3807
+
unsafe extern "C" {
3808
+
pub fn e_source_smime_get_encrypt_by_default(extension: *mut ESourceSMIME) -> gboolean;
3809
+
}
3810
+
unsafe extern "C" {
3811
+
pub fn e_source_smime_set_encrypt_by_default(
3812
+
extension: *mut ESourceSMIME,
3813
+
encrypt_by_default: gboolean,
3814
+
);
3815
+
}
3816
+
unsafe extern "C" {
3817
+
pub fn e_source_smime_get_encrypt_to_self(extension: *mut ESourceSMIME) -> gboolean;
3818
+
}
3819
+
unsafe extern "C" {
3820
+
pub fn e_source_smime_set_encrypt_to_self(
3821
+
extension: *mut ESourceSMIME,
3822
+
encrypt_to_self: gboolean,
3823
+
);
3824
+
}
3825
+
unsafe extern "C" {
3826
+
pub fn e_source_smime_get_signing_algorithm(extension: *mut ESourceSMIME) -> *const gchar;
3827
+
}
3828
+
unsafe extern "C" {
3829
+
pub fn e_source_smime_dup_signing_algorithm(extension: *mut ESourceSMIME) -> *mut gchar;
3830
+
}
3831
+
unsafe extern "C" {
3832
+
pub fn e_source_smime_set_signing_algorithm(
3833
+
extension: *mut ESourceSMIME,
3834
+
signing_algorithm: *const gchar,
3835
+
);
3836
+
}
3837
+
unsafe extern "C" {
3838
+
pub fn e_source_smime_get_signing_certificate(extension: *mut ESourceSMIME) -> *const gchar;
3839
+
}
3840
+
unsafe extern "C" {
3841
+
pub fn e_source_smime_dup_signing_certificate(extension: *mut ESourceSMIME) -> *mut gchar;
3842
+
}
3843
+
unsafe extern "C" {
3844
+
pub fn e_source_smime_set_signing_certificate(
3845
+
extension: *mut ESourceSMIME,
3846
+
signing_certificate: *const gchar,
3847
+
);
3848
+
}
3849
+
unsafe extern "C" {
3850
+
pub fn e_source_smime_get_sign_by_default(extension: *mut ESourceSMIME) -> gboolean;
3851
+
}
3852
+
unsafe extern "C" {
3853
+
pub fn e_source_smime_set_sign_by_default(
3854
+
extension: *mut ESourceSMIME,
3855
+
sign_by_default: gboolean,
3856
+
);
3857
+
}
3858
+
unsafe extern "C" {
3859
+
pub fn e_source_task_list_get_type() -> GType;
3860
+
}
3861
+
#[doc = " ESourceUoa:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.8"]
3862
+
pub type ESourceUoa = _ESourceUoa;
3863
+
#[repr(C)]
3864
+
#[derive(Debug, Copy, Clone)]
3865
+
pub struct _ESourceUoaPrivate {
3866
+
_unused: [u8; 0],
3867
+
}
3868
+
pub type ESourceUoaPrivate = _ESourceUoaPrivate;
3869
+
#[doc = " ESourceUoa:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.8"]
3870
+
#[repr(C)]
3871
+
#[derive(Debug, Copy, Clone)]
3872
+
pub struct _ESourceUoa {
3873
+
pub parent: ESourceExtension,
3874
+
pub priv_: *mut ESourceUoaPrivate,
3875
+
}
3876
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3877
+
const _: () = {
3878
+
["Size of _ESourceUoa"][::std::mem::size_of::<_ESourceUoa>() - 40usize];
3879
+
["Alignment of _ESourceUoa"][::std::mem::align_of::<_ESourceUoa>() - 8usize];
3880
+
["Offset of field: _ESourceUoa::parent"][::std::mem::offset_of!(_ESourceUoa, parent) - 0usize];
3881
+
["Offset of field: _ESourceUoa::priv_"][::std::mem::offset_of!(_ESourceUoa, priv_) - 32usize];
3882
+
};
3883
+
unsafe extern "C" {
3884
+
pub fn e_source_uoa_get_type() -> GType;
3885
+
}
3886
+
unsafe extern "C" {
3887
+
pub fn e_source_uoa_get_account_id(extension: *mut ESourceUoa) -> guint;
3888
+
}
3889
+
unsafe extern "C" {
3890
+
pub fn e_source_uoa_set_account_id(extension: *mut ESourceUoa, account_id: guint);
3891
+
}
3892
+
#[doc = " ESourceWebdav:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3893
+
pub type ESourceWebdav = _ESourceWebdav;
3894
+
#[repr(C)]
3895
+
#[derive(Debug, Copy, Clone)]
3896
+
pub struct _ESourceWebdavPrivate {
3897
+
_unused: [u8; 0],
3898
+
}
3899
+
pub type ESourceWebdavPrivate = _ESourceWebdavPrivate;
3900
+
#[doc = " ESourceWebdav:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.6"]
3901
+
#[repr(C)]
3902
+
#[derive(Debug, Copy, Clone)]
3903
+
pub struct _ESourceWebdav {
3904
+
pub parent: ESourceExtension,
3905
+
pub priv_: *mut ESourceWebdavPrivate,
3906
+
}
3907
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3908
+
const _: () = {
3909
+
["Size of _ESourceWebdav"][::std::mem::size_of::<_ESourceWebdav>() - 40usize];
3910
+
["Alignment of _ESourceWebdav"][::std::mem::align_of::<_ESourceWebdav>() - 8usize];
3911
+
["Offset of field: _ESourceWebdav::parent"]
3912
+
[::std::mem::offset_of!(_ESourceWebdav, parent) - 0usize];
3913
+
["Offset of field: _ESourceWebdav::priv_"]
3914
+
[::std::mem::offset_of!(_ESourceWebdav, priv_) - 32usize];
3915
+
};
3916
+
unsafe extern "C" {
3917
+
pub fn e_source_webdav_get_type() -> GType;
3918
+
}
3919
+
unsafe extern "C" {
3920
+
pub fn e_source_webdav_get_avoid_ifmatch(extension: *mut ESourceWebdav) -> gboolean;
3921
+
}
3922
+
unsafe extern "C" {
3923
+
pub fn e_source_webdav_set_avoid_ifmatch(
3924
+
extension: *mut ESourceWebdav,
3925
+
avoid_ifmatch: gboolean,
3926
+
);
3927
+
}
3928
+
unsafe extern "C" {
3929
+
pub fn e_source_webdav_get_calendar_auto_schedule(extension: *mut ESourceWebdav) -> gboolean;
3930
+
}
3931
+
unsafe extern "C" {
3932
+
pub fn e_source_webdav_set_calendar_auto_schedule(
3933
+
extension: *mut ESourceWebdav,
3934
+
calendar_auto_schedule: gboolean,
3935
+
);
3936
+
}
3937
+
unsafe extern "C" {
3938
+
pub fn e_source_webdav_get_display_name(extension: *mut ESourceWebdav) -> *const gchar;
3939
+
}
3940
+
unsafe extern "C" {
3941
+
pub fn e_source_webdav_dup_display_name(extension: *mut ESourceWebdav) -> *mut gchar;
3942
+
}
3943
+
unsafe extern "C" {
3944
+
pub fn e_source_webdav_set_display_name(
3945
+
extension: *mut ESourceWebdav,
3946
+
display_name: *const gchar,
3947
+
);
3948
+
}
3949
+
unsafe extern "C" {
3950
+
pub fn e_source_webdav_get_color(extension: *mut ESourceWebdav) -> *const gchar;
3951
+
}
3952
+
unsafe extern "C" {
3953
+
pub fn e_source_webdav_dup_color(extension: *mut ESourceWebdav) -> *mut gchar;
3954
+
}
3955
+
unsafe extern "C" {
3956
+
pub fn e_source_webdav_set_color(extension: *mut ESourceWebdav, color: *const gchar);
3957
+
}
3958
+
unsafe extern "C" {
3959
+
pub fn e_source_webdav_get_email_address(extension: *mut ESourceWebdav) -> *const gchar;
3960
+
}
3961
+
unsafe extern "C" {
3962
+
pub fn e_source_webdav_dup_email_address(extension: *mut ESourceWebdav) -> *mut gchar;
3963
+
}
3964
+
unsafe extern "C" {
3965
+
pub fn e_source_webdav_set_email_address(
3966
+
extension: *mut ESourceWebdav,
3967
+
email_address: *const gchar,
3968
+
);
3969
+
}
3970
+
unsafe extern "C" {
3971
+
pub fn e_source_webdav_get_resource_path(extension: *mut ESourceWebdav) -> *const gchar;
3972
+
}
3973
+
unsafe extern "C" {
3974
+
pub fn e_source_webdav_dup_resource_path(extension: *mut ESourceWebdav) -> *mut gchar;
3975
+
}
3976
+
unsafe extern "C" {
3977
+
pub fn e_source_webdav_set_resource_path(
3978
+
extension: *mut ESourceWebdav,
3979
+
resource_path: *const gchar,
3980
+
);
3981
+
}
3982
+
unsafe extern "C" {
3983
+
pub fn e_source_webdav_get_resource_query(extension: *mut ESourceWebdav) -> *const gchar;
3984
+
}
3985
+
unsafe extern "C" {
3986
+
pub fn e_source_webdav_dup_resource_query(extension: *mut ESourceWebdav) -> *mut gchar;
3987
+
}
3988
+
unsafe extern "C" {
3989
+
pub fn e_source_webdav_set_resource_query(
3990
+
extension: *mut ESourceWebdav,
3991
+
resource_query: *const gchar,
3992
+
);
3993
+
}
3994
+
unsafe extern "C" {
3995
+
pub fn e_source_webdav_get_ssl_trust(extension: *mut ESourceWebdav) -> *const gchar;
3996
+
}
3997
+
unsafe extern "C" {
3998
+
pub fn e_source_webdav_dup_ssl_trust(extension: *mut ESourceWebdav) -> *mut gchar;
3999
+
}
4000
+
unsafe extern "C" {
4001
+
pub fn e_source_webdav_set_ssl_trust(extension: *mut ESourceWebdav, ssl_trust: *const gchar);
4002
+
}
4003
+
unsafe extern "C" {
4004
+
pub fn e_source_webdav_dup_uri(extension: *mut ESourceWebdav) -> *mut GUri;
4005
+
}
4006
+
unsafe extern "C" {
4007
+
pub fn e_source_webdav_set_uri(extension: *mut ESourceWebdav, uri: *mut GUri);
4008
+
}
4009
+
unsafe extern "C" {
4010
+
pub fn e_source_webdav_update_ssl_trust(
4011
+
extension: *mut ESourceWebdav,
4012
+
host: *const gchar,
4013
+
cert: *mut GTlsCertificate,
4014
+
response: ETrustPromptResponse,
4015
+
);
4016
+
}
4017
+
unsafe extern "C" {
4018
+
pub fn e_source_webdav_verify_ssl_trust(
4019
+
extension: *mut ESourceWebdav,
4020
+
host: *const gchar,
4021
+
cert: *mut GTlsCertificate,
4022
+
cert_errors: GTlsCertificateFlags,
4023
+
) -> ETrustPromptResponse;
4024
+
}
4025
+
unsafe extern "C" {
4026
+
pub fn e_source_webdav_unset_temporary_ssl_trust(extension: *mut ESourceWebdav);
4027
+
}
4028
+
unsafe extern "C" {
4029
+
pub fn e_source_webdav_get_ssl_trust_response(
4030
+
extension: *mut ESourceWebdav,
4031
+
) -> ETrustPromptResponse;
4032
+
}
4033
+
unsafe extern "C" {
4034
+
pub fn e_source_webdav_set_ssl_trust_response(
4035
+
extension: *mut ESourceWebdav,
4036
+
response: ETrustPromptResponse,
4037
+
);
4038
+
}
4039
+
unsafe extern "C" {
4040
+
pub fn e_source_webdav_get_order(extension: *mut ESourceWebdav) -> guint;
4041
+
}
4042
+
unsafe extern "C" {
4043
+
pub fn e_source_webdav_set_order(extension: *mut ESourceWebdav, order: guint);
4044
+
}
4045
+
unsafe extern "C" {
4046
+
pub fn e_source_webdav_get_timeout(extension: *mut ESourceWebdav) -> guint;
4047
+
}
4048
+
unsafe extern "C" {
4049
+
pub fn e_source_webdav_set_timeout(extension: *mut ESourceWebdav, timeout: guint);
4050
+
}
4051
+
#[doc = " ESourceWebDAVNotes:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.44"]
4052
+
pub type ESourceWebDAVNotes = _ESourceWebDAVNotes;
4053
+
#[repr(C)]
4054
+
#[derive(Debug, Copy, Clone)]
4055
+
pub struct _ESourceWebDAVNotesPrivate {
4056
+
_unused: [u8; 0],
4057
+
}
4058
+
pub type ESourceWebDAVNotesPrivate = _ESourceWebDAVNotesPrivate;
4059
+
#[doc = " ESourceWebDAVNotes:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.44"]
4060
+
#[repr(C)]
4061
+
#[derive(Debug, Copy, Clone)]
4062
+
pub struct _ESourceWebDAVNotes {
4063
+
pub parent: ESourceExtension,
4064
+
pub priv_: *mut ESourceWebDAVNotesPrivate,
4065
+
}
4066
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4067
+
const _: () = {
4068
+
["Size of _ESourceWebDAVNotes"][::std::mem::size_of::<_ESourceWebDAVNotes>() - 40usize];
4069
+
["Alignment of _ESourceWebDAVNotes"][::std::mem::align_of::<_ESourceWebDAVNotes>() - 8usize];
4070
+
["Offset of field: _ESourceWebDAVNotes::parent"]
4071
+
[::std::mem::offset_of!(_ESourceWebDAVNotes, parent) - 0usize];
4072
+
["Offset of field: _ESourceWebDAVNotes::priv_"]
4073
+
[::std::mem::offset_of!(_ESourceWebDAVNotes, priv_) - 32usize];
4074
+
};
4075
+
unsafe extern "C" {
4076
+
pub fn e_source_webdav_notes_get_type() -> GType;
4077
+
}
4078
+
unsafe extern "C" {
4079
+
pub fn e_source_webdav_notes_get_default_ext(
4080
+
extension: *mut ESourceWebDAVNotes,
4081
+
) -> *const gchar;
4082
+
}
4083
+
unsafe extern "C" {
4084
+
pub fn e_source_webdav_notes_dup_default_ext(extension: *mut ESourceWebDAVNotes) -> *mut gchar;
4085
+
}
4086
+
unsafe extern "C" {
4087
+
pub fn e_source_webdav_notes_set_default_ext(
4088
+
extension: *mut ESourceWebDAVNotes,
4089
+
default_ext: *const gchar,
4090
+
);
4091
+
}
4092
+
pub type ESourceWeather = _ESourceWeather;
4093
+
#[repr(C)]
4094
+
#[derive(Debug, Copy, Clone)]
4095
+
pub struct _ESourceWeatherPrivate {
4096
+
_unused: [u8; 0],
4097
+
}
4098
+
pub type ESourceWeatherPrivate = _ESourceWeatherPrivate;
4099
+
#[repr(C)]
4100
+
#[derive(Debug, Copy, Clone)]
4101
+
pub struct _ESourceWeather {
4102
+
pub parent: ESourceExtension,
4103
+
pub priv_: *mut ESourceWeatherPrivate,
4104
+
}
4105
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4106
+
const _: () = {
4107
+
["Size of _ESourceWeather"][::std::mem::size_of::<_ESourceWeather>() - 40usize];
4108
+
["Alignment of _ESourceWeather"][::std::mem::align_of::<_ESourceWeather>() - 8usize];
4109
+
["Offset of field: _ESourceWeather::parent"]
4110
+
[::std::mem::offset_of!(_ESourceWeather, parent) - 0usize];
4111
+
["Offset of field: _ESourceWeather::priv_"]
4112
+
[::std::mem::offset_of!(_ESourceWeather, priv_) - 32usize];
4113
+
};
4114
+
unsafe extern "C" {
4115
+
pub fn e_source_weather_get_type() -> GType;
4116
+
}
4117
+
unsafe extern "C" {
4118
+
pub fn e_source_weather_get_location(extension: *mut ESourceWeather) -> *const gchar;
4119
+
}
4120
+
unsafe extern "C" {
4121
+
pub fn e_source_weather_dup_location(extension: *mut ESourceWeather) -> *mut gchar;
4122
+
}
4123
+
unsafe extern "C" {
4124
+
pub fn e_source_weather_set_location(extension: *mut ESourceWeather, location: *const gchar);
4125
+
}
4126
+
unsafe extern "C" {
4127
+
pub fn e_source_weather_get_units(extension: *mut ESourceWeather) -> ESourceWeatherUnits;
4128
+
}
4129
+
unsafe extern "C" {
4130
+
pub fn e_source_weather_set_units(extension: *mut ESourceWeather, units: ESourceWeatherUnits);
4131
+
}
4132
+
pub type ICalArray = _ICalArray;
4133
+
pub type ICalAttach = _ICalAttach;
4134
+
pub type ICalCompIter = _ICalCompIter;
4135
+
pub type ICalComponent = _ICalComponent;
4136
+
pub type ICalDatetimeperiod = _ICalDatetimeperiod;
4137
+
pub type ICalDuration = _ICalDuration;
4138
+
pub type ICalGeo = _ICalGeo;
4139
+
pub type ICalParameter = _ICalParameter;
4140
+
pub type ICalParser = _ICalParser;
4141
+
pub type ICalPeriod = _ICalPeriod;
4142
+
pub type ICalProperty = _ICalProperty;
4143
+
pub type ICalRecurIterator = _ICalRecurIterator;
4144
+
pub type ICalRecurrence = _ICalRecurrence;
4145
+
pub type ICalReqstat = _ICalReqstat;
4146
+
pub type ICalTime = _ICalTime;
4147
+
pub type ICalTimeSpan = _ICalTimeSpan;
4148
+
pub type ICalTimezone = _ICalTimezone;
4149
+
pub type ICalTrigger = _ICalTrigger;
4150
+
pub type ICalValue = _ICalValue;
4151
+
pub type ICalObject = _ICalObject;
4152
+
#[repr(C)]
4153
+
#[derive(Debug, Copy, Clone)]
4154
+
pub struct _ICalObjectPrivate {
4155
+
_unused: [u8; 0],
4156
+
}
4157
+
pub type ICalObjectPrivate = _ICalObjectPrivate;
4158
+
#[repr(C)]
4159
+
#[derive(Debug, Copy, Clone)]
4160
+
pub struct _ICalObject {
4161
+
pub parent: GObject,
4162
+
pub priv_: *mut ICalObjectPrivate,
4163
+
}
4164
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4165
+
const _: () = {
4166
+
["Size of _ICalObject"][::std::mem::size_of::<_ICalObject>() - 32usize];
4167
+
["Alignment of _ICalObject"][::std::mem::align_of::<_ICalObject>() - 8usize];
4168
+
["Offset of field: _ICalObject::parent"][::std::mem::offset_of!(_ICalObject, parent) - 0usize];
4169
+
["Offset of field: _ICalObject::priv_"][::std::mem::offset_of!(_ICalObject, priv_) - 24usize];
4170
+
};
4171
+
unsafe extern "C" {
4172
+
pub fn i_cal_object_get_type() -> GType;
4173
+
}
4174
+
unsafe extern "C" {
4175
+
pub fn i_cal_object_construct(
4176
+
object_type: GType,
4177
+
native: gpointer,
4178
+
native_destroy_func: GDestroyNotify,
4179
+
is_global_memory: gboolean,
4180
+
owner: *mut GObject,
4181
+
) -> gpointer;
4182
+
}
4183
+
unsafe extern "C" {
4184
+
pub fn i_cal_object_get_native(iobject: *mut ICalObject) -> gpointer;
4185
+
}
4186
+
unsafe extern "C" {
4187
+
pub fn i_cal_object_steal_native(iobject: *mut ICalObject) -> gpointer;
4188
+
}
4189
+
unsafe extern "C" {
4190
+
pub fn i_cal_object_get_is_global_memory(iobject: *mut ICalObject) -> gboolean;
4191
+
}
4192
+
unsafe extern "C" {
4193
+
pub fn i_cal_object_get_native_destroy_func(iobject: *mut ICalObject) -> GDestroyNotify;
4194
+
}
4195
+
unsafe extern "C" {
4196
+
pub fn i_cal_object_set_native_destroy_func(
4197
+
iobject: *mut ICalObject,
4198
+
native_destroy_func: GDestroyNotify,
4199
+
);
4200
+
}
4201
+
unsafe extern "C" {
4202
+
pub fn i_cal_object_set_owner(iobject: *mut ICalObject, owner: *mut GObject);
4203
+
}
4204
+
unsafe extern "C" {
4205
+
pub fn i_cal_object_ref_owner(iobject: *mut ICalObject) -> *mut GObject;
4206
+
}
4207
+
unsafe extern "C" {
4208
+
pub fn i_cal_object_remove_owner(iobject: *mut ICalObject);
4209
+
}
4210
+
unsafe extern "C" {
4211
+
pub fn i_cal_object_add_depender(iobject: *mut ICalObject, depender: *mut GObject);
4212
+
}
4213
+
unsafe extern "C" {
4214
+
pub fn i_cal_object_remove_depender(iobject: *mut ICalObject, depender: *mut GObject);
4215
+
}
4216
+
unsafe extern "C" {
4217
+
pub fn i_cal_object_set_always_destroy(iobject: *mut ICalObject, value: gboolean);
4218
+
}
4219
+
unsafe extern "C" {
4220
+
pub fn i_cal_object_get_always_destroy(iobject: *mut ICalObject) -> gboolean;
4221
+
}
4222
+
unsafe extern "C" {
4223
+
pub fn i_cal_object_free_global_objects();
4224
+
}
4225
+
#[repr(C)]
4226
+
#[derive(Debug, Copy, Clone)]
4227
+
pub struct _ICalArray {
4228
+
pub parent: ICalObject,
4229
+
}
4230
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4231
+
const _: () = {
4232
+
["Size of _ICalArray"][::std::mem::size_of::<_ICalArray>() - 32usize];
4233
+
["Alignment of _ICalArray"][::std::mem::align_of::<_ICalArray>() - 8usize];
4234
+
["Offset of field: _ICalArray::parent"][::std::mem::offset_of!(_ICalArray, parent) - 0usize];
4235
+
};
4236
+
unsafe extern "C" {
4237
+
pub fn i_cal_array_get_type() -> GType;
4238
+
}
4239
+
unsafe extern "C" {
4240
+
pub fn i_cal_array_size(array: *mut ICalArray) -> gint;
4241
+
}
4242
+
unsafe extern "C" {
4243
+
pub fn i_cal_array_copy(array: *mut ICalArray) -> *mut ICalArray;
4244
+
}
4245
+
unsafe extern "C" {
4246
+
pub fn i_cal_array_free(array: *mut ICalArray);
4247
+
}
4248
+
unsafe extern "C" {
4249
+
pub fn i_cal_array_remove_element_at(array: *mut ICalArray, position: gint);
4250
+
}
4251
+
unsafe extern "C" {
4252
+
pub fn i_cal_array_sort(
4253
+
array: *mut ICalArray,
4254
+
compare: ::std::option::Option<
4255
+
unsafe extern "C" fn(
4256
+
arg1: *const ::std::os::raw::c_void,
4257
+
arg2: *const ::std::os::raw::c_void,
4258
+
) -> gint,
4259
+
>,
4260
+
);
4261
+
}
4262
+
#[repr(C)]
4263
+
#[derive(Debug, Copy, Clone)]
4264
+
pub struct _ICalAttach {
4265
+
pub parent: ICalObject,
4266
+
}
4267
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4268
+
const _: () = {
4269
+
["Size of _ICalAttach"][::std::mem::size_of::<_ICalAttach>() - 32usize];
4270
+
["Alignment of _ICalAttach"][::std::mem::align_of::<_ICalAttach>() - 8usize];
4271
+
["Offset of field: _ICalAttach::parent"][::std::mem::offset_of!(_ICalAttach, parent) - 0usize];
4272
+
};
4273
+
unsafe extern "C" {
4274
+
pub fn i_cal_attach_get_type() -> GType;
4275
+
}
4276
+
unsafe extern "C" {
4277
+
pub fn i_cal_attach_new_from_url(url: *const gchar) -> *mut ICalAttach;
4278
+
}
4279
+
unsafe extern "C" {
4280
+
pub fn i_cal_attach_new_from_data(
4281
+
data: *const gchar,
4282
+
free_fn: GFunc,
4283
+
free_fn_data: *mut ::std::os::raw::c_void,
4284
+
) -> *mut ICalAttach;
4285
+
}
4286
+
unsafe extern "C" {
4287
+
pub fn i_cal_attach_new_from_bytes(bytes: *mut GBytes) -> *mut ICalAttach;
4288
+
}
4289
+
unsafe extern "C" {
4290
+
pub fn i_cal_attach_ref(attach: *mut ICalAttach);
4291
+
}
4292
+
unsafe extern "C" {
4293
+
pub fn i_cal_attach_unref(attach: *mut ICalAttach);
4294
+
}
4295
+
unsafe extern "C" {
4296
+
pub fn i_cal_attach_get_is_url(attach: *mut ICalAttach) -> gboolean;
4297
+
}
4298
+
unsafe extern "C" {
4299
+
pub fn i_cal_attach_get_url(attach: *mut ICalAttach) -> *const gchar;
4300
+
}
4301
+
unsafe extern "C" {
4302
+
pub fn i_cal_attach_get_data(attach: *mut ICalAttach) -> *const gchar;
4303
+
}
4304
+
#[repr(C)]
4305
+
#[derive(Debug, Copy, Clone)]
4306
+
pub struct _ICalCompIter {
4307
+
pub parent: ICalObject,
4308
+
}
4309
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4310
+
const _: () = {
4311
+
["Size of _ICalCompIter"][::std::mem::size_of::<_ICalCompIter>() - 32usize];
4312
+
["Alignment of _ICalCompIter"][::std::mem::align_of::<_ICalCompIter>() - 8usize];
4313
+
["Offset of field: _ICalCompIter::parent"]
4314
+
[::std::mem::offset_of!(_ICalCompIter, parent) - 0usize];
4315
+
};
4316
+
unsafe extern "C" {
4317
+
pub fn i_cal_comp_iter_get_type() -> GType;
4318
+
}
4319
+
pub const ICalParameterKind_I_CAL_ANY_PARAMETER: ICalParameterKind = 0;
4320
+
pub const ICalParameterKind_I_CAL_ACTIONPARAM_PARAMETER: ICalParameterKind = 1;
4321
+
pub const ICalParameterKind_I_CAL_ALTREP_PARAMETER: ICalParameterKind = 2;
4322
+
pub const ICalParameterKind_I_CAL_CHARSET_PARAMETER: ICalParameterKind = 3;
4323
+
pub const ICalParameterKind_I_CAL_CN_PARAMETER: ICalParameterKind = 4;
4324
+
pub const ICalParameterKind_I_CAL_CUTYPE_PARAMETER: ICalParameterKind = 5;
4325
+
pub const ICalParameterKind_I_CAL_DELEGATEDFROM_PARAMETER: ICalParameterKind = 6;
4326
+
pub const ICalParameterKind_I_CAL_DELEGATEDTO_PARAMETER: ICalParameterKind = 7;
4327
+
pub const ICalParameterKind_I_CAL_DIR_PARAMETER: ICalParameterKind = 8;
4328
+
pub const ICalParameterKind_I_CAL_DISPLAY_PARAMETER: ICalParameterKind = 46;
4329
+
pub const ICalParameterKind_I_CAL_EMAIL_PARAMETER: ICalParameterKind = 50;
4330
+
pub const ICalParameterKind_I_CAL_ENABLE_PARAMETER: ICalParameterKind = 9;
4331
+
pub const ICalParameterKind_I_CAL_ENCODING_PARAMETER: ICalParameterKind = 10;
4332
+
pub const ICalParameterKind_I_CAL_FBTYPE_PARAMETER: ICalParameterKind = 11;
4333
+
pub const ICalParameterKind_I_CAL_FEATURE_PARAMETER: ICalParameterKind = 48;
4334
+
pub const ICalParameterKind_I_CAL_FILENAME_PARAMETER: ICalParameterKind = 42;
4335
+
pub const ICalParameterKind_I_CAL_FMTTYPE_PARAMETER: ICalParameterKind = 12;
4336
+
pub const ICalParameterKind_I_CAL_IANA_PARAMETER: ICalParameterKind = 33;
4337
+
pub const ICalParameterKind_I_CAL_ID_PARAMETER: ICalParameterKind = 13;
4338
+
pub const ICalParameterKind_I_CAL_LABEL_PARAMETER: ICalParameterKind = 49;
4339
+
pub const ICalParameterKind_I_CAL_LANGUAGE_PARAMETER: ICalParameterKind = 14;
4340
+
pub const ICalParameterKind_I_CAL_LATENCY_PARAMETER: ICalParameterKind = 15;
4341
+
pub const ICalParameterKind_I_CAL_LOCAL_PARAMETER: ICalParameterKind = 16;
4342
+
pub const ICalParameterKind_I_CAL_LOCALIZE_PARAMETER: ICalParameterKind = 17;
4343
+
pub const ICalParameterKind_I_CAL_MANAGEDID_PARAMETER: ICalParameterKind = 40;
4344
+
pub const ICalParameterKind_I_CAL_MEMBER_PARAMETER: ICalParameterKind = 18;
4345
+
pub const ICalParameterKind_I_CAL_MODIFIED_PARAMETER: ICalParameterKind = 44;
4346
+
pub const ICalParameterKind_I_CAL_OPTIONS_PARAMETER: ICalParameterKind = 19;
4347
+
pub const ICalParameterKind_I_CAL_PARTSTAT_PARAMETER: ICalParameterKind = 20;
4348
+
pub const ICalParameterKind_I_CAL_PATCHACTION_PARAMETER: ICalParameterKind = 51;
4349
+
pub const ICalParameterKind_I_CAL_PUBLICCOMMENT_PARAMETER: ICalParameterKind = 37;
4350
+
pub const ICalParameterKind_I_CAL_RANGE_PARAMETER: ICalParameterKind = 21;
4351
+
pub const ICalParameterKind_I_CAL_REASON_PARAMETER: ICalParameterKind = 43;
4352
+
pub const ICalParameterKind_I_CAL_RELATED_PARAMETER: ICalParameterKind = 22;
4353
+
pub const ICalParameterKind_I_CAL_RELTYPE_PARAMETER: ICalParameterKind = 23;
4354
+
pub const ICalParameterKind_I_CAL_REQUIRED_PARAMETER: ICalParameterKind = 43;
4355
+
pub const ICalParameterKind_I_CAL_RESPONSE_PARAMETER: ICalParameterKind = 38;
4356
+
pub const ICalParameterKind_I_CAL_ROLE_PARAMETER: ICalParameterKind = 24;
4357
+
pub const ICalParameterKind_I_CAL_RSVP_PARAMETER: ICalParameterKind = 25;
4358
+
pub const ICalParameterKind_I_CAL_SCHEDULEAGENT_PARAMETER: ICalParameterKind = 34;
4359
+
pub const ICalParameterKind_I_CAL_SCHEDULEFORCESEND_PARAMETER: ICalParameterKind = 35;
4360
+
pub const ICalParameterKind_I_CAL_SCHEDULESTATUS_PARAMETER: ICalParameterKind = 36;
4361
+
pub const ICalParameterKind_I_CAL_SENTBY_PARAMETER: ICalParameterKind = 26;
4362
+
pub const ICalParameterKind_I_CAL_SIZE_PARAMETER: ICalParameterKind = 41;
4363
+
pub const ICalParameterKind_I_CAL_STAYINFORMED_PARAMETER: ICalParameterKind = 39;
4364
+
pub const ICalParameterKind_I_CAL_SUBSTATE_PARAMETER: ICalParameterKind = 45;
4365
+
pub const ICalParameterKind_I_CAL_TZID_PARAMETER: ICalParameterKind = 27;
4366
+
pub const ICalParameterKind_I_CAL_VALUE_PARAMETER: ICalParameterKind = 28;
4367
+
pub const ICalParameterKind_I_CAL_X_PARAMETER: ICalParameterKind = 29;
4368
+
pub const ICalParameterKind_I_CAL_XLICCOMPARETYPE_PARAMETER: ICalParameterKind = 30;
4369
+
pub const ICalParameterKind_I_CAL_XLICERRORTYPE_PARAMETER: ICalParameterKind = 31;
4370
+
pub const ICalParameterKind_I_CAL_NO_PARAMETER: ICalParameterKind = 32;
4371
+
pub type ICalParameterKind = ::std::os::raw::c_uint;
4372
+
pub const ICalParameterAction_I_CAL_ACTIONPARAM_X: ICalParameterAction = 20000;
4373
+
pub const ICalParameterAction_I_CAL_ACTIONPARAM_ASK: ICalParameterAction = 20001;
4374
+
pub const ICalParameterAction_I_CAL_ACTIONPARAM_ABORT: ICalParameterAction = 20002;
4375
+
pub const ICalParameterAction_I_CAL_ACTIONPARAM_NONE: ICalParameterAction = 20099;
4376
+
pub type ICalParameterAction = ::std::os::raw::c_uint;
4377
+
pub const ICalParameterCutype_I_CAL_CUTYPE_X: ICalParameterCutype = 20100;
4378
+
pub const ICalParameterCutype_I_CAL_CUTYPE_INDIVIDUAL: ICalParameterCutype = 20101;
4379
+
pub const ICalParameterCutype_I_CAL_CUTYPE_GROUP: ICalParameterCutype = 20102;
4380
+
pub const ICalParameterCutype_I_CAL_CUTYPE_RESOURCE: ICalParameterCutype = 20103;
4381
+
pub const ICalParameterCutype_I_CAL_CUTYPE_ROOM: ICalParameterCutype = 20104;
4382
+
pub const ICalParameterCutype_I_CAL_CUTYPE_UNKNOWN: ICalParameterCutype = 20105;
4383
+
pub const ICalParameterCutype_I_CAL_CUTYPE_NONE: ICalParameterCutype = 20199;
4384
+
pub type ICalParameterCutype = ::std::os::raw::c_uint;
4385
+
pub const ICalParameterDisplay_I_CAL_DISPLAY_X: ICalParameterDisplay = 22000;
4386
+
pub const ICalParameterDisplay_I_CAL_DISPLAY_BADGE: ICalParameterDisplay = 22001;
4387
+
pub const ICalParameterDisplay_I_CAL_DISPLAY_GRAPHIC: ICalParameterDisplay = 22002;
4388
+
pub const ICalParameterDisplay_I_CAL_DISPLAY_FULLSIZE: ICalParameterDisplay = 22003;
4389
+
pub const ICalParameterDisplay_I_CAL_DISPLAY_THUMBNAIL: ICalParameterDisplay = 22004;
4390
+
pub const ICalParameterDisplay_I_CAL_DISPLAY_NONE: ICalParameterDisplay = 22099;
4391
+
pub type ICalParameterDisplay = ::std::os::raw::c_uint;
4392
+
pub const ICalParameterEnable_I_CAL_ENABLE_X: ICalParameterEnable = 20200;
4393
+
pub const ICalParameterEnable_I_CAL_ENABLE_TRUE: ICalParameterEnable = 20201;
4394
+
pub const ICalParameterEnable_I_CAL_ENABLE_FALSE: ICalParameterEnable = 20202;
4395
+
pub const ICalParameterEnable_I_CAL_ENABLE_NONE: ICalParameterEnable = 20299;
4396
+
pub type ICalParameterEnable = ::std::os::raw::c_uint;
4397
+
pub const ICalParameterEncoding_I_CAL_ENCODING_X: ICalParameterEncoding = 20300;
4398
+
pub const ICalParameterEncoding_I_CAL_ENCODING_8BIT: ICalParameterEncoding = 20301;
4399
+
pub const ICalParameterEncoding_I_CAL_ENCODING_BASE64: ICalParameterEncoding = 20302;
4400
+
pub const ICalParameterEncoding_I_CAL_ENCODING_NONE: ICalParameterEncoding = 20399;
4401
+
pub type ICalParameterEncoding = ::std::os::raw::c_uint;
4402
+
pub const ICalParameterFbtype_I_CAL_FBTYPE_X: ICalParameterFbtype = 20400;
4403
+
pub const ICalParameterFbtype_I_CAL_FBTYPE_FREE: ICalParameterFbtype = 20401;
4404
+
pub const ICalParameterFbtype_I_CAL_FBTYPE_BUSY: ICalParameterFbtype = 20402;
4405
+
pub const ICalParameterFbtype_I_CAL_FBTYPE_BUSYUNAVAILABLE: ICalParameterFbtype = 20403;
4406
+
pub const ICalParameterFbtype_I_CAL_FBTYPE_BUSYTENTATIVE: ICalParameterFbtype = 20404;
4407
+
pub const ICalParameterFbtype_I_CAL_FBTYPE_NONE: ICalParameterFbtype = 20499;
4408
+
pub type ICalParameterFbtype = ::std::os::raw::c_uint;
4409
+
pub const ICalParameterFeature_I_CAL_FEATURE_X: ICalParameterFeature = 22100;
4410
+
pub const ICalParameterFeature_I_CAL_FEATURE_AUDIO: ICalParameterFeature = 22101;
4411
+
pub const ICalParameterFeature_I_CAL_FEATURE_CHAT: ICalParameterFeature = 22102;
4412
+
pub const ICalParameterFeature_I_CAL_FEATURE_FEED: ICalParameterFeature = 22103;
4413
+
pub const ICalParameterFeature_I_CAL_FEATURE_MODERATOR: ICalParameterFeature = 22104;
4414
+
pub const ICalParameterFeature_I_CAL_FEATURE_PHONE: ICalParameterFeature = 22105;
4415
+
pub const ICalParameterFeature_I_CAL_FEATURE_SCREEN: ICalParameterFeature = 22106;
4416
+
pub const ICalParameterFeature_I_CAL_FEATURE_VIDEO: ICalParameterFeature = 22107;
4417
+
pub const ICalParameterFeature_I_CAL_FEATURE_NONE: ICalParameterFeature = 22199;
4418
+
pub type ICalParameterFeature = ::std::os::raw::c_uint;
4419
+
pub const ICalParameterLocal_I_CAL_LOCAL_X: ICalParameterLocal = 20500;
4420
+
pub const ICalParameterLocal_I_CAL_LOCAL_TRUE: ICalParameterLocal = 20501;
4421
+
pub const ICalParameterLocal_I_CAL_LOCAL_FALSE: ICalParameterLocal = 20502;
4422
+
pub const ICalParameterLocal_I_CAL_LOCAL_NONE: ICalParameterLocal = 20599;
4423
+
pub type ICalParameterLocal = ::std::os::raw::c_uint;
4424
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_X: ICalParameterPartstat = 20600;
4425
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_NEEDSACTION: ICalParameterPartstat = 20601;
4426
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_ACCEPTED: ICalParameterPartstat = 20602;
4427
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_DECLINED: ICalParameterPartstat = 20603;
4428
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_TENTATIVE: ICalParameterPartstat = 20604;
4429
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_DELEGATED: ICalParameterPartstat = 20605;
4430
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_COMPLETED: ICalParameterPartstat = 20606;
4431
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_INPROCESS: ICalParameterPartstat = 20607;
4432
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_FAILED: ICalParameterPartstat = 20608;
4433
+
pub const ICalParameterPartstat_I_CAL_PARTSTAT_NONE: ICalParameterPartstat = 20699;
4434
+
pub type ICalParameterPartstat = ::std::os::raw::c_uint;
4435
+
pub const ICalParameterPatchaction_I_CAL_PATCHACTION_X: ICalParameterPatchaction = 22200;
4436
+
pub const ICalParameterPatchaction_I_CAL_PATCHACTION_CREATE: ICalParameterPatchaction = 22201;
4437
+
pub const ICalParameterPatchaction_I_CAL_PATCHACTION_BYNAME: ICalParameterPatchaction = 22202;
4438
+
pub const ICalParameterPatchaction_I_CAL_PATCHACTION_BYVALUE: ICalParameterPatchaction = 22203;
4439
+
pub const ICalParameterPatchaction_I_CAL_PATCHACTION_BYPARAM: ICalParameterPatchaction = 22204;
4440
+
pub const ICalParameterPatchaction_I_CAL_PATCHACTION_NONE: ICalParameterPatchaction = 22299;
4441
+
pub type ICalParameterPatchaction = ::std::os::raw::c_uint;
4442
+
pub const ICalParameterRange_I_CAL_RANGE_X: ICalParameterRange = 20700;
4443
+
pub const ICalParameterRange_I_CAL_RANGE_THISANDPRIOR: ICalParameterRange = 20701;
4444
+
pub const ICalParameterRange_I_CAL_RANGE_THISANDFUTURE: ICalParameterRange = 20702;
4445
+
pub const ICalParameterRange_I_CAL_RANGE_NONE: ICalParameterRange = 20799;
4446
+
pub type ICalParameterRange = ::std::os::raw::c_uint;
4447
+
pub const ICalParameterRelated_I_CAL_RELATED_X: ICalParameterRelated = 20800;
4448
+
pub const ICalParameterRelated_I_CAL_RELATED_START: ICalParameterRelated = 20801;
4449
+
pub const ICalParameterRelated_I_CAL_RELATED_END: ICalParameterRelated = 20802;
4450
+
pub const ICalParameterRelated_I_CAL_RELATED_NONE: ICalParameterRelated = 20899;
4451
+
pub type ICalParameterRelated = ::std::os::raw::c_uint;
4452
+
pub const ICalParameterReltype_I_CAL_RELTYPE_X: ICalParameterReltype = 20900;
4453
+
pub const ICalParameterReltype_I_CAL_RELTYPE_PARENT: ICalParameterReltype = 20901;
4454
+
pub const ICalParameterReltype_I_CAL_RELTYPE_CHILD: ICalParameterReltype = 20902;
4455
+
pub const ICalParameterReltype_I_CAL_RELTYPE_SIBLING: ICalParameterReltype = 20903;
4456
+
pub const ICalParameterReltype_I_CAL_RELTYPE_POLL: ICalParameterReltype = 20904;
4457
+
pub const ICalParameterReltype_I_CAL_RELTYPE_NONE: ICalParameterReltype = 20999;
4458
+
pub type ICalParameterReltype = ::std::os::raw::c_uint;
4459
+
pub const ICalParameterRequired_I_CAL_REQUIRED_X: ICalParameterRequired = 21000;
4460
+
pub const ICalParameterRequired_I_CAL_REQUIRED_TRUE: ICalParameterRequired = 21001;
4461
+
pub const ICalParameterRequired_I_CAL_REQUIRED_FALSE: ICalParameterRequired = 21002;
4462
+
pub const ICalParameterRequired_I_CAL_REQUIRED_NONE: ICalParameterRequired = 21099;
4463
+
pub type ICalParameterRequired = ::std::os::raw::c_uint;
4464
+
pub const ICalParameterRole_I_CAL_ROLE_X: ICalParameterRole = 21100;
4465
+
pub const ICalParameterRole_I_CAL_ROLE_CHAIR: ICalParameterRole = 21101;
4466
+
pub const ICalParameterRole_I_CAL_ROLE_REQPARTICIPANT: ICalParameterRole = 21102;
4467
+
pub const ICalParameterRole_I_CAL_ROLE_OPTPARTICIPANT: ICalParameterRole = 21103;
4468
+
pub const ICalParameterRole_I_CAL_ROLE_NONPARTICIPANT: ICalParameterRole = 21104;
4469
+
pub const ICalParameterRole_I_CAL_ROLE_NONE: ICalParameterRole = 21199;
4470
+
pub type ICalParameterRole = ::std::os::raw::c_uint;
4471
+
pub const ICalParameterRsvp_I_CAL_RSVP_X: ICalParameterRsvp = 21200;
4472
+
pub const ICalParameterRsvp_I_CAL_RSVP_TRUE: ICalParameterRsvp = 21201;
4473
+
pub const ICalParameterRsvp_I_CAL_RSVP_FALSE: ICalParameterRsvp = 21202;
4474
+
pub const ICalParameterRsvp_I_CAL_RSVP_NONE: ICalParameterRsvp = 21299;
4475
+
pub type ICalParameterRsvp = ::std::os::raw::c_uint;
4476
+
pub const ICalParameterScheduleagent_I_CAL_SCHEDULEAGENT_X: ICalParameterScheduleagent = 21300;
4477
+
pub const ICalParameterScheduleagent_I_CAL_SCHEDULEAGENT_SERVER: ICalParameterScheduleagent = 21301;
4478
+
pub const ICalParameterScheduleagent_I_CAL_SCHEDULEAGENT_CLIENT: ICalParameterScheduleagent = 21302;
4479
+
pub const ICalParameterScheduleagent_I_CAL_SCHEDULEAGENT_NONE: ICalParameterScheduleagent = 21399;
4480
+
pub type ICalParameterScheduleagent = ::std::os::raw::c_uint;
4481
+
pub const ICalParameterScheduleforcesend_I_CAL_SCHEDULEFORCESEND_X: ICalParameterScheduleforcesend =
4482
+
21400;
4483
+
pub const ICalParameterScheduleforcesend_I_CAL_SCHEDULEFORCESEND_REQUEST:
4484
+
ICalParameterScheduleforcesend = 21401;
4485
+
pub const ICalParameterScheduleforcesend_I_CAL_SCHEDULEFORCESEND_REPLY:
4486
+
ICalParameterScheduleforcesend = 21402;
4487
+
pub const ICalParameterScheduleforcesend_I_CAL_SCHEDULEFORCESEND_NONE:
4488
+
ICalParameterScheduleforcesend = 21499;
4489
+
pub type ICalParameterScheduleforcesend = ::std::os::raw::c_uint;
4490
+
pub const ICalParameterStayinformed_I_CAL_STAYINFORMED_X: ICalParameterStayinformed = 21500;
4491
+
pub const ICalParameterStayinformed_I_CAL_STAYINFORMED_TRUE: ICalParameterStayinformed = 21501;
4492
+
pub const ICalParameterStayinformed_I_CAL_STAYINFORMED_FALSE: ICalParameterStayinformed = 21502;
4493
+
pub const ICalParameterStayinformed_I_CAL_STAYINFORMED_NONE: ICalParameterStayinformed = 21599;
4494
+
pub type ICalParameterStayinformed = ::std::os::raw::c_uint;
4495
+
pub const ICalParameterSubstate_I_CAL_SUBSTATE_X: ICalParameterSubstate = 21900;
4496
+
pub const ICalParameterSubstate_I_CAL_SUBSTATE_OK: ICalParameterSubstate = 21901;
4497
+
pub const ICalParameterSubstate_I_CAL_SUBSTATE_ERROR: ICalParameterSubstate = 21902;
4498
+
pub const ICalParameterSubstate_I_CAL_SUBSTATE_SUSPENDED: ICalParameterSubstate = 21903;
4499
+
pub const ICalParameterSubstate_I_CAL_SUBSTATE_NONE: ICalParameterSubstate = 21999;
4500
+
pub type ICalParameterSubstate = ::std::os::raw::c_uint;
4501
+
pub const ICalParameterValue_I_CAL_VALUE_X: ICalParameterValue = 21600;
4502
+
pub const ICalParameterValue_I_CAL_VALUE_BINARY: ICalParameterValue = 21601;
4503
+
pub const ICalParameterValue_I_CAL_VALUE_BOOLEAN: ICalParameterValue = 21602;
4504
+
pub const ICalParameterValue_I_CAL_VALUE_DATE: ICalParameterValue = 21603;
4505
+
pub const ICalParameterValue_I_CAL_VALUE_DURATION: ICalParameterValue = 21604;
4506
+
pub const ICalParameterValue_I_CAL_VALUE_FLOAT: ICalParameterValue = 21605;
4507
+
pub const ICalParameterValue_I_CAL_VALUE_INTEGER: ICalParameterValue = 21606;
4508
+
pub const ICalParameterValue_I_CAL_VALUE_PERIOD: ICalParameterValue = 21607;
4509
+
pub const ICalParameterValue_I_CAL_VALUE_RECUR: ICalParameterValue = 21608;
4510
+
pub const ICalParameterValue_I_CAL_VALUE_TEXT: ICalParameterValue = 21609;
4511
+
pub const ICalParameterValue_I_CAL_VALUE_URI: ICalParameterValue = 21610;
4512
+
pub const ICalParameterValue_I_CAL_VALUE_ERROR: ICalParameterValue = 21611;
4513
+
pub const ICalParameterValue_I_CAL_VALUE_DATETIME: ICalParameterValue = 21612;
4514
+
pub const ICalParameterValue_I_CAL_VALUE_UTCOFFSET: ICalParameterValue = 21613;
4515
+
pub const ICalParameterValue_I_CAL_VALUE_CALADDRESS: ICalParameterValue = 21614;
4516
+
pub const ICalParameterValue_I_CAL_VALUE_NONE: ICalParameterValue = 21699;
4517
+
pub type ICalParameterValue = ::std::os::raw::c_uint;
4518
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_X: ICalParameterXliccomparetype =
4519
+
21700;
4520
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_EQUAL: ICalParameterXliccomparetype =
4521
+
21701;
4522
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_NOTEQUAL:
4523
+
ICalParameterXliccomparetype = 21702;
4524
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_LESS: ICalParameterXliccomparetype =
4525
+
21703;
4526
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_GREATER: ICalParameterXliccomparetype =
4527
+
21704;
4528
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_LESSEQUAL:
4529
+
ICalParameterXliccomparetype = 21705;
4530
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_GREATEREQUAL:
4531
+
ICalParameterXliccomparetype = 21706;
4532
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_REGEX: ICalParameterXliccomparetype =
4533
+
21707;
4534
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_ISNULL: ICalParameterXliccomparetype =
4535
+
21708;
4536
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_ISNOTNULL:
4537
+
ICalParameterXliccomparetype = 21709;
4538
+
pub const ICalParameterXliccomparetype_I_CAL_XLICCOMPARETYPE_NONE: ICalParameterXliccomparetype =
4539
+
21799;
4540
+
pub type ICalParameterXliccomparetype = ::std::os::raw::c_uint;
4541
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_X: ICalParameterXlicerrortype = 21800;
4542
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_COMPONENTPARSEERROR:
4543
+
ICalParameterXlicerrortype = 21801;
4544
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_PROPERTYPARSEERROR:
4545
+
ICalParameterXlicerrortype = 21802;
4546
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR:
4547
+
ICalParameterXlicerrortype = 21803;
4548
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR:
4549
+
ICalParameterXlicerrortype = 21804;
4550
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_VALUEPARSEERROR:
4551
+
ICalParameterXlicerrortype = 21805;
4552
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_INVALIDITIP: ICalParameterXlicerrortype =
4553
+
21806;
4554
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_UNKNOWNVCALPROPERROR:
4555
+
ICalParameterXlicerrortype = 21807;
4556
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_MIMEPARSEERROR:
4557
+
ICalParameterXlicerrortype = 21808;
4558
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_VCALPROPPARSEERROR:
4559
+
ICalParameterXlicerrortype = 21809;
4560
+
pub const ICalParameterXlicerrortype_I_CAL_XLICERRORTYPE_NONE: ICalParameterXlicerrortype = 21899;
4561
+
pub type ICalParameterXlicerrortype = ::std::os::raw::c_uint;
4562
+
unsafe extern "C" {
4563
+
pub fn i_cal_parameter_new_actionparam(v: ICalParameterAction) -> *mut ICalParameter;
4564
+
}
4565
+
unsafe extern "C" {
4566
+
pub fn i_cal_parameter_get_actionparam(value: *const ICalParameter) -> ICalParameterAction;
4567
+
}
4568
+
unsafe extern "C" {
4569
+
pub fn i_cal_parameter_set_actionparam(value: *mut ICalParameter, v: ICalParameterAction);
4570
+
}
4571
+
unsafe extern "C" {
4572
+
pub fn i_cal_parameter_new_altrep(v: *const gchar) -> *mut ICalParameter;
4573
+
}
4574
+
unsafe extern "C" {
4575
+
pub fn i_cal_parameter_get_altrep(value: *const ICalParameter) -> *const gchar;
4576
+
}
4577
+
unsafe extern "C" {
4578
+
pub fn i_cal_parameter_set_altrep(value: *mut ICalParameter, v: *const gchar);
4579
+
}
4580
+
unsafe extern "C" {
4581
+
pub fn i_cal_parameter_new_charset(v: *const gchar) -> *mut ICalParameter;
4582
+
}
4583
+
unsafe extern "C" {
4584
+
pub fn i_cal_parameter_get_charset(value: *const ICalParameter) -> *const gchar;
4585
+
}
4586
+
unsafe extern "C" {
4587
+
pub fn i_cal_parameter_set_charset(value: *mut ICalParameter, v: *const gchar);
4588
+
}
4589
+
unsafe extern "C" {
4590
+
pub fn i_cal_parameter_new_cn(v: *const gchar) -> *mut ICalParameter;
4591
+
}
4592
+
unsafe extern "C" {
4593
+
pub fn i_cal_parameter_get_cn(value: *const ICalParameter) -> *const gchar;
4594
+
}
4595
+
unsafe extern "C" {
4596
+
pub fn i_cal_parameter_set_cn(value: *mut ICalParameter, v: *const gchar);
4597
+
}
4598
+
unsafe extern "C" {
4599
+
pub fn i_cal_parameter_new_cutype(v: ICalParameterCutype) -> *mut ICalParameter;
4600
+
}
4601
+
unsafe extern "C" {
4602
+
pub fn i_cal_parameter_get_cutype(value: *const ICalParameter) -> ICalParameterCutype;
4603
+
}
4604
+
unsafe extern "C" {
4605
+
pub fn i_cal_parameter_set_cutype(value: *mut ICalParameter, v: ICalParameterCutype);
4606
+
}
4607
+
unsafe extern "C" {
4608
+
pub fn i_cal_parameter_new_delegatedfrom(v: *const gchar) -> *mut ICalParameter;
4609
+
}
4610
+
unsafe extern "C" {
4611
+
pub fn i_cal_parameter_get_delegatedfrom(value: *const ICalParameter) -> *const gchar;
4612
+
}
4613
+
unsafe extern "C" {
4614
+
pub fn i_cal_parameter_set_delegatedfrom(value: *mut ICalParameter, v: *const gchar);
4615
+
}
4616
+
unsafe extern "C" {
4617
+
pub fn i_cal_parameter_new_delegatedto(v: *const gchar) -> *mut ICalParameter;
4618
+
}
4619
+
unsafe extern "C" {
4620
+
pub fn i_cal_parameter_get_delegatedto(value: *const ICalParameter) -> *const gchar;
4621
+
}
4622
+
unsafe extern "C" {
4623
+
pub fn i_cal_parameter_set_delegatedto(value: *mut ICalParameter, v: *const gchar);
4624
+
}
4625
+
unsafe extern "C" {
4626
+
pub fn i_cal_parameter_new_dir(v: *const gchar) -> *mut ICalParameter;
4627
+
}
4628
+
unsafe extern "C" {
4629
+
pub fn i_cal_parameter_get_dir(value: *const ICalParameter) -> *const gchar;
4630
+
}
4631
+
unsafe extern "C" {
4632
+
pub fn i_cal_parameter_set_dir(value: *mut ICalParameter, v: *const gchar);
4633
+
}
4634
+
unsafe extern "C" {
4635
+
pub fn i_cal_parameter_new_display(value: ICalParameterDisplay) -> *mut ICalParameter;
4636
+
}
4637
+
unsafe extern "C" {
4638
+
pub fn i_cal_parameter_get_display(param: *const ICalParameter) -> ICalParameterDisplay;
4639
+
}
4640
+
unsafe extern "C" {
4641
+
pub fn i_cal_parameter_set_display(param: *mut ICalParameter, value: ICalParameterDisplay);
4642
+
}
4643
+
unsafe extern "C" {
4644
+
pub fn i_cal_parameter_new_email(value: *const gchar) -> *mut ICalParameter;
4645
+
}
4646
+
unsafe extern "C" {
4647
+
pub fn i_cal_parameter_get_email(param: *const ICalParameter) -> *const gchar;
4648
+
}
4649
+
unsafe extern "C" {
4650
+
pub fn i_cal_parameter_set_email(param: *mut ICalParameter, value: *const gchar);
4651
+
}
4652
+
unsafe extern "C" {
4653
+
pub fn i_cal_parameter_new_enable(v: ICalParameterEnable) -> *mut ICalParameter;
4654
+
}
4655
+
unsafe extern "C" {
4656
+
pub fn i_cal_parameter_get_enable(value: *const ICalParameter) -> ICalParameterEnable;
4657
+
}
4658
+
unsafe extern "C" {
4659
+
pub fn i_cal_parameter_set_enable(value: *mut ICalParameter, v: ICalParameterEnable);
4660
+
}
4661
+
unsafe extern "C" {
4662
+
pub fn i_cal_parameter_new_encoding(v: ICalParameterEncoding) -> *mut ICalParameter;
4663
+
}
4664
+
unsafe extern "C" {
4665
+
pub fn i_cal_parameter_get_encoding(value: *const ICalParameter) -> ICalParameterEncoding;
4666
+
}
4667
+
unsafe extern "C" {
4668
+
pub fn i_cal_parameter_set_encoding(value: *mut ICalParameter, v: ICalParameterEncoding);
4669
+
}
4670
+
unsafe extern "C" {
4671
+
pub fn i_cal_parameter_new_fbtype(v: ICalParameterFbtype) -> *mut ICalParameter;
4672
+
}
4673
+
unsafe extern "C" {
4674
+
pub fn i_cal_parameter_get_fbtype(value: *const ICalParameter) -> ICalParameterFbtype;
4675
+
}
4676
+
unsafe extern "C" {
4677
+
pub fn i_cal_parameter_set_fbtype(value: *mut ICalParameter, v: ICalParameterFbtype);
4678
+
}
4679
+
unsafe extern "C" {
4680
+
pub fn i_cal_parameter_new_feature(value: ICalParameterFeature) -> *mut ICalParameter;
4681
+
}
4682
+
unsafe extern "C" {
4683
+
pub fn i_cal_parameter_get_feature(param: *const ICalParameter) -> ICalParameterFeature;
4684
+
}
4685
+
unsafe extern "C" {
4686
+
pub fn i_cal_parameter_set_feature(param: *mut ICalParameter, value: ICalParameterFeature);
4687
+
}
4688
+
unsafe extern "C" {
4689
+
pub fn i_cal_parameter_new_filename(v: *const gchar) -> *mut ICalParameter;
4690
+
}
4691
+
unsafe extern "C" {
4692
+
pub fn i_cal_parameter_get_filename(value: *const ICalParameter) -> *const gchar;
4693
+
}
4694
+
unsafe extern "C" {
4695
+
pub fn i_cal_parameter_set_filename(value: *mut ICalParameter, v: *const gchar);
4696
+
}
4697
+
unsafe extern "C" {
4698
+
pub fn i_cal_parameter_new_fmttype(v: *const gchar) -> *mut ICalParameter;
4699
+
}
4700
+
unsafe extern "C" {
4701
+
pub fn i_cal_parameter_get_fmttype(value: *const ICalParameter) -> *const gchar;
4702
+
}
4703
+
unsafe extern "C" {
4704
+
pub fn i_cal_parameter_set_fmttype(value: *mut ICalParameter, v: *const gchar);
4705
+
}
4706
+
unsafe extern "C" {
4707
+
pub fn i_cal_parameter_new_iana(v: *const gchar) -> *mut ICalParameter;
4708
+
}
4709
+
unsafe extern "C" {
4710
+
pub fn i_cal_parameter_get_iana(value: *const ICalParameter) -> *const gchar;
4711
+
}
4712
+
unsafe extern "C" {
4713
+
pub fn i_cal_parameter_set_iana(value: *mut ICalParameter, v: *const gchar);
4714
+
}
4715
+
unsafe extern "C" {
4716
+
pub fn i_cal_parameter_new_id(v: *const gchar) -> *mut ICalParameter;
4717
+
}
4718
+
unsafe extern "C" {
4719
+
pub fn i_cal_parameter_get_id(value: *const ICalParameter) -> *const gchar;
4720
+
}
4721
+
unsafe extern "C" {
4722
+
pub fn i_cal_parameter_set_id(value: *mut ICalParameter, v: *const gchar);
4723
+
}
4724
+
unsafe extern "C" {
4725
+
pub fn i_cal_parameter_new_label(value: *const gchar) -> *mut ICalParameter;
4726
+
}
4727
+
unsafe extern "C" {
4728
+
pub fn i_cal_parameter_get_label(param: *const ICalParameter) -> *const gchar;
4729
+
}
4730
+
unsafe extern "C" {
4731
+
pub fn i_cal_parameter_set_label(param: *mut ICalParameter, value: *const gchar);
4732
+
}
4733
+
unsafe extern "C" {
4734
+
pub fn i_cal_parameter_new_language(v: *const gchar) -> *mut ICalParameter;
4735
+
}
4736
+
unsafe extern "C" {
4737
+
pub fn i_cal_parameter_get_language(value: *const ICalParameter) -> *const gchar;
4738
+
}
4739
+
unsafe extern "C" {
4740
+
pub fn i_cal_parameter_set_language(value: *mut ICalParameter, v: *const gchar);
4741
+
}
4742
+
unsafe extern "C" {
4743
+
pub fn i_cal_parameter_new_latency(v: *const gchar) -> *mut ICalParameter;
4744
+
}
4745
+
unsafe extern "C" {
4746
+
pub fn i_cal_parameter_get_latency(value: *const ICalParameter) -> *const gchar;
4747
+
}
4748
+
unsafe extern "C" {
4749
+
pub fn i_cal_parameter_set_latency(value: *mut ICalParameter, v: *const gchar);
4750
+
}
4751
+
unsafe extern "C" {
4752
+
pub fn i_cal_parameter_new_local(v: ICalParameterLocal) -> *mut ICalParameter;
4753
+
}
4754
+
unsafe extern "C" {
4755
+
pub fn i_cal_parameter_get_local(value: *const ICalParameter) -> ICalParameterLocal;
4756
+
}
4757
+
unsafe extern "C" {
4758
+
pub fn i_cal_parameter_set_local(value: *mut ICalParameter, v: ICalParameterLocal);
4759
+
}
4760
+
unsafe extern "C" {
4761
+
pub fn i_cal_parameter_new_localize(v: *const gchar) -> *mut ICalParameter;
4762
+
}
4763
+
unsafe extern "C" {
4764
+
pub fn i_cal_parameter_get_localize(value: *const ICalParameter) -> *const gchar;
4765
+
}
4766
+
unsafe extern "C" {
4767
+
pub fn i_cal_parameter_set_localize(value: *mut ICalParameter, v: *const gchar);
4768
+
}
4769
+
unsafe extern "C" {
4770
+
pub fn i_cal_parameter_new_managedid(v: *const gchar) -> *mut ICalParameter;
4771
+
}
4772
+
unsafe extern "C" {
4773
+
pub fn i_cal_parameter_get_managedid(value: *const ICalParameter) -> *const gchar;
4774
+
}
4775
+
unsafe extern "C" {
4776
+
pub fn i_cal_parameter_set_managedid(value: *mut ICalParameter, v: *const gchar);
4777
+
}
4778
+
unsafe extern "C" {
4779
+
pub fn i_cal_parameter_new_member(v: *const gchar) -> *mut ICalParameter;
4780
+
}
4781
+
unsafe extern "C" {
4782
+
pub fn i_cal_parameter_get_member(value: *const ICalParameter) -> *const gchar;
4783
+
}
4784
+
unsafe extern "C" {
4785
+
pub fn i_cal_parameter_set_member(value: *mut ICalParameter, v: *const gchar);
4786
+
}
4787
+
unsafe extern "C" {
4788
+
pub fn i_cal_parameter_new_modified(v: *const gchar) -> *mut ICalParameter;
4789
+
}
4790
+
unsafe extern "C" {
4791
+
pub fn i_cal_parameter_get_modified(value: *const ICalParameter) -> *const gchar;
4792
+
}
4793
+
unsafe extern "C" {
4794
+
pub fn i_cal_parameter_set_modified(value: *mut ICalParameter, v: *const gchar);
4795
+
}
4796
+
unsafe extern "C" {
4797
+
pub fn i_cal_parameter_new_options(v: *const gchar) -> *mut ICalParameter;
4798
+
}
4799
+
unsafe extern "C" {
4800
+
pub fn i_cal_parameter_get_options(value: *const ICalParameter) -> *const gchar;
4801
+
}
4802
+
unsafe extern "C" {
4803
+
pub fn i_cal_parameter_set_options(value: *mut ICalParameter, v: *const gchar);
4804
+
}
4805
+
unsafe extern "C" {
4806
+
pub fn i_cal_parameter_new_partstat(v: ICalParameterPartstat) -> *mut ICalParameter;
4807
+
}
4808
+
unsafe extern "C" {
4809
+
pub fn i_cal_parameter_get_partstat(value: *const ICalParameter) -> ICalParameterPartstat;
4810
+
}
4811
+
unsafe extern "C" {
4812
+
pub fn i_cal_parameter_set_partstat(value: *mut ICalParameter, v: ICalParameterPartstat);
4813
+
}
4814
+
unsafe extern "C" {
4815
+
pub fn i_cal_parameter_new_patchaction(value: ICalParameterPatchaction) -> *mut ICalParameter;
4816
+
}
4817
+
unsafe extern "C" {
4818
+
pub fn i_cal_parameter_get_patchaction(param: *const ICalParameter)
4819
+
-> ICalParameterPatchaction;
4820
+
}
4821
+
unsafe extern "C" {
4822
+
pub fn i_cal_parameter_set_patchaction(
4823
+
param: *mut ICalParameter,
4824
+
value: ICalParameterPatchaction,
4825
+
);
4826
+
}
4827
+
unsafe extern "C" {
4828
+
pub fn i_cal_parameter_new_publiccomment(v: *const gchar) -> *mut ICalParameter;
4829
+
}
4830
+
unsafe extern "C" {
4831
+
pub fn i_cal_parameter_get_publiccomment(value: *const ICalParameter) -> *const gchar;
4832
+
}
4833
+
unsafe extern "C" {
4834
+
pub fn i_cal_parameter_set_publiccomment(value: *mut ICalParameter, v: *const gchar);
4835
+
}
4836
+
unsafe extern "C" {
4837
+
pub fn i_cal_parameter_new_range(v: ICalParameterRange) -> *mut ICalParameter;
4838
+
}
4839
+
unsafe extern "C" {
4840
+
pub fn i_cal_parameter_get_range(value: *const ICalParameter) -> ICalParameterRange;
4841
+
}
4842
+
unsafe extern "C" {
4843
+
pub fn i_cal_parameter_set_range(value: *mut ICalParameter, v: ICalParameterRange);
4844
+
}
4845
+
unsafe extern "C" {
4846
+
pub fn i_cal_parameter_new_reason(v: *const gchar) -> *mut ICalParameter;
4847
+
}
4848
+
unsafe extern "C" {
4849
+
pub fn i_cal_parameter_get_reason(value: *const ICalParameter) -> *const gchar;
4850
+
}
4851
+
unsafe extern "C" {
4852
+
pub fn i_cal_parameter_set_reason(value: *mut ICalParameter, v: *const gchar);
4853
+
}
4854
+
unsafe extern "C" {
4855
+
pub fn i_cal_parameter_new_related(v: ICalParameterRelated) -> *mut ICalParameter;
4856
+
}
4857
+
unsafe extern "C" {
4858
+
pub fn i_cal_parameter_get_related(value: *const ICalParameter) -> ICalParameterRelated;
4859
+
}
4860
+
unsafe extern "C" {
4861
+
pub fn i_cal_parameter_set_related(value: *mut ICalParameter, v: ICalParameterRelated);
4862
+
}
4863
+
unsafe extern "C" {
4864
+
pub fn i_cal_parameter_new_reltype(v: ICalParameterReltype) -> *mut ICalParameter;
4865
+
}
4866
+
unsafe extern "C" {
4867
+
pub fn i_cal_parameter_get_reltype(value: *const ICalParameter) -> ICalParameterReltype;
4868
+
}
4869
+
unsafe extern "C" {
4870
+
pub fn i_cal_parameter_set_reltype(value: *mut ICalParameter, v: ICalParameterReltype);
4871
+
}
4872
+
unsafe extern "C" {
4873
+
pub fn i_cal_parameter_new_required(v: ICalParameterRequired) -> *mut ICalParameter;
4874
+
}
4875
+
unsafe extern "C" {
4876
+
pub fn i_cal_parameter_get_required(value: *const ICalParameter) -> ICalParameterRequired;
4877
+
}
4878
+
unsafe extern "C" {
4879
+
pub fn i_cal_parameter_set_required(value: *mut ICalParameter, v: ICalParameterRequired);
4880
+
}
4881
+
unsafe extern "C" {
4882
+
pub fn i_cal_parameter_new_response(v: gint) -> *mut ICalParameter;
4883
+
}
4884
+
unsafe extern "C" {
4885
+
pub fn i_cal_parameter_get_response(value: *const ICalParameter) -> gint;
4886
+
}
4887
+
unsafe extern "C" {
4888
+
pub fn i_cal_parameter_set_response(value: *mut ICalParameter, v: gint);
4889
+
}
4890
+
unsafe extern "C" {
4891
+
pub fn i_cal_parameter_new_role(v: ICalParameterRole) -> *mut ICalParameter;
4892
+
}
4893
+
unsafe extern "C" {
4894
+
pub fn i_cal_parameter_get_role(value: *const ICalParameter) -> ICalParameterRole;
4895
+
}
4896
+
unsafe extern "C" {
4897
+
pub fn i_cal_parameter_set_role(value: *mut ICalParameter, v: ICalParameterRole);
4898
+
}
4899
+
unsafe extern "C" {
4900
+
pub fn i_cal_parameter_new_rsvp(v: ICalParameterRsvp) -> *mut ICalParameter;
4901
+
}
4902
+
unsafe extern "C" {
4903
+
pub fn i_cal_parameter_get_rsvp(value: *const ICalParameter) -> ICalParameterRsvp;
4904
+
}
4905
+
unsafe extern "C" {
4906
+
pub fn i_cal_parameter_set_rsvp(value: *mut ICalParameter, v: ICalParameterRsvp);
4907
+
}
4908
+
unsafe extern "C" {
4909
+
pub fn i_cal_parameter_new_scheduleagent(v: ICalParameterScheduleagent) -> *mut ICalParameter;
4910
+
}
4911
+
unsafe extern "C" {
4912
+
pub fn i_cal_parameter_get_scheduleagent(
4913
+
value: *const ICalParameter,
4914
+
) -> ICalParameterScheduleagent;
4915
+
}
4916
+
unsafe extern "C" {
4917
+
pub fn i_cal_parameter_set_scheduleagent(
4918
+
value: *mut ICalParameter,
4919
+
v: ICalParameterScheduleagent,
4920
+
);
4921
+
}
4922
+
unsafe extern "C" {
4923
+
pub fn i_cal_parameter_new_scheduleforcesend(
4924
+
v: ICalParameterScheduleforcesend,
4925
+
) -> *mut ICalParameter;
4926
+
}
4927
+
unsafe extern "C" {
4928
+
pub fn i_cal_parameter_get_scheduleforcesend(
4929
+
value: *const ICalParameter,
4930
+
) -> ICalParameterScheduleforcesend;
4931
+
}
4932
+
unsafe extern "C" {
4933
+
pub fn i_cal_parameter_set_scheduleforcesend(
4934
+
value: *mut ICalParameter,
4935
+
v: ICalParameterScheduleforcesend,
4936
+
);
4937
+
}
4938
+
unsafe extern "C" {
4939
+
pub fn i_cal_parameter_new_schedulestatus(v: *const gchar) -> *mut ICalParameter;
4940
+
}
4941
+
unsafe extern "C" {
4942
+
pub fn i_cal_parameter_get_schedulestatus(value: *const ICalParameter) -> *const gchar;
4943
+
}
4944
+
unsafe extern "C" {
4945
+
pub fn i_cal_parameter_set_schedulestatus(value: *mut ICalParameter, v: *const gchar);
4946
+
}
4947
+
unsafe extern "C" {
4948
+
pub fn i_cal_parameter_new_sentby(v: *const gchar) -> *mut ICalParameter;
4949
+
}
4950
+
unsafe extern "C" {
4951
+
pub fn i_cal_parameter_get_sentby(value: *const ICalParameter) -> *const gchar;
4952
+
}
4953
+
unsafe extern "C" {
4954
+
pub fn i_cal_parameter_set_sentby(value: *mut ICalParameter, v: *const gchar);
4955
+
}
4956
+
unsafe extern "C" {
4957
+
pub fn i_cal_parameter_new_size(v: *const gchar) -> *mut ICalParameter;
4958
+
}
4959
+
unsafe extern "C" {
4960
+
pub fn i_cal_parameter_get_size(value: *const ICalParameter) -> *const gchar;
4961
+
}
4962
+
unsafe extern "C" {
4963
+
pub fn i_cal_parameter_set_size(value: *mut ICalParameter, v: *const gchar);
4964
+
}
4965
+
unsafe extern "C" {
4966
+
pub fn i_cal_parameter_new_stayinformed(v: ICalParameterStayinformed) -> *mut ICalParameter;
4967
+
}
4968
+
unsafe extern "C" {
4969
+
pub fn i_cal_parameter_get_stayinformed(
4970
+
value: *const ICalParameter,
4971
+
) -> ICalParameterStayinformed;
4972
+
}
4973
+
unsafe extern "C" {
4974
+
pub fn i_cal_parameter_set_stayinformed(
4975
+
value: *mut ICalParameter,
4976
+
v: ICalParameterStayinformed,
4977
+
);
4978
+
}
4979
+
unsafe extern "C" {
4980
+
pub fn i_cal_parameter_new_substate(v: ICalParameterSubstate) -> *mut ICalParameter;
4981
+
}
4982
+
unsafe extern "C" {
4983
+
pub fn i_cal_parameter_get_substate(value: *const ICalParameter) -> ICalParameterSubstate;
4984
+
}
4985
+
unsafe extern "C" {
4986
+
pub fn i_cal_parameter_set_substate(value: *mut ICalParameter, v: ICalParameterSubstate);
4987
+
}
4988
+
unsafe extern "C" {
4989
+
pub fn i_cal_parameter_new_tzid(v: *const gchar) -> *mut ICalParameter;
4990
+
}
4991
+
unsafe extern "C" {
4992
+
pub fn i_cal_parameter_get_tzid(value: *const ICalParameter) -> *const gchar;
4993
+
}
4994
+
unsafe extern "C" {
4995
+
pub fn i_cal_parameter_set_tzid(value: *mut ICalParameter, v: *const gchar);
4996
+
}
4997
+
unsafe extern "C" {
4998
+
pub fn i_cal_parameter_new_value(v: ICalParameterValue) -> *mut ICalParameter;
4999
+
}
5000
+
unsafe extern "C" {
5001
+
pub fn i_cal_parameter_get_value(value: *const ICalParameter) -> ICalParameterValue;
5002
+
}
5003
+
unsafe extern "C" {
5004
+
pub fn i_cal_parameter_set_value(value: *mut ICalParameter, v: ICalParameterValue);
5005
+
}
5006
+
unsafe extern "C" {
5007
+
pub fn i_cal_parameter_new_x(v: *const gchar) -> *mut ICalParameter;
5008
+
}
5009
+
unsafe extern "C" {
5010
+
pub fn i_cal_parameter_get_x(value: *const ICalParameter) -> *const gchar;
5011
+
}
5012
+
unsafe extern "C" {
5013
+
pub fn i_cal_parameter_set_x(value: *mut ICalParameter, v: *const gchar);
5014
+
}
5015
+
unsafe extern "C" {
5016
+
pub fn i_cal_parameter_new_xliccomparetype(
5017
+
v: ICalParameterXliccomparetype,
5018
+
) -> *mut ICalParameter;
5019
+
}
5020
+
unsafe extern "C" {
5021
+
pub fn i_cal_parameter_get_xliccomparetype(
5022
+
value: *const ICalParameter,
5023
+
) -> ICalParameterXliccomparetype;
5024
+
}
5025
+
unsafe extern "C" {
5026
+
pub fn i_cal_parameter_set_xliccomparetype(
5027
+
value: *mut ICalParameter,
5028
+
v: ICalParameterXliccomparetype,
5029
+
);
5030
+
}
5031
+
unsafe extern "C" {
5032
+
pub fn i_cal_parameter_new_xlicerrortype(v: ICalParameterXlicerrortype) -> *mut ICalParameter;
5033
+
}
5034
+
unsafe extern "C" {
5035
+
pub fn i_cal_parameter_get_xlicerrortype(
5036
+
value: *const ICalParameter,
5037
+
) -> ICalParameterXlicerrortype;
5038
+
}
5039
+
unsafe extern "C" {
5040
+
pub fn i_cal_parameter_set_xlicerrortype(
5041
+
value: *mut ICalParameter,
5042
+
v: ICalParameterXlicerrortype,
5043
+
);
5044
+
}
5045
+
#[repr(C)]
5046
+
#[derive(Debug, Copy, Clone)]
5047
+
pub struct _ICalParameter {
5048
+
pub parent: ICalObject,
5049
+
}
5050
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5051
+
const _: () = {
5052
+
["Size of _ICalParameter"][::std::mem::size_of::<_ICalParameter>() - 32usize];
5053
+
["Alignment of _ICalParameter"][::std::mem::align_of::<_ICalParameter>() - 8usize];
5054
+
["Offset of field: _ICalParameter::parent"]
5055
+
[::std::mem::offset_of!(_ICalParameter, parent) - 0usize];
5056
+
};
5057
+
unsafe extern "C" {
5058
+
pub fn i_cal_parameter_get_type() -> GType;
5059
+
}
5060
+
unsafe extern "C" {
5061
+
pub fn i_cal_parameter_new(v: ICalParameterKind) -> *mut ICalParameter;
5062
+
}
5063
+
unsafe extern "C" {
5064
+
pub fn i_cal_parameter_clone(p: *mut ICalParameter) -> *mut ICalParameter;
5065
+
}
5066
+
unsafe extern "C" {
5067
+
pub fn i_cal_parameter_new_from_string(value: *const gchar) -> *mut ICalParameter;
5068
+
}
5069
+
unsafe extern "C" {
5070
+
pub fn i_cal_parameter_new_from_value_string(
5071
+
kind: ICalParameterKind,
5072
+
value: *const gchar,
5073
+
) -> *mut ICalParameter;
5074
+
}
5075
+
unsafe extern "C" {
5076
+
pub fn i_cal_parameter_free(parameter: *mut ICalParameter);
5077
+
}
5078
+
unsafe extern "C" {
5079
+
pub fn i_cal_parameter_as_ical_string(parameter: *mut ICalParameter) -> *mut gchar;
5080
+
}
5081
+
unsafe extern "C" {
5082
+
pub fn i_cal_parameter_isa(parameter: *mut ICalParameter) -> ICalParameterKind;
5083
+
}
5084
+
unsafe extern "C" {
5085
+
pub fn i_cal_parameter_isa_parameter(param: *mut ICalParameter) -> gint;
5086
+
}
5087
+
unsafe extern "C" {
5088
+
pub fn i_cal_parameter_set_xname(param: *mut ICalParameter, v: *const gchar);
5089
+
}
5090
+
unsafe extern "C" {
5091
+
pub fn i_cal_parameter_get_xname(param: *mut ICalParameter) -> *const gchar;
5092
+
}
5093
+
unsafe extern "C" {
5094
+
pub fn i_cal_parameter_set_xvalue(param: *mut ICalParameter, v: *const gchar);
5095
+
}
5096
+
unsafe extern "C" {
5097
+
pub fn i_cal_parameter_get_xvalue(param: *mut ICalParameter) -> *const gchar;
5098
+
}
5099
+
unsafe extern "C" {
5100
+
pub fn i_cal_parameter_set_iana_name(param: *mut ICalParameter, v: *const gchar);
5101
+
}
5102
+
unsafe extern "C" {
5103
+
pub fn i_cal_parameter_get_iana_name(param: *mut ICalParameter) -> *const gchar;
5104
+
}
5105
+
unsafe extern "C" {
5106
+
pub fn i_cal_parameter_set_iana_value(param: *mut ICalParameter, v: *const gchar);
5107
+
}
5108
+
unsafe extern "C" {
5109
+
pub fn i_cal_parameter_get_iana_value(param: *mut ICalParameter) -> *const gchar;
5110
+
}
5111
+
unsafe extern "C" {
5112
+
pub fn i_cal_parameter_has_same_name(
5113
+
param1: *mut ICalParameter,
5114
+
param2: *mut ICalParameter,
5115
+
) -> gint;
5116
+
}
5117
+
unsafe extern "C" {
5118
+
pub fn i_cal_parameter_kind_to_string(kind: ICalParameterKind) -> *const gchar;
5119
+
}
5120
+
unsafe extern "C" {
5121
+
pub fn i_cal_parameter_kind_from_string(string: *const gchar) -> ICalParameterKind;
5122
+
}
5123
+
unsafe extern "C" {
5124
+
pub fn i_cal_parameter_kind_is_valid(kind: ICalParameterKind) -> gboolean;
5125
+
}
5126
+
pub const ICalComponentKind_I_CAL_NO_COMPONENT: ICalComponentKind = 0;
5127
+
pub const ICalComponentKind_I_CAL_ANY_COMPONENT: ICalComponentKind = 1;
5128
+
pub const ICalComponentKind_I_CAL_XROOT_COMPONENT: ICalComponentKind = 2;
5129
+
pub const ICalComponentKind_I_CAL_XATTACH_COMPONENT: ICalComponentKind = 3;
5130
+
pub const ICalComponentKind_I_CAL_VEVENT_COMPONENT: ICalComponentKind = 4;
5131
+
pub const ICalComponentKind_I_CAL_VTODO_COMPONENT: ICalComponentKind = 5;
5132
+
pub const ICalComponentKind_I_CAL_VJOURNAL_COMPONENT: ICalComponentKind = 6;
5133
+
pub const ICalComponentKind_I_CAL_VCALENDAR_COMPONENT: ICalComponentKind = 7;
5134
+
pub const ICalComponentKind_I_CAL_VAGENDA_COMPONENT: ICalComponentKind = 8;
5135
+
pub const ICalComponentKind_I_CAL_VFREEBUSY_COMPONENT: ICalComponentKind = 9;
5136
+
pub const ICalComponentKind_I_CAL_VALARM_COMPONENT: ICalComponentKind = 10;
5137
+
pub const ICalComponentKind_I_CAL_XAUDIOALARM_COMPONENT: ICalComponentKind = 11;
5138
+
pub const ICalComponentKind_I_CAL_XDISPLAYALARM_COMPONENT: ICalComponentKind = 12;
5139
+
pub const ICalComponentKind_I_CAL_XEMAILALARM_COMPONENT: ICalComponentKind = 13;
5140
+
pub const ICalComponentKind_I_CAL_XPROCEDUREALARM_COMPONENT: ICalComponentKind = 14;
5141
+
pub const ICalComponentKind_I_CAL_VTIMEZONE_COMPONENT: ICalComponentKind = 15;
5142
+
pub const ICalComponentKind_I_CAL_XSTANDARD_COMPONENT: ICalComponentKind = 16;
5143
+
pub const ICalComponentKind_I_CAL_XDAYLIGHT_COMPONENT: ICalComponentKind = 17;
5144
+
pub const ICalComponentKind_I_CAL_X_COMPONENT: ICalComponentKind = 18;
5145
+
pub const ICalComponentKind_I_CAL_VSCHEDULE_COMPONENT: ICalComponentKind = 19;
5146
+
pub const ICalComponentKind_I_CAL_VQUERY_COMPONENT: ICalComponentKind = 20;
5147
+
pub const ICalComponentKind_I_CAL_VREPLY_COMPONENT: ICalComponentKind = 21;
5148
+
pub const ICalComponentKind_I_CAL_VCAR_COMPONENT: ICalComponentKind = 22;
5149
+
pub const ICalComponentKind_I_CAL_VCOMMAND_COMPONENT: ICalComponentKind = 23;
5150
+
pub const ICalComponentKind_I_CAL_XLICINVALID_COMPONENT: ICalComponentKind = 24;
5151
+
pub const ICalComponentKind_I_CAL_XLICMIMEPART_COMPONENT: ICalComponentKind = 25;
5152
+
pub const ICalComponentKind_I_CAL_VAVAILABILITY_COMPONENT: ICalComponentKind = 26;
5153
+
pub const ICalComponentKind_I_CAL_XAVAILABLE_COMPONENT: ICalComponentKind = 27;
5154
+
pub const ICalComponentKind_I_CAL_VPOLL_COMPONENT: ICalComponentKind = 28;
5155
+
pub const ICalComponentKind_I_CAL_VVOTER_COMPONENT: ICalComponentKind = 29;
5156
+
pub const ICalComponentKind_I_CAL_XVOTE_COMPONENT: ICalComponentKind = 30;
5157
+
pub type ICalComponentKind = ::std::os::raw::c_uint;
5158
+
pub const ICalRequestStatus_I_CAL_UNKNOWN_STATUS: ICalRequestStatus = 0;
5159
+
pub const ICalRequestStatus_I_CAL_2_0_SUCCESS_STATUS: ICalRequestStatus = 1;
5160
+
pub const ICalRequestStatus_I_CAL_2_1_FALLBACK_STATUS: ICalRequestStatus = 2;
5161
+
pub const ICalRequestStatus_I_CAL_2_2_IGPROP_STATUS: ICalRequestStatus = 3;
5162
+
pub const ICalRequestStatus_I_CAL_2_3_IGPARAM_STATUS: ICalRequestStatus = 4;
5163
+
pub const ICalRequestStatus_I_CAL_2_4_IGXPROP_STATUS: ICalRequestStatus = 5;
5164
+
pub const ICalRequestStatus_I_CAL_2_5_IGXPARAM_STATUS: ICalRequestStatus = 6;
5165
+
pub const ICalRequestStatus_I_CAL_2_6_IGCOMP_STATUS: ICalRequestStatus = 7;
5166
+
pub const ICalRequestStatus_I_CAL_2_7_FORWARD_STATUS: ICalRequestStatus = 8;
5167
+
pub const ICalRequestStatus_I_CAL_2_8_ONEEVENT_STATUS: ICalRequestStatus = 9;
5168
+
pub const ICalRequestStatus_I_CAL_2_9_TRUNC_STATUS: ICalRequestStatus = 10;
5169
+
pub const ICalRequestStatus_I_CAL_2_10_ONETODO_STATUS: ICalRequestStatus = 11;
5170
+
pub const ICalRequestStatus_I_CAL_2_11_TRUNCRRULE_STATUS: ICalRequestStatus = 12;
5171
+
pub const ICalRequestStatus_I_CAL_3_0_INVPROPNAME_STATUS: ICalRequestStatus = 13;
5172
+
pub const ICalRequestStatus_I_CAL_3_1_INVPROPVAL_STATUS: ICalRequestStatus = 14;
5173
+
pub const ICalRequestStatus_I_CAL_3_2_INVPARAM_STATUS: ICalRequestStatus = 15;
5174
+
pub const ICalRequestStatus_I_CAL_3_3_INVPARAMVAL_STATUS: ICalRequestStatus = 16;
5175
+
pub const ICalRequestStatus_I_CAL_3_4_INVCOMP_STATUS: ICalRequestStatus = 17;
5176
+
pub const ICalRequestStatus_I_CAL_3_5_INVTIME_STATUS: ICalRequestStatus = 18;
5177
+
pub const ICalRequestStatus_I_CAL_3_6_INVRULE_STATUS: ICalRequestStatus = 19;
5178
+
pub const ICalRequestStatus_I_CAL_3_7_INVCU_STATUS: ICalRequestStatus = 20;
5179
+
pub const ICalRequestStatus_I_CAL_3_8_NOAUTH_STATUS: ICalRequestStatus = 21;
5180
+
pub const ICalRequestStatus_I_CAL_3_9_BADVERSION_STATUS: ICalRequestStatus = 22;
5181
+
pub const ICalRequestStatus_I_CAL_3_10_TOOBIG_STATUS: ICalRequestStatus = 23;
5182
+
pub const ICalRequestStatus_I_CAL_3_11_MISSREQCOMP_STATUS: ICalRequestStatus = 24;
5183
+
pub const ICalRequestStatus_I_CAL_3_12_UNKCOMP_STATUS: ICalRequestStatus = 25;
5184
+
pub const ICalRequestStatus_I_CAL_3_13_BADCOMP_STATUS: ICalRequestStatus = 26;
5185
+
pub const ICalRequestStatus_I_CAL_3_14_NOCAP_STATUS: ICalRequestStatus = 27;
5186
+
pub const ICalRequestStatus_I_CAL_3_15_INVCOMMAND: ICalRequestStatus = 28;
5187
+
pub const ICalRequestStatus_I_CAL_4_0_BUSY_STATUS: ICalRequestStatus = 29;
5188
+
pub const ICalRequestStatus_I_CAL_4_1_STORE_ACCESS_DENIED: ICalRequestStatus = 30;
5189
+
pub const ICalRequestStatus_I_CAL_4_2_STORE_FAILED: ICalRequestStatus = 31;
5190
+
pub const ICalRequestStatus_I_CAL_4_3_STORE_NOT_FOUND: ICalRequestStatus = 32;
5191
+
pub const ICalRequestStatus_I_CAL_5_0_MAYBE_STATUS: ICalRequestStatus = 33;
5192
+
pub const ICalRequestStatus_I_CAL_5_1_UNAVAIL_STATUS: ICalRequestStatus = 34;
5193
+
pub const ICalRequestStatus_I_CAL_5_2_NOSERVICE_STATUS: ICalRequestStatus = 35;
5194
+
pub const ICalRequestStatus_I_CAL_5_3_NOSCHED_STATUS: ICalRequestStatus = 36;
5195
+
pub const ICalRequestStatus_I_CAL_6_1_CONTAINER_NOT_FOUND: ICalRequestStatus = 37;
5196
+
pub const ICalRequestStatus_I_CAL_9_0_UNRECOGNIZED_COMMAND: ICalRequestStatus = 38;
5197
+
pub type ICalRequestStatus = ::std::os::raw::c_uint;
5198
+
unsafe extern "C" {
5199
+
pub fn i_cal_request_status_desc(stat: ICalRequestStatus) -> *const gchar;
5200
+
}
5201
+
unsafe extern "C" {
5202
+
pub fn i_cal_request_status_major(stat: ICalRequestStatus) -> gshort;
5203
+
}
5204
+
unsafe extern "C" {
5205
+
pub fn i_cal_request_status_minor(stat: ICalRequestStatus) -> gshort;
5206
+
}
5207
+
unsafe extern "C" {
5208
+
pub fn i_cal_request_status_from_num(major: gshort, minor: gshort) -> ICalRequestStatus;
5209
+
}
5210
+
unsafe extern "C" {
5211
+
pub fn i_cal_request_status_code(stat: ICalRequestStatus) -> *mut gchar;
5212
+
}
5213
+
pub const ICalValueKind_I_CAL_ANY_VALUE: ICalValueKind = 5000;
5214
+
pub const ICalValueKind_I_CAL_ACTION_VALUE: ICalValueKind = 5027;
5215
+
pub const ICalValueKind_I_CAL_ATTACH_VALUE: ICalValueKind = 5003;
5216
+
pub const ICalValueKind_I_CAL_BINARY_VALUE: ICalValueKind = 5011;
5217
+
pub const ICalValueKind_I_CAL_BOOLEAN_VALUE: ICalValueKind = 5021;
5218
+
pub const ICalValueKind_I_CAL_BUSYTYPE_VALUE: ICalValueKind = 5032;
5219
+
pub const ICalValueKind_I_CAL_CALADDRESS_VALUE: ICalValueKind = 5023;
5220
+
pub const ICalValueKind_I_CAL_CARLEVEL_VALUE: ICalValueKind = 5016;
5221
+
pub const ICalValueKind_I_CAL_CLASS_VALUE: ICalValueKind = 5019;
5222
+
pub const ICalValueKind_I_CAL_CMD_VALUE: ICalValueKind = 5010;
5223
+
pub const ICalValueKind_I_CAL_DATE_VALUE: ICalValueKind = 5002;
5224
+
pub const ICalValueKind_I_CAL_DATETIME_VALUE: ICalValueKind = 5028;
5225
+
pub const ICalValueKind_I_CAL_DATETIMEDATE_VALUE: ICalValueKind = 5036;
5226
+
pub const ICalValueKind_I_CAL_DATETIMEPERIOD_VALUE: ICalValueKind = 5015;
5227
+
pub const ICalValueKind_I_CAL_DURATION_VALUE: ICalValueKind = 5020;
5228
+
pub const ICalValueKind_I_CAL_FLOAT_VALUE: ICalValueKind = 5013;
5229
+
pub const ICalValueKind_I_CAL_GEO_VALUE: ICalValueKind = 5004;
5230
+
pub const ICalValueKind_I_CAL_INTEGER_VALUE: ICalValueKind = 5017;
5231
+
pub const ICalValueKind_I_CAL_METHOD_VALUE: ICalValueKind = 5030;
5232
+
pub const ICalValueKind_I_CAL_PERIOD_VALUE: ICalValueKind = 5014;
5233
+
pub const ICalValueKind_I_CAL_POLLCOMPLETION_VALUE: ICalValueKind = 5034;
5234
+
pub const ICalValueKind_I_CAL_POLLMODE_VALUE: ICalValueKind = 5033;
5235
+
pub const ICalValueKind_I_CAL_QUERY_VALUE: ICalValueKind = 5001;
5236
+
pub const ICalValueKind_I_CAL_QUERYLEVEL_VALUE: ICalValueKind = 5012;
5237
+
pub const ICalValueKind_I_CAL_RECUR_VALUE: ICalValueKind = 5026;
5238
+
pub const ICalValueKind_I_CAL_REQUESTSTATUS_VALUE: ICalValueKind = 5009;
5239
+
pub const ICalValueKind_I_CAL_STATUS_VALUE: ICalValueKind = 5005;
5240
+
pub const ICalValueKind_I_CAL_STRING_VALUE: ICalValueKind = 5007;
5241
+
pub const ICalValueKind_I_CAL_TASKMODE_VALUE: ICalValueKind = 5035;
5242
+
pub const ICalValueKind_I_CAL_TEXT_VALUE: ICalValueKind = 5008;
5243
+
pub const ICalValueKind_I_CAL_TRANSP_VALUE: ICalValueKind = 5006;
5244
+
pub const ICalValueKind_I_CAL_TRIGGER_VALUE: ICalValueKind = 5024;
5245
+
pub const ICalValueKind_I_CAL_URI_VALUE: ICalValueKind = 5018;
5246
+
pub const ICalValueKind_I_CAL_UTCOFFSET_VALUE: ICalValueKind = 5029;
5247
+
pub const ICalValueKind_I_CAL_X_VALUE: ICalValueKind = 5022;
5248
+
pub const ICalValueKind_I_CAL_XLICCLASS_VALUE: ICalValueKind = 5025;
5249
+
pub const ICalValueKind_I_CAL_NO_VALUE: ICalValueKind = 5031;
5250
+
pub type ICalValueKind = ::std::os::raw::c_uint;
5251
+
pub const ICalPropertyAction_I_CAL_ACTION_X: ICalPropertyAction = 10000;
5252
+
pub const ICalPropertyAction_I_CAL_ACTION_AUDIO: ICalPropertyAction = 10001;
5253
+
pub const ICalPropertyAction_I_CAL_ACTION_DISPLAY: ICalPropertyAction = 10002;
5254
+
pub const ICalPropertyAction_I_CAL_ACTION_EMAIL: ICalPropertyAction = 10003;
5255
+
pub const ICalPropertyAction_I_CAL_ACTION_PROCEDURE: ICalPropertyAction = 10004;
5256
+
pub const ICalPropertyAction_I_CAL_ACTION_NONE: ICalPropertyAction = 10099;
5257
+
pub type ICalPropertyAction = ::std::os::raw::c_uint;
5258
+
pub const ICalPropertyBusytype_I_CAL_BUSYTYPE_X: ICalPropertyBusytype = 10100;
5259
+
pub const ICalPropertyBusytype_I_CAL_BUSYTYPE_BUSY: ICalPropertyBusytype = 10101;
5260
+
pub const ICalPropertyBusytype_I_CAL_BUSYTYPE_BUSYUNAVAILABLE: ICalPropertyBusytype = 10102;
5261
+
pub const ICalPropertyBusytype_I_CAL_BUSYTYPE_BUSYTENTATIVE: ICalPropertyBusytype = 10103;
5262
+
pub const ICalPropertyBusytype_I_CAL_BUSYTYPE_NONE: ICalPropertyBusytype = 10199;
5263
+
pub type ICalPropertyBusytype = ::std::os::raw::c_uint;
5264
+
pub const ICalPropertyCarlevel_I_CAL_CARLEVEL_X: ICalPropertyCarlevel = 10200;
5265
+
pub const ICalPropertyCarlevel_I_CAL_CARLEVEL_CARNONE: ICalPropertyCarlevel = 10201;
5266
+
pub const ICalPropertyCarlevel_I_CAL_CARLEVEL_CARMIN: ICalPropertyCarlevel = 10202;
5267
+
pub const ICalPropertyCarlevel_I_CAL_CARLEVEL_CARFULL1: ICalPropertyCarlevel = 10203;
5268
+
pub const ICalPropertyCarlevel_I_CAL_CARLEVEL_NONE: ICalPropertyCarlevel = 10299;
5269
+
pub type ICalPropertyCarlevel = ::std::os::raw::c_uint;
5270
+
pub const ICalProperty_Class_I_CAL_CLASS_X: ICalProperty_Class = 10300;
5271
+
pub const ICalProperty_Class_I_CAL_CLASS_PUBLIC: ICalProperty_Class = 10301;
5272
+
pub const ICalProperty_Class_I_CAL_CLASS_PRIVATE: ICalProperty_Class = 10302;
5273
+
pub const ICalProperty_Class_I_CAL_CLASS_CONFIDENTIAL: ICalProperty_Class = 10303;
5274
+
pub const ICalProperty_Class_I_CAL_CLASS_NONE: ICalProperty_Class = 10399;
5275
+
pub type ICalProperty_Class = ::std::os::raw::c_uint;
5276
+
pub const ICalPropertyCmd_I_CAL_CMD_X: ICalPropertyCmd = 10400;
5277
+
pub const ICalPropertyCmd_I_CAL_CMD_ABORT: ICalPropertyCmd = 10401;
5278
+
pub const ICalPropertyCmd_I_CAL_CMD_CONTINUE: ICalPropertyCmd = 10402;
5279
+
pub const ICalPropertyCmd_I_CAL_CMD_CREATE: ICalPropertyCmd = 10403;
5280
+
pub const ICalPropertyCmd_I_CAL_CMD_DELETE: ICalPropertyCmd = 10404;
5281
+
pub const ICalPropertyCmd_I_CAL_CMD_GENERATEUID: ICalPropertyCmd = 10405;
5282
+
pub const ICalPropertyCmd_I_CAL_CMD_GETCAPABILITY: ICalPropertyCmd = 10406;
5283
+
pub const ICalPropertyCmd_I_CAL_CMD_IDENTIFY: ICalPropertyCmd = 10407;
5284
+
pub const ICalPropertyCmd_I_CAL_CMD_MODIFY: ICalPropertyCmd = 10408;
5285
+
pub const ICalPropertyCmd_I_CAL_CMD_MOVE: ICalPropertyCmd = 10409;
5286
+
pub const ICalPropertyCmd_I_CAL_CMD_REPLY: ICalPropertyCmd = 10410;
5287
+
pub const ICalPropertyCmd_I_CAL_CMD_SEARCH: ICalPropertyCmd = 10411;
5288
+
pub const ICalPropertyCmd_I_CAL_CMD_SETLOCALE: ICalPropertyCmd = 10412;
5289
+
pub const ICalPropertyCmd_I_CAL_CMD_NONE: ICalPropertyCmd = 10499;
5290
+
pub type ICalPropertyCmd = ::std::os::raw::c_uint;
5291
+
pub const ICalPropertyMethod_I_CAL_METHOD_X: ICalPropertyMethod = 10500;
5292
+
pub const ICalPropertyMethod_I_CAL_METHOD_PUBLISH: ICalPropertyMethod = 10501;
5293
+
pub const ICalPropertyMethod_I_CAL_METHOD_REQUEST: ICalPropertyMethod = 10502;
5294
+
pub const ICalPropertyMethod_I_CAL_METHOD_REPLY: ICalPropertyMethod = 10503;
5295
+
pub const ICalPropertyMethod_I_CAL_METHOD_ADD: ICalPropertyMethod = 10504;
5296
+
pub const ICalPropertyMethod_I_CAL_METHOD_CANCEL: ICalPropertyMethod = 10505;
5297
+
pub const ICalPropertyMethod_I_CAL_METHOD_REFRESH: ICalPropertyMethod = 10506;
5298
+
pub const ICalPropertyMethod_I_CAL_METHOD_COUNTER: ICalPropertyMethod = 10507;
5299
+
pub const ICalPropertyMethod_I_CAL_METHOD_DECLINECOUNTER: ICalPropertyMethod = 10508;
5300
+
pub const ICalPropertyMethod_I_CAL_METHOD_CREATE: ICalPropertyMethod = 10509;
5301
+
pub const ICalPropertyMethod_I_CAL_METHOD_READ: ICalPropertyMethod = 10510;
5302
+
pub const ICalPropertyMethod_I_CAL_METHOD_RESPONSE: ICalPropertyMethod = 10511;
5303
+
pub const ICalPropertyMethod_I_CAL_METHOD_MOVE: ICalPropertyMethod = 10512;
5304
+
pub const ICalPropertyMethod_I_CAL_METHOD_MODIFY: ICalPropertyMethod = 10513;
5305
+
pub const ICalPropertyMethod_I_CAL_METHOD_GENERATEUID: ICalPropertyMethod = 10514;
5306
+
pub const ICalPropertyMethod_I_CAL_METHOD_DELETE: ICalPropertyMethod = 10515;
5307
+
pub const ICalPropertyMethod_I_CAL_METHOD_NONE: ICalPropertyMethod = 10599;
5308
+
pub type ICalPropertyMethod = ::std::os::raw::c_uint;
5309
+
pub const ICalPropertyPollcompletion_I_CAL_POLLCOMPLETION_X: ICalPropertyPollcompletion = 10600;
5310
+
pub const ICalPropertyPollcompletion_I_CAL_POLLCOMPLETION_SERVER: ICalPropertyPollcompletion =
5311
+
10601;
5312
+
pub const ICalPropertyPollcompletion_I_CAL_POLLCOMPLETION_SERVERSUBMIT: ICalPropertyPollcompletion =
5313
+
10602;
5314
+
pub const ICalPropertyPollcompletion_I_CAL_POLLCOMPLETION_SERVERCHOICE: ICalPropertyPollcompletion =
5315
+
10603;
5316
+
pub const ICalPropertyPollcompletion_I_CAL_POLLCOMPLETION_CLIENT: ICalPropertyPollcompletion =
5317
+
10604;
5318
+
pub const ICalPropertyPollcompletion_I_CAL_POLLCOMPLETION_NONE: ICalPropertyPollcompletion = 10699;
5319
+
pub type ICalPropertyPollcompletion = ::std::os::raw::c_uint;
5320
+
pub const ICalPropertyPollmode_I_CAL_POLLMODE_X: ICalPropertyPollmode = 10700;
5321
+
pub const ICalPropertyPollmode_I_CAL_POLLMODE_BASIC: ICalPropertyPollmode = 10701;
5322
+
pub const ICalPropertyPollmode_I_CAL_POLLMODE_NONE: ICalPropertyPollmode = 10799;
5323
+
pub type ICalPropertyPollmode = ::std::os::raw::c_uint;
5324
+
pub const ICalPropertyQuerylevel_I_CAL_QUERYLEVEL_X: ICalPropertyQuerylevel = 10800;
5325
+
pub const ICalPropertyQuerylevel_I_CAL_QUERYLEVEL_CALQL1: ICalPropertyQuerylevel = 10801;
5326
+
pub const ICalPropertyQuerylevel_I_CAL_QUERYLEVEL_CALQLNONE: ICalPropertyQuerylevel = 10802;
5327
+
pub const ICalPropertyQuerylevel_I_CAL_QUERYLEVEL_NONE: ICalPropertyQuerylevel = 10899;
5328
+
pub type ICalPropertyQuerylevel = ::std::os::raw::c_uint;
5329
+
pub const ICalPropertyStatus_I_CAL_STATUS_X: ICalPropertyStatus = 10900;
5330
+
pub const ICalPropertyStatus_I_CAL_STATUS_TENTATIVE: ICalPropertyStatus = 10901;
5331
+
pub const ICalPropertyStatus_I_CAL_STATUS_CONFIRMED: ICalPropertyStatus = 10902;
5332
+
pub const ICalPropertyStatus_I_CAL_STATUS_COMPLETED: ICalPropertyStatus = 10903;
5333
+
pub const ICalPropertyStatus_I_CAL_STATUS_NEEDSACTION: ICalPropertyStatus = 10904;
5334
+
pub const ICalPropertyStatus_I_CAL_STATUS_CANCELLED: ICalPropertyStatus = 10905;
5335
+
pub const ICalPropertyStatus_I_CAL_STATUS_INPROCESS: ICalPropertyStatus = 10906;
5336
+
pub const ICalPropertyStatus_I_CAL_STATUS_DRAFT: ICalPropertyStatus = 10907;
5337
+
pub const ICalPropertyStatus_I_CAL_STATUS_FINAL: ICalPropertyStatus = 10908;
5338
+
pub const ICalPropertyStatus_I_CAL_STATUS_SUBMITTED: ICalPropertyStatus = 10909;
5339
+
pub const ICalPropertyStatus_I_CAL_STATUS_PENDING: ICalPropertyStatus = 10910;
5340
+
pub const ICalPropertyStatus_I_CAL_STATUS_FAILED: ICalPropertyStatus = 10911;
5341
+
pub const ICalPropertyStatus_I_CAL_STATUS_DELETED: ICalPropertyStatus = 10912;
5342
+
pub const ICalPropertyStatus_I_CAL_STATUS_NONE: ICalPropertyStatus = 10999;
5343
+
pub type ICalPropertyStatus = ::std::os::raw::c_uint;
5344
+
pub const ICalPropertyTaskmode_I_CAL_TASKMODE_X: ICalPropertyTaskmode = 11200;
5345
+
pub const ICalPropertyTaskmode_I_CAL_TASKMODE_AUTOMATICCOMPLETION: ICalPropertyTaskmode = 11201;
5346
+
pub const ICalPropertyTaskmode_I_CAL_TASKMODE_AUTOMATICFAILURE: ICalPropertyTaskmode = 11202;
5347
+
pub const ICalPropertyTaskmode_I_CAL_TASKMODE_AUTOMATICSTATUS: ICalPropertyTaskmode = 11203;
5348
+
pub const ICalPropertyTaskmode_I_CAL_TASKMODE_NONE: ICalPropertyTaskmode = 11299;
5349
+
pub type ICalPropertyTaskmode = ::std::os::raw::c_uint;
5350
+
pub const ICalPropertyTransp_I_CAL_TRANSP_X: ICalPropertyTransp = 11000;
5351
+
pub const ICalPropertyTransp_I_CAL_TRANSP_OPAQUE: ICalPropertyTransp = 11001;
5352
+
pub const ICalPropertyTransp_I_CAL_TRANSP_OPAQUENOCONFLICT: ICalPropertyTransp = 11002;
5353
+
pub const ICalPropertyTransp_I_CAL_TRANSP_TRANSPARENT: ICalPropertyTransp = 11003;
5354
+
pub const ICalPropertyTransp_I_CAL_TRANSP_TRANSPARENTNOCONFLICT: ICalPropertyTransp = 11004;
5355
+
pub const ICalPropertyTransp_I_CAL_TRANSP_NONE: ICalPropertyTransp = 11099;
5356
+
pub type ICalPropertyTransp = ::std::os::raw::c_uint;
5357
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_X: ICalPropertyXlicclass = 11100;
5358
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_PUBLISHNEW: ICalPropertyXlicclass = 11101;
5359
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_PUBLISHUPDATE: ICalPropertyXlicclass = 11102;
5360
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_PUBLISHFREEBUSY: ICalPropertyXlicclass = 11103;
5361
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REQUESTNEW: ICalPropertyXlicclass = 11104;
5362
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REQUESTUPDATE: ICalPropertyXlicclass = 11105;
5363
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REQUESTRESCHEDULE: ICalPropertyXlicclass = 11106;
5364
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REQUESTDELEGATE: ICalPropertyXlicclass = 11107;
5365
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REQUESTNEWORGANIZER: ICalPropertyXlicclass = 11108;
5366
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REQUESTFORWARD: ICalPropertyXlicclass = 11109;
5367
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REQUESTSTATUS: ICalPropertyXlicclass = 11110;
5368
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REQUESTFREEBUSY: ICalPropertyXlicclass = 11111;
5369
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REPLYACCEPT: ICalPropertyXlicclass = 11112;
5370
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REPLYDECLINE: ICalPropertyXlicclass = 11113;
5371
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REPLYDELEGATE: ICalPropertyXlicclass = 11114;
5372
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REPLYCRASHERACCEPT: ICalPropertyXlicclass = 11115;
5373
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REPLYCRASHERDECLINE: ICalPropertyXlicclass = 11116;
5374
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_ADDINSTANCE: ICalPropertyXlicclass = 11117;
5375
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_CANCELEVENT: ICalPropertyXlicclass = 11118;
5376
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_CANCELINSTANCE: ICalPropertyXlicclass = 11119;
5377
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_CANCELALL: ICalPropertyXlicclass = 11120;
5378
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_REFRESH: ICalPropertyXlicclass = 11121;
5379
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_COUNTER: ICalPropertyXlicclass = 11122;
5380
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_DECLINECOUNTER: ICalPropertyXlicclass = 11123;
5381
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_MALFORMED: ICalPropertyXlicclass = 11124;
5382
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_OBSOLETE: ICalPropertyXlicclass = 11125;
5383
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_MISSEQUENCED: ICalPropertyXlicclass = 11126;
5384
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_UNKNOWN: ICalPropertyXlicclass = 11127;
5385
+
pub const ICalPropertyXlicclass_I_CAL_XLICCLASS_NONE: ICalPropertyXlicclass = 11199;
5386
+
pub type ICalPropertyXlicclass = ::std::os::raw::c_uint;
5387
+
unsafe extern "C" {
5388
+
pub fn i_cal_value_set_x(value: *mut ICalValue, v: *const gchar);
5389
+
}
5390
+
unsafe extern "C" {
5391
+
pub fn i_cal_value_new_x(v: *const gchar) -> *mut ICalValue;
5392
+
}
5393
+
unsafe extern "C" {
5394
+
pub fn i_cal_value_get_x(value: *mut ICalValue) -> *const gchar;
5395
+
}
5396
+
unsafe extern "C" {
5397
+
pub fn i_cal_value_set_recur(value: *mut ICalValue, v: *mut ICalRecurrence);
5398
+
}
5399
+
unsafe extern "C" {
5400
+
pub fn i_cal_value_new_recur(v: *mut ICalRecurrence) -> *mut ICalValue;
5401
+
}
5402
+
unsafe extern "C" {
5403
+
pub fn i_cal_value_get_recur(value: *mut ICalValue) -> *mut ICalRecurrence;
5404
+
}
5405
+
unsafe extern "C" {
5406
+
pub fn i_cal_value_set_trigger(value: *mut ICalValue, v: *mut ICalTrigger);
5407
+
}
5408
+
unsafe extern "C" {
5409
+
pub fn i_cal_value_new_trigger(v: *mut ICalTrigger) -> *mut ICalValue;
5410
+
}
5411
+
unsafe extern "C" {
5412
+
pub fn i_cal_value_get_trigger(value: *mut ICalValue) -> *mut ICalTrigger;
5413
+
}
5414
+
unsafe extern "C" {
5415
+
pub fn i_cal_value_set_datetime(value: *mut ICalValue, v: *mut ICalTime);
5416
+
}
5417
+
unsafe extern "C" {
5418
+
pub fn i_cal_value_new_datetime(v: *mut ICalTime) -> *mut ICalValue;
5419
+
}
5420
+
unsafe extern "C" {
5421
+
pub fn i_cal_value_get_datetime(value: *mut ICalValue) -> *mut ICalTime;
5422
+
}
5423
+
unsafe extern "C" {
5424
+
pub fn i_cal_value_set_datetimedate(value: *mut ICalValue, v: *mut ICalTime);
5425
+
}
5426
+
unsafe extern "C" {
5427
+
pub fn i_cal_value_new_datetimedate(v: *mut ICalTime) -> *mut ICalValue;
5428
+
}
5429
+
unsafe extern "C" {
5430
+
pub fn i_cal_value_get_datetimedate(value: *mut ICalValue) -> *mut ICalTime;
5431
+
}
5432
+
unsafe extern "C" {
5433
+
pub fn i_cal_value_set_datetimeperiod(value: *mut ICalValue, v: *mut ICalDatetimeperiod);
5434
+
}
5435
+
unsafe extern "C" {
5436
+
pub fn i_cal_value_new_datetimeperiod(v: *mut ICalDatetimeperiod) -> *mut ICalValue;
5437
+
}
5438
+
unsafe extern "C" {
5439
+
pub fn i_cal_value_get_datetimeperiod(value: *mut ICalValue) -> *mut ICalDatetimeperiod;
5440
+
}
5441
+
unsafe extern "C" {
5442
+
pub fn i_cal_value_set_geo(value: *mut ICalValue, v: *mut ICalGeo);
5443
+
}
5444
+
unsafe extern "C" {
5445
+
pub fn i_cal_value_new_geo(v: *mut ICalGeo) -> *mut ICalValue;
5446
+
}
5447
+
unsafe extern "C" {
5448
+
pub fn i_cal_value_get_geo(value: *mut ICalValue) -> *mut ICalGeo;
5449
+
}
5450
+
unsafe extern "C" {
5451
+
pub fn i_cal_value_set_attach(value: *mut ICalValue, v: *mut ICalAttach);
5452
+
}
5453
+
unsafe extern "C" {
5454
+
pub fn i_cal_value_new_attach(v: *mut ICalAttach) -> *mut ICalValue;
5455
+
}
5456
+
unsafe extern "C" {
5457
+
pub fn i_cal_value_get_attach(value: *mut ICalValue) -> *mut ICalAttach;
5458
+
}
5459
+
unsafe extern "C" {
5460
+
pub fn i_cal_value_reset_kind(value: *mut ICalValue);
5461
+
}
5462
+
unsafe extern "C" {
5463
+
pub fn i_cal_value_set_xlicclass(value: *mut ICalValue, v: ICalPropertyXlicclass);
5464
+
}
5465
+
unsafe extern "C" {
5466
+
pub fn i_cal_value_new_xlicclass(v: ICalPropertyXlicclass) -> *mut ICalValue;
5467
+
}
5468
+
unsafe extern "C" {
5469
+
pub fn i_cal_value_get_xlicclass(value: *mut ICalValue) -> ICalPropertyXlicclass;
5470
+
}
5471
+
unsafe extern "C" {
5472
+
pub fn i_cal_value_set_boolean(value: *mut ICalValue, v: gint);
5473
+
}
5474
+
unsafe extern "C" {
5475
+
pub fn i_cal_value_new_boolean(v: gint) -> *mut ICalValue;
5476
+
}
5477
+
unsafe extern "C" {
5478
+
pub fn i_cal_value_get_boolean(value: *mut ICalValue) -> gint;
5479
+
}
5480
+
unsafe extern "C" {
5481
+
pub fn i_cal_value_set_busytype(value: *mut ICalValue, v: ICalPropertyBusytype);
5482
+
}
5483
+
unsafe extern "C" {
5484
+
pub fn i_cal_value_new_busytype(v: ICalPropertyBusytype) -> *mut ICalValue;
5485
+
}
5486
+
unsafe extern "C" {
5487
+
pub fn i_cal_value_get_busytype(value: *mut ICalValue) -> ICalPropertyBusytype;
5488
+
}
5489
+
unsafe extern "C" {
5490
+
pub fn i_cal_value_set_pollcompletion(value: *mut ICalValue, v: ICalPropertyPollcompletion);
5491
+
}
5492
+
unsafe extern "C" {
5493
+
pub fn i_cal_value_new_pollcompletion(v: ICalPropertyPollcompletion) -> *mut ICalValue;
5494
+
}
5495
+
unsafe extern "C" {
5496
+
pub fn i_cal_value_get_pollcompletion(value: *mut ICalValue) -> ICalPropertyPollcompletion;
5497
+
}
5498
+
unsafe extern "C" {
5499
+
pub fn i_cal_value_set_taskmode(value: *mut ICalValue, v: ICalPropertyTaskmode);
5500
+
}
5501
+
unsafe extern "C" {
5502
+
pub fn i_cal_value_new_taskmode(v: ICalPropertyTaskmode) -> *mut ICalValue;
5503
+
}
5504
+
unsafe extern "C" {
5505
+
pub fn i_cal_value_get_taskmode(value: *mut ICalValue) -> ICalPropertyTaskmode;
5506
+
}
5507
+
unsafe extern "C" {
5508
+
pub fn i_cal_value_set_pollmode(value: *mut ICalValue, v: ICalPropertyPollmode);
5509
+
}
5510
+
unsafe extern "C" {
5511
+
pub fn i_cal_value_new_pollmode(v: ICalPropertyPollmode) -> *mut ICalValue;
5512
+
}
5513
+
unsafe extern "C" {
5514
+
pub fn i_cal_value_get_pollmode(value: *mut ICalValue) -> ICalPropertyPollmode;
5515
+
}
5516
+
unsafe extern "C" {
5517
+
pub fn i_cal_value_set_utcoffset(value: *mut ICalValue, v: gint);
5518
+
}
5519
+
unsafe extern "C" {
5520
+
pub fn i_cal_value_new_utcoffset(v: gint) -> *mut ICalValue;
5521
+
}
5522
+
unsafe extern "C" {
5523
+
pub fn i_cal_value_get_utcoffset(value: *mut ICalValue) -> gint;
5524
+
}
5525
+
unsafe extern "C" {
5526
+
pub fn i_cal_value_set_method(value: *mut ICalValue, v: ICalPropertyMethod);
5527
+
}
5528
+
unsafe extern "C" {
5529
+
pub fn i_cal_value_new_method(v: ICalPropertyMethod) -> *mut ICalValue;
5530
+
}
5531
+
unsafe extern "C" {
5532
+
pub fn i_cal_value_get_method(value: *mut ICalValue) -> ICalPropertyMethod;
5533
+
}
5534
+
unsafe extern "C" {
5535
+
pub fn i_cal_value_set_caladdress(value: *mut ICalValue, v: *const gchar);
5536
+
}
5537
+
unsafe extern "C" {
5538
+
pub fn i_cal_value_new_caladdress(v: *const gchar) -> *mut ICalValue;
5539
+
}
5540
+
unsafe extern "C" {
5541
+
pub fn i_cal_value_get_caladdress(value: *mut ICalValue) -> *const gchar;
5542
+
}
5543
+
unsafe extern "C" {
5544
+
pub fn i_cal_value_set_period(value: *mut ICalValue, v: *mut ICalPeriod);
5545
+
}
5546
+
unsafe extern "C" {
5547
+
pub fn i_cal_value_new_period(v: *mut ICalPeriod) -> *mut ICalValue;
5548
+
}
5549
+
unsafe extern "C" {
5550
+
pub fn i_cal_value_get_period(value: *mut ICalValue) -> *mut ICalPeriod;
5551
+
}
5552
+
unsafe extern "C" {
5553
+
pub fn i_cal_value_set_status(value: *mut ICalValue, v: ICalPropertyStatus);
5554
+
}
5555
+
unsafe extern "C" {
5556
+
pub fn i_cal_value_new_status(v: ICalPropertyStatus) -> *mut ICalValue;
5557
+
}
5558
+
unsafe extern "C" {
5559
+
pub fn i_cal_value_get_status(value: *mut ICalValue) -> ICalPropertyStatus;
5560
+
}
5561
+
unsafe extern "C" {
5562
+
pub fn i_cal_value_set_binary(value: *mut ICalValue, v: *const gchar);
5563
+
}
5564
+
unsafe extern "C" {
5565
+
pub fn i_cal_value_new_binary(v: *const gchar) -> *mut ICalValue;
5566
+
}
5567
+
unsafe extern "C" {
5568
+
pub fn i_cal_value_get_binary(value: *mut ICalValue) -> *const gchar;
5569
+
}
5570
+
unsafe extern "C" {
5571
+
pub fn i_cal_value_set_text(value: *mut ICalValue, v: *const gchar);
5572
+
}
5573
+
unsafe extern "C" {
5574
+
pub fn i_cal_value_new_text(v: *const gchar) -> *mut ICalValue;
5575
+
}
5576
+
unsafe extern "C" {
5577
+
pub fn i_cal_value_get_text(value: *mut ICalValue) -> *const gchar;
5578
+
}
5579
+
unsafe extern "C" {
5580
+
pub fn i_cal_value_set_duration(value: *mut ICalValue, v: *mut ICalDuration);
5581
+
}
5582
+
unsafe extern "C" {
5583
+
pub fn i_cal_value_new_duration(v: *mut ICalDuration) -> *mut ICalValue;
5584
+
}
5585
+
unsafe extern "C" {
5586
+
pub fn i_cal_value_get_duration(value: *mut ICalValue) -> *mut ICalDuration;
5587
+
}
5588
+
unsafe extern "C" {
5589
+
pub fn i_cal_value_set_integer(value: *mut ICalValue, v: gint);
5590
+
}
5591
+
unsafe extern "C" {
5592
+
pub fn i_cal_value_new_integer(v: gint) -> *mut ICalValue;
5593
+
}
5594
+
unsafe extern "C" {
5595
+
pub fn i_cal_value_get_integer(value: *mut ICalValue) -> gint;
5596
+
}
5597
+
unsafe extern "C" {
5598
+
pub fn i_cal_value_set_uri(value: *mut ICalValue, v: *const gchar);
5599
+
}
5600
+
unsafe extern "C" {
5601
+
pub fn i_cal_value_new_uri(v: *const gchar) -> *mut ICalValue;
5602
+
}
5603
+
unsafe extern "C" {
5604
+
pub fn i_cal_value_get_uri(value: *mut ICalValue) -> *const gchar;
5605
+
}
5606
+
unsafe extern "C" {
5607
+
pub fn i_cal_value_set_class(value: *mut ICalValue, v: ICalProperty_Class);
5608
+
}
5609
+
unsafe extern "C" {
5610
+
pub fn i_cal_value_new_class(v: ICalProperty_Class) -> *mut ICalValue;
5611
+
}
5612
+
unsafe extern "C" {
5613
+
pub fn i_cal_value_get_class(value: *mut ICalValue) -> ICalProperty_Class;
5614
+
}
5615
+
unsafe extern "C" {
5616
+
pub fn i_cal_value_set_float(value: *mut ICalValue, v: gdouble);
5617
+
}
5618
+
unsafe extern "C" {
5619
+
pub fn i_cal_value_new_float(v: gdouble) -> *mut ICalValue;
5620
+
}
5621
+
unsafe extern "C" {
5622
+
pub fn i_cal_value_get_float(value: *mut ICalValue) -> gdouble;
5623
+
}
5624
+
unsafe extern "C" {
5625
+
pub fn i_cal_value_set_query(value: *mut ICalValue, v: *const gchar);
5626
+
}
5627
+
unsafe extern "C" {
5628
+
pub fn i_cal_value_new_query(v: *const gchar) -> *mut ICalValue;
5629
+
}
5630
+
unsafe extern "C" {
5631
+
pub fn i_cal_value_get_query(value: *mut ICalValue) -> *const gchar;
5632
+
}
5633
+
unsafe extern "C" {
5634
+
pub fn i_cal_value_set_string(value: *mut ICalValue, v: *const gchar);
5635
+
}
5636
+
unsafe extern "C" {
5637
+
pub fn i_cal_value_new_string(v: *const gchar) -> *mut ICalValue;
5638
+
}
5639
+
unsafe extern "C" {
5640
+
pub fn i_cal_value_get_string(value: *mut ICalValue) -> *const gchar;
5641
+
}
5642
+
unsafe extern "C" {
5643
+
pub fn i_cal_value_set_transp(value: *mut ICalValue, v: ICalPropertyTransp);
5644
+
}
5645
+
unsafe extern "C" {
5646
+
pub fn i_cal_value_new_transp(v: ICalPropertyTransp) -> *mut ICalValue;
5647
+
}
5648
+
unsafe extern "C" {
5649
+
pub fn i_cal_value_get_transp(value: *mut ICalValue) -> ICalPropertyTransp;
5650
+
}
5651
+
unsafe extern "C" {
5652
+
pub fn i_cal_value_set_requeststatus(value: *mut ICalValue, v: *mut ICalReqstat);
5653
+
}
5654
+
unsafe extern "C" {
5655
+
pub fn i_cal_value_new_requeststatus(v: *mut ICalReqstat) -> *mut ICalValue;
5656
+
}
5657
+
unsafe extern "C" {
5658
+
pub fn i_cal_value_get_requeststatus(value: *mut ICalValue) -> *mut ICalReqstat;
5659
+
}
5660
+
unsafe extern "C" {
5661
+
pub fn i_cal_value_set_date(value: *mut ICalValue, v: *mut ICalTime);
5662
+
}
5663
+
unsafe extern "C" {
5664
+
pub fn i_cal_value_new_date(v: *mut ICalTime) -> *mut ICalValue;
5665
+
}
5666
+
unsafe extern "C" {
5667
+
pub fn i_cal_value_get_date(value: *mut ICalValue) -> *mut ICalTime;
5668
+
}
5669
+
unsafe extern "C" {
5670
+
pub fn i_cal_value_set_action(value: *mut ICalValue, v: ICalPropertyAction);
5671
+
}
5672
+
unsafe extern "C" {
5673
+
pub fn i_cal_value_new_action(v: ICalPropertyAction) -> *mut ICalValue;
5674
+
}
5675
+
unsafe extern "C" {
5676
+
pub fn i_cal_value_get_action(value: *mut ICalValue) -> ICalPropertyAction;
5677
+
}
5678
+
unsafe extern "C" {
5679
+
pub fn i_cal_value_set_cmd(value: *mut ICalValue, v: ICalPropertyCmd);
5680
+
}
5681
+
unsafe extern "C" {
5682
+
pub fn i_cal_value_new_cmd(v: ICalPropertyCmd) -> *mut ICalValue;
5683
+
}
5684
+
unsafe extern "C" {
5685
+
pub fn i_cal_value_get_cmd(value: *mut ICalValue) -> ICalPropertyCmd;
5686
+
}
5687
+
unsafe extern "C" {
5688
+
pub fn i_cal_value_set_querylevel(value: *mut ICalValue, v: ICalPropertyQuerylevel);
5689
+
}
5690
+
unsafe extern "C" {
5691
+
pub fn i_cal_value_new_querylevel(v: ICalPropertyQuerylevel) -> *mut ICalValue;
5692
+
}
5693
+
unsafe extern "C" {
5694
+
pub fn i_cal_value_get_querylevel(value: *mut ICalValue) -> ICalPropertyQuerylevel;
5695
+
}
5696
+
unsafe extern "C" {
5697
+
pub fn i_cal_value_set_carlevel(value: *mut ICalValue, v: ICalPropertyCarlevel);
5698
+
}
5699
+
unsafe extern "C" {
5700
+
pub fn i_cal_value_new_carlevel(v: ICalPropertyCarlevel) -> *mut ICalValue;
5701
+
}
5702
+
unsafe extern "C" {
5703
+
pub fn i_cal_value_get_carlevel(value: *mut ICalValue) -> ICalPropertyCarlevel;
5704
+
}
5705
+
pub const ICalPropertyKind_I_CAL_ANY_PROPERTY: ICalPropertyKind = 0;
5706
+
pub const ICalPropertyKind_I_CAL_ACCEPTRESPONSE_PROPERTY: ICalPropertyKind = 102;
5707
+
pub const ICalPropertyKind_I_CAL_ACKNOWLEDGED_PROPERTY: ICalPropertyKind = 1;
5708
+
pub const ICalPropertyKind_I_CAL_ACTION_PROPERTY: ICalPropertyKind = 2;
5709
+
pub const ICalPropertyKind_I_CAL_ALLOWCONFLICT_PROPERTY: ICalPropertyKind = 3;
5710
+
pub const ICalPropertyKind_I_CAL_ATTACH_PROPERTY: ICalPropertyKind = 4;
5711
+
pub const ICalPropertyKind_I_CAL_ATTENDEE_PROPERTY: ICalPropertyKind = 5;
5712
+
pub const ICalPropertyKind_I_CAL_BUSYTYPE_PROPERTY: ICalPropertyKind = 101;
5713
+
pub const ICalPropertyKind_I_CAL_CALID_PROPERTY: ICalPropertyKind = 6;
5714
+
pub const ICalPropertyKind_I_CAL_CALMASTER_PROPERTY: ICalPropertyKind = 7;
5715
+
pub const ICalPropertyKind_I_CAL_CALSCALE_PROPERTY: ICalPropertyKind = 8;
5716
+
pub const ICalPropertyKind_I_CAL_CAPVERSION_PROPERTY: ICalPropertyKind = 9;
5717
+
pub const ICalPropertyKind_I_CAL_CARLEVEL_PROPERTY: ICalPropertyKind = 10;
5718
+
pub const ICalPropertyKind_I_CAL_CARID_PROPERTY: ICalPropertyKind = 11;
5719
+
pub const ICalPropertyKind_I_CAL_CATEGORIES_PROPERTY: ICalPropertyKind = 12;
5720
+
pub const ICalPropertyKind_I_CAL_CLASS_PROPERTY: ICalPropertyKind = 13;
5721
+
pub const ICalPropertyKind_I_CAL_CMD_PROPERTY: ICalPropertyKind = 14;
5722
+
pub const ICalPropertyKind_I_CAL_COLOR_PROPERTY: ICalPropertyKind = 118;
5723
+
pub const ICalPropertyKind_I_CAL_COMMENT_PROPERTY: ICalPropertyKind = 15;
5724
+
pub const ICalPropertyKind_I_CAL_COMPLETED_PROPERTY: ICalPropertyKind = 16;
5725
+
pub const ICalPropertyKind_I_CAL_COMPONENTS_PROPERTY: ICalPropertyKind = 17;
5726
+
pub const ICalPropertyKind_I_CAL_CONTACT_PROPERTY: ICalPropertyKind = 18;
5727
+
pub const ICalPropertyKind_I_CAL_CREATED_PROPERTY: ICalPropertyKind = 19;
5728
+
pub const ICalPropertyKind_I_CAL_CSID_PROPERTY: ICalPropertyKind = 20;
5729
+
pub const ICalPropertyKind_I_CAL_DATEMAX_PROPERTY: ICalPropertyKind = 21;
5730
+
pub const ICalPropertyKind_I_CAL_DATEMIN_PROPERTY: ICalPropertyKind = 22;
5731
+
pub const ICalPropertyKind_I_CAL_DECREED_PROPERTY: ICalPropertyKind = 23;
5732
+
pub const ICalPropertyKind_I_CAL_DEFAULTCHARSET_PROPERTY: ICalPropertyKind = 24;
5733
+
pub const ICalPropertyKind_I_CAL_DEFAULTLOCALE_PROPERTY: ICalPropertyKind = 25;
5734
+
pub const ICalPropertyKind_I_CAL_DEFAULTTZID_PROPERTY: ICalPropertyKind = 26;
5735
+
pub const ICalPropertyKind_I_CAL_DEFAULTVCARS_PROPERTY: ICalPropertyKind = 27;
5736
+
pub const ICalPropertyKind_I_CAL_DENY_PROPERTY: ICalPropertyKind = 28;
5737
+
pub const ICalPropertyKind_I_CAL_DESCRIPTION_PROPERTY: ICalPropertyKind = 29;
5738
+
pub const ICalPropertyKind_I_CAL_DTEND_PROPERTY: ICalPropertyKind = 30;
5739
+
pub const ICalPropertyKind_I_CAL_DTSTAMP_PROPERTY: ICalPropertyKind = 31;
5740
+
pub const ICalPropertyKind_I_CAL_DTSTART_PROPERTY: ICalPropertyKind = 32;
5741
+
pub const ICalPropertyKind_I_CAL_DUE_PROPERTY: ICalPropertyKind = 33;
5742
+
pub const ICalPropertyKind_I_CAL_DURATION_PROPERTY: ICalPropertyKind = 34;
5743
+
pub const ICalPropertyKind_I_CAL_ESTIMATEDDURATION_PROPERTY: ICalPropertyKind = 113;
5744
+
pub const ICalPropertyKind_I_CAL_EXDATE_PROPERTY: ICalPropertyKind = 35;
5745
+
pub const ICalPropertyKind_I_CAL_EXPAND_PROPERTY: ICalPropertyKind = 36;
5746
+
pub const ICalPropertyKind_I_CAL_EXRULE_PROPERTY: ICalPropertyKind = 37;
5747
+
pub const ICalPropertyKind_I_CAL_FREEBUSY_PROPERTY: ICalPropertyKind = 38;
5748
+
pub const ICalPropertyKind_I_CAL_GEO_PROPERTY: ICalPropertyKind = 39;
5749
+
pub const ICalPropertyKind_I_CAL_GRANT_PROPERTY: ICalPropertyKind = 40;
5750
+
pub const ICalPropertyKind_I_CAL_ITIPVERSION_PROPERTY: ICalPropertyKind = 41;
5751
+
pub const ICalPropertyKind_I_CAL_LASTMODIFIED_PROPERTY: ICalPropertyKind = 42;
5752
+
pub const ICalPropertyKind_I_CAL_LOCATION_PROPERTY: ICalPropertyKind = 43;
5753
+
pub const ICalPropertyKind_I_CAL_MAXCOMPONENTSIZE_PROPERTY: ICalPropertyKind = 44;
5754
+
pub const ICalPropertyKind_I_CAL_MAXDATE_PROPERTY: ICalPropertyKind = 45;
5755
+
pub const ICalPropertyKind_I_CAL_MAXRESULTS_PROPERTY: ICalPropertyKind = 46;
5756
+
pub const ICalPropertyKind_I_CAL_MAXRESULTSSIZE_PROPERTY: ICalPropertyKind = 47;
5757
+
pub const ICalPropertyKind_I_CAL_METHOD_PROPERTY: ICalPropertyKind = 48;
5758
+
pub const ICalPropertyKind_I_CAL_MINDATE_PROPERTY: ICalPropertyKind = 49;
5759
+
pub const ICalPropertyKind_I_CAL_MULTIPART_PROPERTY: ICalPropertyKind = 50;
5760
+
pub const ICalPropertyKind_I_CAL_NAME_PROPERTY: ICalPropertyKind = 115;
5761
+
pub const ICalPropertyKind_I_CAL_ORGANIZER_PROPERTY: ICalPropertyKind = 52;
5762
+
pub const ICalPropertyKind_I_CAL_OWNER_PROPERTY: ICalPropertyKind = 53;
5763
+
pub const ICalPropertyKind_I_CAL_PERCENTCOMPLETE_PROPERTY: ICalPropertyKind = 54;
5764
+
pub const ICalPropertyKind_I_CAL_PERMISSION_PROPERTY: ICalPropertyKind = 55;
5765
+
pub const ICalPropertyKind_I_CAL_POLLCOMPLETION_PROPERTY: ICalPropertyKind = 110;
5766
+
pub const ICalPropertyKind_I_CAL_POLLITEMID_PROPERTY: ICalPropertyKind = 103;
5767
+
pub const ICalPropertyKind_I_CAL_POLLMODE_PROPERTY: ICalPropertyKind = 104;
5768
+
pub const ICalPropertyKind_I_CAL_POLLPROPERTIES_PROPERTY: ICalPropertyKind = 105;
5769
+
pub const ICalPropertyKind_I_CAL_POLLWINNER_PROPERTY: ICalPropertyKind = 106;
5770
+
pub const ICalPropertyKind_I_CAL_PRIORITY_PROPERTY: ICalPropertyKind = 56;
5771
+
pub const ICalPropertyKind_I_CAL_PRODID_PROPERTY: ICalPropertyKind = 57;
5772
+
pub const ICalPropertyKind_I_CAL_QUERY_PROPERTY: ICalPropertyKind = 58;
5773
+
pub const ICalPropertyKind_I_CAL_QUERYLEVEL_PROPERTY: ICalPropertyKind = 59;
5774
+
pub const ICalPropertyKind_I_CAL_QUERYID_PROPERTY: ICalPropertyKind = 60;
5775
+
pub const ICalPropertyKind_I_CAL_QUERYNAME_PROPERTY: ICalPropertyKind = 61;
5776
+
pub const ICalPropertyKind_I_CAL_RDATE_PROPERTY: ICalPropertyKind = 62;
5777
+
pub const ICalPropertyKind_I_CAL_RECURACCEPTED_PROPERTY: ICalPropertyKind = 63;
5778
+
pub const ICalPropertyKind_I_CAL_RECUREXPAND_PROPERTY: ICalPropertyKind = 64;
5779
+
pub const ICalPropertyKind_I_CAL_RECURLIMIT_PROPERTY: ICalPropertyKind = 65;
5780
+
pub const ICalPropertyKind_I_CAL_RECURRENCEID_PROPERTY: ICalPropertyKind = 66;
5781
+
pub const ICalPropertyKind_I_CAL_RELATEDTO_PROPERTY: ICalPropertyKind = 67;
5782
+
pub const ICalPropertyKind_I_CAL_RELCALID_PROPERTY: ICalPropertyKind = 68;
5783
+
pub const ICalPropertyKind_I_CAL_REPEAT_PROPERTY: ICalPropertyKind = 69;
5784
+
pub const ICalPropertyKind_I_CAL_REPLYURL_PROPERTY: ICalPropertyKind = 111;
5785
+
pub const ICalPropertyKind_I_CAL_REQUESTSTATUS_PROPERTY: ICalPropertyKind = 70;
5786
+
pub const ICalPropertyKind_I_CAL_RESOURCES_PROPERTY: ICalPropertyKind = 71;
5787
+
pub const ICalPropertyKind_I_CAL_RESPONSE_PROPERTY: ICalPropertyKind = 112;
5788
+
pub const ICalPropertyKind_I_CAL_RESTRICTION_PROPERTY: ICalPropertyKind = 72;
5789
+
pub const ICalPropertyKind_I_CAL_RRULE_PROPERTY: ICalPropertyKind = 73;
5790
+
pub const ICalPropertyKind_I_CAL_SCOPE_PROPERTY: ICalPropertyKind = 74;
5791
+
pub const ICalPropertyKind_I_CAL_SEQUENCE_PROPERTY: ICalPropertyKind = 75;
5792
+
pub const ICalPropertyKind_I_CAL_STATUS_PROPERTY: ICalPropertyKind = 76;
5793
+
pub const ICalPropertyKind_I_CAL_STORESEXPANDED_PROPERTY: ICalPropertyKind = 77;
5794
+
pub const ICalPropertyKind_I_CAL_SUMMARY_PROPERTY: ICalPropertyKind = 78;
5795
+
pub const ICalPropertyKind_I_CAL_TARGET_PROPERTY: ICalPropertyKind = 79;
5796
+
pub const ICalPropertyKind_I_CAL_TASKMODE_PROPERTY: ICalPropertyKind = 114;
5797
+
pub const ICalPropertyKind_I_CAL_TRANSP_PROPERTY: ICalPropertyKind = 80;
5798
+
pub const ICalPropertyKind_I_CAL_TRIGGER_PROPERTY: ICalPropertyKind = 81;
5799
+
pub const ICalPropertyKind_I_CAL_TZID_PROPERTY: ICalPropertyKind = 82;
5800
+
pub const ICalPropertyKind_I_CAL_TZIDALIASOF_PROPERTY: ICalPropertyKind = 108;
5801
+
pub const ICalPropertyKind_I_CAL_TZNAME_PROPERTY: ICalPropertyKind = 83;
5802
+
pub const ICalPropertyKind_I_CAL_TZOFFSETFROM_PROPERTY: ICalPropertyKind = 84;
5803
+
pub const ICalPropertyKind_I_CAL_TZOFFSETTO_PROPERTY: ICalPropertyKind = 85;
5804
+
pub const ICalPropertyKind_I_CAL_TZUNTIL_PROPERTY: ICalPropertyKind = 109;
5805
+
pub const ICalPropertyKind_I_CAL_TZURL_PROPERTY: ICalPropertyKind = 86;
5806
+
pub const ICalPropertyKind_I_CAL_UID_PROPERTY: ICalPropertyKind = 87;
5807
+
pub const ICalPropertyKind_I_CAL_URL_PROPERTY: ICalPropertyKind = 88;
5808
+
pub const ICalPropertyKind_I_CAL_VERSION_PROPERTY: ICalPropertyKind = 89;
5809
+
pub const ICalPropertyKind_I_CAL_VOTER_PROPERTY: ICalPropertyKind = 107;
5810
+
pub const ICalPropertyKind_I_CAL_X_PROPERTY: ICalPropertyKind = 90;
5811
+
pub const ICalPropertyKind_I_CAL_XLICCLASS_PROPERTY: ICalPropertyKind = 91;
5812
+
pub const ICalPropertyKind_I_CAL_XLICCLUSTERCOUNT_PROPERTY: ICalPropertyKind = 92;
5813
+
pub const ICalPropertyKind_I_CAL_XLICERROR_PROPERTY: ICalPropertyKind = 93;
5814
+
pub const ICalPropertyKind_I_CAL_XLICMIMECHARSET_PROPERTY: ICalPropertyKind = 94;
5815
+
pub const ICalPropertyKind_I_CAL_XLICMIMECID_PROPERTY: ICalPropertyKind = 95;
5816
+
pub const ICalPropertyKind_I_CAL_XLICMIMECONTENTTYPE_PROPERTY: ICalPropertyKind = 96;
5817
+
pub const ICalPropertyKind_I_CAL_XLICMIMEENCODING_PROPERTY: ICalPropertyKind = 97;
5818
+
pub const ICalPropertyKind_I_CAL_XLICMIMEFILENAME_PROPERTY: ICalPropertyKind = 98;
5819
+
pub const ICalPropertyKind_I_CAL_XLICMIMEOPTINFO_PROPERTY: ICalPropertyKind = 99;
5820
+
pub const ICalPropertyKind_I_CAL_NO_PROPERTY: ICalPropertyKind = 100;
5821
+
pub type ICalPropertyKind = ::std::os::raw::c_uint;
5822
+
unsafe extern "C" {
5823
+
pub fn i_cal_property_new_acceptresponse(v: *const gchar) -> *mut ICalProperty;
5824
+
}
5825
+
unsafe extern "C" {
5826
+
pub fn i_cal_property_set_acceptresponse(prop: *mut ICalProperty, v: *const gchar);
5827
+
}
5828
+
unsafe extern "C" {
5829
+
pub fn i_cal_property_get_acceptresponse(prop: *mut ICalProperty) -> *const gchar;
5830
+
}
5831
+
unsafe extern "C" {
5832
+
pub fn i_cal_property_new_acknowledged(v: *mut ICalTime) -> *mut ICalProperty;
5833
+
}
5834
+
unsafe extern "C" {
5835
+
pub fn i_cal_property_set_acknowledged(prop: *mut ICalProperty, v: *mut ICalTime);
5836
+
}
5837
+
unsafe extern "C" {
5838
+
pub fn i_cal_property_get_acknowledged(prop: *mut ICalProperty) -> *mut ICalTime;
5839
+
}
5840
+
unsafe extern "C" {
5841
+
pub fn i_cal_property_new_action(v: ICalPropertyAction) -> *mut ICalProperty;
5842
+
}
5843
+
unsafe extern "C" {
5844
+
pub fn i_cal_property_set_action(prop: *mut ICalProperty, v: ICalPropertyAction);
5845
+
}
5846
+
unsafe extern "C" {
5847
+
pub fn i_cal_property_get_action(prop: *mut ICalProperty) -> ICalPropertyAction;
5848
+
}
5849
+
unsafe extern "C" {
5850
+
pub fn i_cal_property_new_allowconflict(v: *const gchar) -> *mut ICalProperty;
5851
+
}
5852
+
unsafe extern "C" {
5853
+
pub fn i_cal_property_set_allowconflict(prop: *mut ICalProperty, v: *const gchar);
5854
+
}
5855
+
unsafe extern "C" {
5856
+
pub fn i_cal_property_get_allowconflict(prop: *mut ICalProperty) -> *const gchar;
5857
+
}
5858
+
unsafe extern "C" {
5859
+
pub fn i_cal_property_new_attach(v: *mut ICalAttach) -> *mut ICalProperty;
5860
+
}
5861
+
unsafe extern "C" {
5862
+
pub fn i_cal_property_set_attach(prop: *mut ICalProperty, v: *mut ICalAttach);
5863
+
}
5864
+
unsafe extern "C" {
5865
+
pub fn i_cal_property_get_attach(prop: *mut ICalProperty) -> *mut ICalAttach;
5866
+
}
5867
+
unsafe extern "C" {
5868
+
pub fn i_cal_property_new_attendee(v: *const gchar) -> *mut ICalProperty;
5869
+
}
5870
+
unsafe extern "C" {
5871
+
pub fn i_cal_property_set_attendee(prop: *mut ICalProperty, v: *const gchar);
5872
+
}
5873
+
unsafe extern "C" {
5874
+
pub fn i_cal_property_get_attendee(prop: *mut ICalProperty) -> *const gchar;
5875
+
}
5876
+
unsafe extern "C" {
5877
+
pub fn i_cal_property_new_busytype(v: ICalPropertyBusytype) -> *mut ICalProperty;
5878
+
}
5879
+
unsafe extern "C" {
5880
+
pub fn i_cal_property_set_busytype(prop: *mut ICalProperty, v: ICalPropertyBusytype);
5881
+
}
5882
+
unsafe extern "C" {
5883
+
pub fn i_cal_property_get_busytype(prop: *mut ICalProperty) -> ICalPropertyBusytype;
5884
+
}
5885
+
unsafe extern "C" {
5886
+
pub fn i_cal_property_new_calid(v: *const gchar) -> *mut ICalProperty;
5887
+
}
5888
+
unsafe extern "C" {
5889
+
pub fn i_cal_property_set_calid(prop: *mut ICalProperty, v: *const gchar);
5890
+
}
5891
+
unsafe extern "C" {
5892
+
pub fn i_cal_property_get_calid(prop: *mut ICalProperty) -> *const gchar;
5893
+
}
5894
+
unsafe extern "C" {
5895
+
pub fn i_cal_property_new_calmaster(v: *const gchar) -> *mut ICalProperty;
5896
+
}
5897
+
unsafe extern "C" {
5898
+
pub fn i_cal_property_set_calmaster(prop: *mut ICalProperty, v: *const gchar);
5899
+
}
5900
+
unsafe extern "C" {
5901
+
pub fn i_cal_property_get_calmaster(prop: *mut ICalProperty) -> *const gchar;
5902
+
}
5903
+
unsafe extern "C" {
5904
+
pub fn i_cal_property_new_calscale(v: *const gchar) -> *mut ICalProperty;
5905
+
}
5906
+
unsafe extern "C" {
5907
+
pub fn i_cal_property_set_calscale(prop: *mut ICalProperty, v: *const gchar);
5908
+
}
5909
+
unsafe extern "C" {
5910
+
pub fn i_cal_property_get_calscale(prop: *mut ICalProperty) -> *const gchar;
5911
+
}
5912
+
unsafe extern "C" {
5913
+
pub fn i_cal_property_new_capversion(v: *const gchar) -> *mut ICalProperty;
5914
+
}
5915
+
unsafe extern "C" {
5916
+
pub fn i_cal_property_set_capversion(prop: *mut ICalProperty, v: *const gchar);
5917
+
}
5918
+
unsafe extern "C" {
5919
+
pub fn i_cal_property_get_capversion(prop: *mut ICalProperty) -> *const gchar;
5920
+
}
5921
+
unsafe extern "C" {
5922
+
pub fn i_cal_property_new_carlevel(v: ICalPropertyCarlevel) -> *mut ICalProperty;
5923
+
}
5924
+
unsafe extern "C" {
5925
+
pub fn i_cal_property_set_carlevel(prop: *mut ICalProperty, v: ICalPropertyCarlevel);
5926
+
}
5927
+
unsafe extern "C" {
5928
+
pub fn i_cal_property_get_carlevel(prop: *mut ICalProperty) -> ICalPropertyCarlevel;
5929
+
}
5930
+
unsafe extern "C" {
5931
+
pub fn i_cal_property_new_carid(v: *const gchar) -> *mut ICalProperty;
5932
+
}
5933
+
unsafe extern "C" {
5934
+
pub fn i_cal_property_set_carid(prop: *mut ICalProperty, v: *const gchar);
5935
+
}
5936
+
unsafe extern "C" {
5937
+
pub fn i_cal_property_get_carid(prop: *mut ICalProperty) -> *const gchar;
5938
+
}
5939
+
unsafe extern "C" {
5940
+
pub fn i_cal_property_new_categories(v: *const gchar) -> *mut ICalProperty;
5941
+
}
5942
+
unsafe extern "C" {
5943
+
pub fn i_cal_property_set_categories(prop: *mut ICalProperty, v: *const gchar);
5944
+
}
5945
+
unsafe extern "C" {
5946
+
pub fn i_cal_property_get_categories(prop: *mut ICalProperty) -> *const gchar;
5947
+
}
5948
+
unsafe extern "C" {
5949
+
pub fn i_cal_property_new_class(v: ICalProperty_Class) -> *mut ICalProperty;
5950
+
}
5951
+
unsafe extern "C" {
5952
+
pub fn i_cal_property_set_class(prop: *mut ICalProperty, v: ICalProperty_Class);
5953
+
}
5954
+
unsafe extern "C" {
5955
+
pub fn i_cal_property_get_class(prop: *mut ICalProperty) -> ICalProperty_Class;
5956
+
}
5957
+
unsafe extern "C" {
5958
+
pub fn i_cal_property_new_cmd(v: ICalPropertyCmd) -> *mut ICalProperty;
5959
+
}
5960
+
unsafe extern "C" {
5961
+
pub fn i_cal_property_set_cmd(prop: *mut ICalProperty, v: ICalPropertyCmd);
5962
+
}
5963
+
unsafe extern "C" {
5964
+
pub fn i_cal_property_get_cmd(prop: *mut ICalProperty) -> ICalPropertyCmd;
5965
+
}
5966
+
unsafe extern "C" {
5967
+
pub fn i_cal_property_new_comment(v: *const gchar) -> *mut ICalProperty;
5968
+
}
5969
+
unsafe extern "C" {
5970
+
pub fn i_cal_property_set_comment(prop: *mut ICalProperty, v: *const gchar);
5971
+
}
5972
+
unsafe extern "C" {
5973
+
pub fn i_cal_property_get_color(prop: *mut ICalProperty) -> *const gchar;
5974
+
}
5975
+
unsafe extern "C" {
5976
+
pub fn i_cal_property_new_color(v: *const gchar) -> *mut ICalProperty;
5977
+
}
5978
+
unsafe extern "C" {
5979
+
pub fn i_cal_property_set_color(prop: *mut ICalProperty, v: *const gchar);
5980
+
}
5981
+
unsafe extern "C" {
5982
+
pub fn i_cal_property_get_comment(prop: *mut ICalProperty) -> *const gchar;
5983
+
}
5984
+
unsafe extern "C" {
5985
+
pub fn i_cal_property_new_completed(v: *mut ICalTime) -> *mut ICalProperty;
5986
+
}
5987
+
unsafe extern "C" {
5988
+
pub fn i_cal_property_set_completed(prop: *mut ICalProperty, v: *mut ICalTime);
5989
+
}
5990
+
unsafe extern "C" {
5991
+
pub fn i_cal_property_get_completed(prop: *mut ICalProperty) -> *mut ICalTime;
5992
+
}
5993
+
unsafe extern "C" {
5994
+
pub fn i_cal_property_new_components(v: *const gchar) -> *mut ICalProperty;
5995
+
}
5996
+
unsafe extern "C" {
5997
+
pub fn i_cal_property_set_components(prop: *mut ICalProperty, v: *const gchar);
5998
+
}
5999
+
unsafe extern "C" {
6000
+
pub fn i_cal_property_get_components(prop: *mut ICalProperty) -> *const gchar;
6001
+
}
6002
+
unsafe extern "C" {
6003
+
pub fn i_cal_property_new_contact(v: *const gchar) -> *mut ICalProperty;
6004
+
}
6005
+
unsafe extern "C" {
6006
+
pub fn i_cal_property_set_contact(prop: *mut ICalProperty, v: *const gchar);
6007
+
}
6008
+
unsafe extern "C" {
6009
+
pub fn i_cal_property_get_contact(prop: *mut ICalProperty) -> *const gchar;
6010
+
}
6011
+
unsafe extern "C" {
6012
+
pub fn i_cal_property_new_created(v: *mut ICalTime) -> *mut ICalProperty;
6013
+
}
6014
+
unsafe extern "C" {
6015
+
pub fn i_cal_property_set_created(prop: *mut ICalProperty, v: *mut ICalTime);
6016
+
}
6017
+
unsafe extern "C" {
6018
+
pub fn i_cal_property_get_created(prop: *mut ICalProperty) -> *mut ICalTime;
6019
+
}
6020
+
unsafe extern "C" {
6021
+
pub fn i_cal_property_new_csid(v: *const gchar) -> *mut ICalProperty;
6022
+
}
6023
+
unsafe extern "C" {
6024
+
pub fn i_cal_property_set_csid(prop: *mut ICalProperty, v: *const gchar);
6025
+
}
6026
+
unsafe extern "C" {
6027
+
pub fn i_cal_property_get_csid(prop: *mut ICalProperty) -> *const gchar;
6028
+
}
6029
+
unsafe extern "C" {
6030
+
pub fn i_cal_property_new_datemax(v: *mut ICalTime) -> *mut ICalProperty;
6031
+
}
6032
+
unsafe extern "C" {
6033
+
pub fn i_cal_property_set_datemax(prop: *mut ICalProperty, v: *mut ICalTime);
6034
+
}
6035
+
unsafe extern "C" {
6036
+
pub fn i_cal_property_get_datemax(prop: *mut ICalProperty) -> *mut ICalTime;
6037
+
}
6038
+
unsafe extern "C" {
6039
+
pub fn i_cal_property_new_datemin(v: *mut ICalTime) -> *mut ICalProperty;
6040
+
}
6041
+
unsafe extern "C" {
6042
+
pub fn i_cal_property_set_datemin(prop: *mut ICalProperty, v: *mut ICalTime);
6043
+
}
6044
+
unsafe extern "C" {
6045
+
pub fn i_cal_property_get_datemin(prop: *mut ICalProperty) -> *mut ICalTime;
6046
+
}
6047
+
unsafe extern "C" {
6048
+
pub fn i_cal_property_new_decreed(v: *const gchar) -> *mut ICalProperty;
6049
+
}
6050
+
unsafe extern "C" {
6051
+
pub fn i_cal_property_set_decreed(prop: *mut ICalProperty, v: *const gchar);
6052
+
}
6053
+
unsafe extern "C" {
6054
+
pub fn i_cal_property_get_decreed(prop: *mut ICalProperty) -> *const gchar;
6055
+
}
6056
+
unsafe extern "C" {
6057
+
pub fn i_cal_property_new_defaultcharset(v: *const gchar) -> *mut ICalProperty;
6058
+
}
6059
+
unsafe extern "C" {
6060
+
pub fn i_cal_property_set_defaultcharset(prop: *mut ICalProperty, v: *const gchar);
6061
+
}
6062
+
unsafe extern "C" {
6063
+
pub fn i_cal_property_get_defaultcharset(prop: *mut ICalProperty) -> *const gchar;
6064
+
}
6065
+
unsafe extern "C" {
6066
+
pub fn i_cal_property_new_defaultlocale(v: *const gchar) -> *mut ICalProperty;
6067
+
}
6068
+
unsafe extern "C" {
6069
+
pub fn i_cal_property_set_defaultlocale(prop: *mut ICalProperty, v: *const gchar);
6070
+
}
6071
+
unsafe extern "C" {
6072
+
pub fn i_cal_property_get_defaultlocale(prop: *mut ICalProperty) -> *const gchar;
6073
+
}
6074
+
unsafe extern "C" {
6075
+
pub fn i_cal_property_new_defaulttzid(v: *const gchar) -> *mut ICalProperty;
6076
+
}
6077
+
unsafe extern "C" {
6078
+
pub fn i_cal_property_set_defaulttzid(prop: *mut ICalProperty, v: *const gchar);
6079
+
}
6080
+
unsafe extern "C" {
6081
+
pub fn i_cal_property_get_defaulttzid(prop: *mut ICalProperty) -> *const gchar;
6082
+
}
6083
+
unsafe extern "C" {
6084
+
pub fn i_cal_property_new_defaultvcars(v: *const gchar) -> *mut ICalProperty;
6085
+
}
6086
+
unsafe extern "C" {
6087
+
pub fn i_cal_property_set_defaultvcars(prop: *mut ICalProperty, v: *const gchar);
6088
+
}
6089
+
unsafe extern "C" {
6090
+
pub fn i_cal_property_get_defaultvcars(prop: *mut ICalProperty) -> *const gchar;
6091
+
}
6092
+
unsafe extern "C" {
6093
+
pub fn i_cal_property_new_deny(v: *const gchar) -> *mut ICalProperty;
6094
+
}
6095
+
unsafe extern "C" {
6096
+
pub fn i_cal_property_set_deny(prop: *mut ICalProperty, v: *const gchar);
6097
+
}
6098
+
unsafe extern "C" {
6099
+
pub fn i_cal_property_get_deny(prop: *mut ICalProperty) -> *const gchar;
6100
+
}
6101
+
unsafe extern "C" {
6102
+
pub fn i_cal_property_new_description(v: *const gchar) -> *mut ICalProperty;
6103
+
}
6104
+
unsafe extern "C" {
6105
+
pub fn i_cal_property_set_description(prop: *mut ICalProperty, v: *const gchar);
6106
+
}
6107
+
unsafe extern "C" {
6108
+
pub fn i_cal_property_get_description(prop: *mut ICalProperty) -> *const gchar;
6109
+
}
6110
+
unsafe extern "C" {
6111
+
pub fn i_cal_property_new_dtend(v: *mut ICalTime) -> *mut ICalProperty;
6112
+
}
6113
+
unsafe extern "C" {
6114
+
pub fn i_cal_property_set_dtend(prop: *mut ICalProperty, v: *mut ICalTime);
6115
+
}
6116
+
unsafe extern "C" {
6117
+
pub fn i_cal_property_get_dtend(prop: *mut ICalProperty) -> *mut ICalTime;
6118
+
}
6119
+
unsafe extern "C" {
6120
+
pub fn i_cal_property_new_dtstamp(v: *mut ICalTime) -> *mut ICalProperty;
6121
+
}
6122
+
unsafe extern "C" {
6123
+
pub fn i_cal_property_set_dtstamp(prop: *mut ICalProperty, v: *mut ICalTime);
6124
+
}
6125
+
unsafe extern "C" {
6126
+
pub fn i_cal_property_get_dtstamp(prop: *mut ICalProperty) -> *mut ICalTime;
6127
+
}
6128
+
unsafe extern "C" {
6129
+
pub fn i_cal_property_new_dtstart(v: *mut ICalTime) -> *mut ICalProperty;
6130
+
}
6131
+
unsafe extern "C" {
6132
+
pub fn i_cal_property_set_dtstart(prop: *mut ICalProperty, v: *mut ICalTime);
6133
+
}
6134
+
unsafe extern "C" {
6135
+
pub fn i_cal_property_get_dtstart(prop: *mut ICalProperty) -> *mut ICalTime;
6136
+
}
6137
+
unsafe extern "C" {
6138
+
pub fn i_cal_property_new_due(v: *mut ICalTime) -> *mut ICalProperty;
6139
+
}
6140
+
unsafe extern "C" {
6141
+
pub fn i_cal_property_set_due(prop: *mut ICalProperty, v: *mut ICalTime);
6142
+
}
6143
+
unsafe extern "C" {
6144
+
pub fn i_cal_property_get_due(prop: *mut ICalProperty) -> *mut ICalTime;
6145
+
}
6146
+
unsafe extern "C" {
6147
+
pub fn i_cal_property_new_duration(v: *mut ICalDuration) -> *mut ICalProperty;
6148
+
}
6149
+
unsafe extern "C" {
6150
+
pub fn i_cal_property_set_duration(prop: *mut ICalProperty, v: *mut ICalDuration);
6151
+
}
6152
+
unsafe extern "C" {
6153
+
pub fn i_cal_property_get_duration(prop: *mut ICalProperty) -> *mut ICalDuration;
6154
+
}
6155
+
unsafe extern "C" {
6156
+
pub fn i_cal_property_new_estimatedduration(v: *mut ICalDuration) -> *mut ICalProperty;
6157
+
}
6158
+
unsafe extern "C" {
6159
+
pub fn i_cal_property_set_estimatedduration(prop: *mut ICalProperty, v: *mut ICalDuration);
6160
+
}
6161
+
unsafe extern "C" {
6162
+
pub fn i_cal_property_get_estimatedduration(prop: *mut ICalProperty) -> *mut ICalDuration;
6163
+
}
6164
+
unsafe extern "C" {
6165
+
pub fn i_cal_property_new_exdate(v: *mut ICalTime) -> *mut ICalProperty;
6166
+
}
6167
+
unsafe extern "C" {
6168
+
pub fn i_cal_property_set_exdate(prop: *mut ICalProperty, v: *mut ICalTime);
6169
+
}
6170
+
unsafe extern "C" {
6171
+
pub fn i_cal_property_get_exdate(prop: *mut ICalProperty) -> *mut ICalTime;
6172
+
}
6173
+
unsafe extern "C" {
6174
+
pub fn i_cal_property_new_expand(v: gint) -> *mut ICalProperty;
6175
+
}
6176
+
unsafe extern "C" {
6177
+
pub fn i_cal_property_set_expand(prop: *mut ICalProperty, v: gint);
6178
+
}
6179
+
unsafe extern "C" {
6180
+
pub fn i_cal_property_get_expand(prop: *mut ICalProperty) -> gint;
6181
+
}
6182
+
unsafe extern "C" {
6183
+
pub fn i_cal_property_new_exrule(v: *mut ICalRecurrence) -> *mut ICalProperty;
6184
+
}
6185
+
unsafe extern "C" {
6186
+
pub fn i_cal_property_set_exrule(prop: *mut ICalProperty, v: *mut ICalRecurrence);
6187
+
}
6188
+
unsafe extern "C" {
6189
+
pub fn i_cal_property_get_exrule(prop: *mut ICalProperty) -> *mut ICalRecurrence;
6190
+
}
6191
+
unsafe extern "C" {
6192
+
pub fn i_cal_property_new_freebusy(v: *mut ICalPeriod) -> *mut ICalProperty;
6193
+
}
6194
+
unsafe extern "C" {
6195
+
pub fn i_cal_property_set_freebusy(prop: *mut ICalProperty, v: *mut ICalPeriod);
6196
+
}
6197
+
unsafe extern "C" {
6198
+
pub fn i_cal_property_get_freebusy(prop: *mut ICalProperty) -> *mut ICalPeriod;
6199
+
}
6200
+
unsafe extern "C" {
6201
+
pub fn i_cal_property_new_geo(v: *mut ICalGeo) -> *mut ICalProperty;
6202
+
}
6203
+
unsafe extern "C" {
6204
+
pub fn i_cal_property_set_geo(prop: *mut ICalProperty, v: *mut ICalGeo);
6205
+
}
6206
+
unsafe extern "C" {
6207
+
pub fn i_cal_property_get_geo(prop: *mut ICalProperty) -> *mut ICalGeo;
6208
+
}
6209
+
unsafe extern "C" {
6210
+
pub fn i_cal_property_new_grant(v: *const gchar) -> *mut ICalProperty;
6211
+
}
6212
+
unsafe extern "C" {
6213
+
pub fn i_cal_property_set_grant(prop: *mut ICalProperty, v: *const gchar);
6214
+
}
6215
+
unsafe extern "C" {
6216
+
pub fn i_cal_property_get_grant(prop: *mut ICalProperty) -> *const gchar;
6217
+
}
6218
+
unsafe extern "C" {
6219
+
pub fn i_cal_property_new_itipversion(v: *const gchar) -> *mut ICalProperty;
6220
+
}
6221
+
unsafe extern "C" {
6222
+
pub fn i_cal_property_set_itipversion(prop: *mut ICalProperty, v: *const gchar);
6223
+
}
6224
+
unsafe extern "C" {
6225
+
pub fn i_cal_property_get_itipversion(prop: *mut ICalProperty) -> *const gchar;
6226
+
}
6227
+
unsafe extern "C" {
6228
+
pub fn i_cal_property_new_lastmodified(v: *mut ICalTime) -> *mut ICalProperty;
6229
+
}
6230
+
unsafe extern "C" {
6231
+
pub fn i_cal_property_set_lastmodified(prop: *mut ICalProperty, v: *mut ICalTime);
6232
+
}
6233
+
unsafe extern "C" {
6234
+
pub fn i_cal_property_get_lastmodified(prop: *mut ICalProperty) -> *mut ICalTime;
6235
+
}
6236
+
unsafe extern "C" {
6237
+
pub fn i_cal_property_new_location(v: *const gchar) -> *mut ICalProperty;
6238
+
}
6239
+
unsafe extern "C" {
6240
+
pub fn i_cal_property_set_location(prop: *mut ICalProperty, v: *const gchar);
6241
+
}
6242
+
unsafe extern "C" {
6243
+
pub fn i_cal_property_get_location(prop: *mut ICalProperty) -> *const gchar;
6244
+
}
6245
+
unsafe extern "C" {
6246
+
pub fn i_cal_property_new_maxcomponentsize(v: gint) -> *mut ICalProperty;
6247
+
}
6248
+
unsafe extern "C" {
6249
+
pub fn i_cal_property_set_maxcomponentsize(prop: *mut ICalProperty, v: gint);
6250
+
}
6251
+
unsafe extern "C" {
6252
+
pub fn i_cal_property_get_maxcomponentsize(prop: *mut ICalProperty) -> gint;
6253
+
}
6254
+
unsafe extern "C" {
6255
+
pub fn i_cal_property_new_maxdate(v: *mut ICalTime) -> *mut ICalProperty;
6256
+
}
6257
+
unsafe extern "C" {
6258
+
pub fn i_cal_property_set_maxdate(prop: *mut ICalProperty, v: *mut ICalTime);
6259
+
}
6260
+
unsafe extern "C" {
6261
+
pub fn i_cal_property_get_maxdate(prop: *mut ICalProperty) -> *mut ICalTime;
6262
+
}
6263
+
unsafe extern "C" {
6264
+
pub fn i_cal_property_new_maxresults(v: gint) -> *mut ICalProperty;
6265
+
}
6266
+
unsafe extern "C" {
6267
+
pub fn i_cal_property_set_maxresults(prop: *mut ICalProperty, v: gint);
6268
+
}
6269
+
unsafe extern "C" {
6270
+
pub fn i_cal_property_get_maxresults(prop: *mut ICalProperty) -> gint;
6271
+
}
6272
+
unsafe extern "C" {
6273
+
pub fn i_cal_property_new_maxresultssize(v: gint) -> *mut ICalProperty;
6274
+
}
6275
+
unsafe extern "C" {
6276
+
pub fn i_cal_property_set_maxresultssize(prop: *mut ICalProperty, v: gint);
6277
+
}
6278
+
unsafe extern "C" {
6279
+
pub fn i_cal_property_get_maxresultssize(prop: *mut ICalProperty) -> gint;
6280
+
}
6281
+
unsafe extern "C" {
6282
+
pub fn i_cal_property_new_method(v: ICalPropertyMethod) -> *mut ICalProperty;
6283
+
}
6284
+
unsafe extern "C" {
6285
+
pub fn i_cal_property_set_method(prop: *mut ICalProperty, v: ICalPropertyMethod);
6286
+
}
6287
+
unsafe extern "C" {
6288
+
pub fn i_cal_property_get_method(prop: *mut ICalProperty) -> ICalPropertyMethod;
6289
+
}
6290
+
unsafe extern "C" {
6291
+
pub fn i_cal_property_new_mindate(v: *mut ICalTime) -> *mut ICalProperty;
6292
+
}
6293
+
unsafe extern "C" {
6294
+
pub fn i_cal_property_set_mindate(prop: *mut ICalProperty, v: *mut ICalTime);
6295
+
}
6296
+
unsafe extern "C" {
6297
+
pub fn i_cal_property_get_mindate(prop: *mut ICalProperty) -> *mut ICalTime;
6298
+
}
6299
+
unsafe extern "C" {
6300
+
pub fn i_cal_property_new_multipart(v: *const gchar) -> *mut ICalProperty;
6301
+
}
6302
+
unsafe extern "C" {
6303
+
pub fn i_cal_property_set_multipart(prop: *mut ICalProperty, v: *const gchar);
6304
+
}
6305
+
unsafe extern "C" {
6306
+
pub fn i_cal_property_get_multipart(prop: *mut ICalProperty) -> *const gchar;
6307
+
}
6308
+
unsafe extern "C" {
6309
+
pub fn i_cal_property_new_name(v: *const gchar) -> *mut ICalProperty;
6310
+
}
6311
+
unsafe extern "C" {
6312
+
pub fn i_cal_property_set_name(prop: *mut ICalProperty, v: *const gchar);
6313
+
}
6314
+
unsafe extern "C" {
6315
+
pub fn i_cal_property_get_name(prop: *mut ICalProperty) -> *const gchar;
6316
+
}
6317
+
unsafe extern "C" {
6318
+
pub fn i_cal_property_new_organizer(v: *const gchar) -> *mut ICalProperty;
6319
+
}
6320
+
unsafe extern "C" {
6321
+
pub fn i_cal_property_set_organizer(prop: *mut ICalProperty, v: *const gchar);
6322
+
}
6323
+
unsafe extern "C" {
6324
+
pub fn i_cal_property_get_organizer(prop: *mut ICalProperty) -> *const gchar;
6325
+
}
6326
+
unsafe extern "C" {
6327
+
pub fn i_cal_property_new_owner(v: *const gchar) -> *mut ICalProperty;
6328
+
}
6329
+
unsafe extern "C" {
6330
+
pub fn i_cal_property_set_owner(prop: *mut ICalProperty, v: *const gchar);
6331
+
}
6332
+
unsafe extern "C" {
6333
+
pub fn i_cal_property_get_owner(prop: *mut ICalProperty) -> *const gchar;
6334
+
}
6335
+
unsafe extern "C" {
6336
+
pub fn i_cal_property_new_percentcomplete(v: gint) -> *mut ICalProperty;
6337
+
}
6338
+
unsafe extern "C" {
6339
+
pub fn i_cal_property_set_percentcomplete(prop: *mut ICalProperty, v: gint);
6340
+
}
6341
+
unsafe extern "C" {
6342
+
pub fn i_cal_property_get_percentcomplete(prop: *mut ICalProperty) -> gint;
6343
+
}
6344
+
unsafe extern "C" {
6345
+
pub fn i_cal_property_new_permission(v: *const gchar) -> *mut ICalProperty;
6346
+
}
6347
+
unsafe extern "C" {
6348
+
pub fn i_cal_property_set_permission(prop: *mut ICalProperty, v: *const gchar);
6349
+
}
6350
+
unsafe extern "C" {
6351
+
pub fn i_cal_property_get_permission(prop: *mut ICalProperty) -> *const gchar;
6352
+
}
6353
+
unsafe extern "C" {
6354
+
pub fn i_cal_property_new_pollcompletion(v: ICalPropertyPollcompletion) -> *mut ICalProperty;
6355
+
}
6356
+
unsafe extern "C" {
6357
+
pub fn i_cal_property_set_pollcompletion(
6358
+
prop: *mut ICalProperty,
6359
+
v: ICalPropertyPollcompletion,
6360
+
);
6361
+
}
6362
+
unsafe extern "C" {
6363
+
pub fn i_cal_property_get_pollcompletion(prop: *mut ICalProperty)
6364
+
-> ICalPropertyPollcompletion;
6365
+
}
6366
+
unsafe extern "C" {
6367
+
pub fn i_cal_property_new_pollitemid(v: gint) -> *mut ICalProperty;
6368
+
}
6369
+
unsafe extern "C" {
6370
+
pub fn i_cal_property_set_pollitemid(prop: *mut ICalProperty, v: gint);
6371
+
}
6372
+
unsafe extern "C" {
6373
+
pub fn i_cal_property_get_pollitemid(prop: *mut ICalProperty) -> gint;
6374
+
}
6375
+
unsafe extern "C" {
6376
+
pub fn i_cal_property_new_pollmode(v: ICalPropertyPollmode) -> *mut ICalProperty;
6377
+
}
6378
+
unsafe extern "C" {
6379
+
pub fn i_cal_property_set_pollmode(prop: *mut ICalProperty, v: ICalPropertyPollmode);
6380
+
}
6381
+
unsafe extern "C" {
6382
+
pub fn i_cal_property_get_pollmode(prop: *mut ICalProperty) -> ICalPropertyPollmode;
6383
+
}
6384
+
unsafe extern "C" {
6385
+
pub fn i_cal_property_new_pollproperties(v: *const gchar) -> *mut ICalProperty;
6386
+
}
6387
+
unsafe extern "C" {
6388
+
pub fn i_cal_property_set_pollproperties(prop: *mut ICalProperty, v: *const gchar);
6389
+
}
6390
+
unsafe extern "C" {
6391
+
pub fn i_cal_property_get_pollproperties(prop: *mut ICalProperty) -> *const gchar;
6392
+
}
6393
+
unsafe extern "C" {
6394
+
pub fn i_cal_property_new_pollwinner(v: gint) -> *mut ICalProperty;
6395
+
}
6396
+
unsafe extern "C" {
6397
+
pub fn i_cal_property_set_pollwinner(prop: *mut ICalProperty, v: gint);
6398
+
}
6399
+
unsafe extern "C" {
6400
+
pub fn i_cal_property_get_pollwinner(prop: *mut ICalProperty) -> gint;
6401
+
}
6402
+
unsafe extern "C" {
6403
+
pub fn i_cal_property_new_priority(v: gint) -> *mut ICalProperty;
6404
+
}
6405
+
unsafe extern "C" {
6406
+
pub fn i_cal_property_set_priority(prop: *mut ICalProperty, v: gint);
6407
+
}
6408
+
unsafe extern "C" {
6409
+
pub fn i_cal_property_get_priority(prop: *mut ICalProperty) -> gint;
6410
+
}
6411
+
unsafe extern "C" {
6412
+
pub fn i_cal_property_new_prodid(v: *const gchar) -> *mut ICalProperty;
6413
+
}
6414
+
unsafe extern "C" {
6415
+
pub fn i_cal_property_set_prodid(prop: *mut ICalProperty, v: *const gchar);
6416
+
}
6417
+
unsafe extern "C" {
6418
+
pub fn i_cal_property_get_prodid(prop: *mut ICalProperty) -> *const gchar;
6419
+
}
6420
+
unsafe extern "C" {
6421
+
pub fn i_cal_property_new_query(v: *const gchar) -> *mut ICalProperty;
6422
+
}
6423
+
unsafe extern "C" {
6424
+
pub fn i_cal_property_set_query(prop: *mut ICalProperty, v: *const gchar);
6425
+
}
6426
+
unsafe extern "C" {
6427
+
pub fn i_cal_property_get_query(prop: *mut ICalProperty) -> *const gchar;
6428
+
}
6429
+
unsafe extern "C" {
6430
+
pub fn i_cal_property_new_querylevel(v: ICalPropertyQuerylevel) -> *mut ICalProperty;
6431
+
}
6432
+
unsafe extern "C" {
6433
+
pub fn i_cal_property_set_querylevel(prop: *mut ICalProperty, v: ICalPropertyQuerylevel);
6434
+
}
6435
+
unsafe extern "C" {
6436
+
pub fn i_cal_property_get_querylevel(prop: *mut ICalProperty) -> ICalPropertyQuerylevel;
6437
+
}
6438
+
unsafe extern "C" {
6439
+
pub fn i_cal_property_new_queryid(v: *const gchar) -> *mut ICalProperty;
6440
+
}
6441
+
unsafe extern "C" {
6442
+
pub fn i_cal_property_set_queryid(prop: *mut ICalProperty, v: *const gchar);
6443
+
}
6444
+
unsafe extern "C" {
6445
+
pub fn i_cal_property_get_queryid(prop: *mut ICalProperty) -> *const gchar;
6446
+
}
6447
+
unsafe extern "C" {
6448
+
pub fn i_cal_property_new_queryname(v: *const gchar) -> *mut ICalProperty;
6449
+
}
6450
+
unsafe extern "C" {
6451
+
pub fn i_cal_property_set_queryname(prop: *mut ICalProperty, v: *const gchar);
6452
+
}
6453
+
unsafe extern "C" {
6454
+
pub fn i_cal_property_get_queryname(prop: *mut ICalProperty) -> *const gchar;
6455
+
}
6456
+
unsafe extern "C" {
6457
+
pub fn i_cal_property_new_rdate(v: *mut ICalDatetimeperiod) -> *mut ICalProperty;
6458
+
}
6459
+
unsafe extern "C" {
6460
+
pub fn i_cal_property_set_rdate(prop: *mut ICalProperty, v: *mut ICalDatetimeperiod);
6461
+
}
6462
+
unsafe extern "C" {
6463
+
pub fn i_cal_property_get_rdate(prop: *mut ICalProperty) -> *mut ICalDatetimeperiod;
6464
+
}
6465
+
unsafe extern "C" {
6466
+
pub fn i_cal_property_new_recuraccepted(v: *const gchar) -> *mut ICalProperty;
6467
+
}
6468
+
unsafe extern "C" {
6469
+
pub fn i_cal_property_set_recuraccepted(prop: *mut ICalProperty, v: *const gchar);
6470
+
}
6471
+
unsafe extern "C" {
6472
+
pub fn i_cal_property_get_recuraccepted(prop: *mut ICalProperty) -> *const gchar;
6473
+
}
6474
+
unsafe extern "C" {
6475
+
pub fn i_cal_property_new_recurexpand(v: *const gchar) -> *mut ICalProperty;
6476
+
}
6477
+
unsafe extern "C" {
6478
+
pub fn i_cal_property_set_recurexpand(prop: *mut ICalProperty, v: *const gchar);
6479
+
}
6480
+
unsafe extern "C" {
6481
+
pub fn i_cal_property_get_recurexpand(prop: *mut ICalProperty) -> *const gchar;
6482
+
}
6483
+
unsafe extern "C" {
6484
+
pub fn i_cal_property_new_recurlimit(v: *const gchar) -> *mut ICalProperty;
6485
+
}
6486
+
unsafe extern "C" {
6487
+
pub fn i_cal_property_set_recurlimit(prop: *mut ICalProperty, v: *const gchar);
6488
+
}
6489
+
unsafe extern "C" {
6490
+
pub fn i_cal_property_get_recurlimit(prop: *mut ICalProperty) -> *const gchar;
6491
+
}
6492
+
unsafe extern "C" {
6493
+
pub fn i_cal_property_new_recurrenceid(v: *mut ICalTime) -> *mut ICalProperty;
6494
+
}
6495
+
unsafe extern "C" {
6496
+
pub fn i_cal_property_set_recurrenceid(prop: *mut ICalProperty, v: *mut ICalTime);
6497
+
}
6498
+
unsafe extern "C" {
6499
+
pub fn i_cal_property_get_recurrenceid(prop: *mut ICalProperty) -> *mut ICalTime;
6500
+
}
6501
+
unsafe extern "C" {
6502
+
pub fn i_cal_property_new_relatedto(v: *const gchar) -> *mut ICalProperty;
6503
+
}
6504
+
unsafe extern "C" {
6505
+
pub fn i_cal_property_set_relatedto(prop: *mut ICalProperty, v: *const gchar);
6506
+
}
6507
+
unsafe extern "C" {
6508
+
pub fn i_cal_property_get_relatedto(prop: *mut ICalProperty) -> *const gchar;
6509
+
}
6510
+
unsafe extern "C" {
6511
+
pub fn i_cal_property_new_relcalid(v: *const gchar) -> *mut ICalProperty;
6512
+
}
6513
+
unsafe extern "C" {
6514
+
pub fn i_cal_property_set_relcalid(prop: *mut ICalProperty, v: *const gchar);
6515
+
}
6516
+
unsafe extern "C" {
6517
+
pub fn i_cal_property_get_relcalid(prop: *mut ICalProperty) -> *const gchar;
6518
+
}
6519
+
unsafe extern "C" {
6520
+
pub fn i_cal_property_new_repeat(v: gint) -> *mut ICalProperty;
6521
+
}
6522
+
unsafe extern "C" {
6523
+
pub fn i_cal_property_set_repeat(prop: *mut ICalProperty, v: gint);
6524
+
}
6525
+
unsafe extern "C" {
6526
+
pub fn i_cal_property_get_repeat(prop: *mut ICalProperty) -> gint;
6527
+
}
6528
+
unsafe extern "C" {
6529
+
pub fn i_cal_property_new_replyurl(v: *const gchar) -> *mut ICalProperty;
6530
+
}
6531
+
unsafe extern "C" {
6532
+
pub fn i_cal_property_set_replyurl(prop: *mut ICalProperty, v: *const gchar);
6533
+
}
6534
+
unsafe extern "C" {
6535
+
pub fn i_cal_property_get_replyurl(prop: *mut ICalProperty) -> *const gchar;
6536
+
}
6537
+
unsafe extern "C" {
6538
+
pub fn i_cal_property_new_requeststatus(v: *mut ICalReqstat) -> *mut ICalProperty;
6539
+
}
6540
+
unsafe extern "C" {
6541
+
pub fn i_cal_property_set_requeststatus(prop: *mut ICalProperty, v: *mut ICalReqstat);
6542
+
}
6543
+
unsafe extern "C" {
6544
+
pub fn i_cal_property_get_requeststatus(prop: *mut ICalProperty) -> *mut ICalReqstat;
6545
+
}
6546
+
unsafe extern "C" {
6547
+
pub fn i_cal_property_new_resources(v: *const gchar) -> *mut ICalProperty;
6548
+
}
6549
+
unsafe extern "C" {
6550
+
pub fn i_cal_property_set_resources(prop: *mut ICalProperty, v: *const gchar);
6551
+
}
6552
+
unsafe extern "C" {
6553
+
pub fn i_cal_property_get_resources(prop: *mut ICalProperty) -> *const gchar;
6554
+
}
6555
+
unsafe extern "C" {
6556
+
pub fn i_cal_property_new_response(v: gint) -> *mut ICalProperty;
6557
+
}
6558
+
unsafe extern "C" {
6559
+
pub fn i_cal_property_set_response(prop: *mut ICalProperty, v: gint);
6560
+
}
6561
+
unsafe extern "C" {
6562
+
pub fn i_cal_property_get_response(prop: *mut ICalProperty) -> gint;
6563
+
}
6564
+
unsafe extern "C" {
6565
+
pub fn i_cal_property_new_restriction(v: *const gchar) -> *mut ICalProperty;
6566
+
}
6567
+
unsafe extern "C" {
6568
+
pub fn i_cal_property_set_restriction(prop: *mut ICalProperty, v: *const gchar);
6569
+
}
6570
+
unsafe extern "C" {
6571
+
pub fn i_cal_property_get_restriction(prop: *mut ICalProperty) -> *const gchar;
6572
+
}
6573
+
unsafe extern "C" {
6574
+
pub fn i_cal_property_new_rrule(v: *mut ICalRecurrence) -> *mut ICalProperty;
6575
+
}
6576
+
unsafe extern "C" {
6577
+
pub fn i_cal_property_set_rrule(prop: *mut ICalProperty, v: *mut ICalRecurrence);
6578
+
}
6579
+
unsafe extern "C" {
6580
+
pub fn i_cal_property_get_rrule(prop: *mut ICalProperty) -> *mut ICalRecurrence;
6581
+
}
6582
+
unsafe extern "C" {
6583
+
pub fn i_cal_property_new_scope(v: *const gchar) -> *mut ICalProperty;
6584
+
}
6585
+
unsafe extern "C" {
6586
+
pub fn i_cal_property_set_scope(prop: *mut ICalProperty, v: *const gchar);
6587
+
}
6588
+
unsafe extern "C" {
6589
+
pub fn i_cal_property_get_scope(prop: *mut ICalProperty) -> *const gchar;
6590
+
}
6591
+
unsafe extern "C" {
6592
+
pub fn i_cal_property_new_sequence(v: gint) -> *mut ICalProperty;
6593
+
}
6594
+
unsafe extern "C" {
6595
+
pub fn i_cal_property_set_sequence(prop: *mut ICalProperty, v: gint);
6596
+
}
6597
+
unsafe extern "C" {
6598
+
pub fn i_cal_property_get_sequence(prop: *mut ICalProperty) -> gint;
6599
+
}
6600
+
unsafe extern "C" {
6601
+
pub fn i_cal_property_new_status(v: ICalPropertyStatus) -> *mut ICalProperty;
6602
+
}
6603
+
unsafe extern "C" {
6604
+
pub fn i_cal_property_set_status(prop: *mut ICalProperty, v: ICalPropertyStatus);
6605
+
}
6606
+
unsafe extern "C" {
6607
+
pub fn i_cal_property_get_status(prop: *mut ICalProperty) -> ICalPropertyStatus;
6608
+
}
6609
+
unsafe extern "C" {
6610
+
pub fn i_cal_property_new_storesexpanded(v: *const gchar) -> *mut ICalProperty;
6611
+
}
6612
+
unsafe extern "C" {
6613
+
pub fn i_cal_property_set_storesexpanded(prop: *mut ICalProperty, v: *const gchar);
6614
+
}
6615
+
unsafe extern "C" {
6616
+
pub fn i_cal_property_get_storesexpanded(prop: *mut ICalProperty) -> *const gchar;
6617
+
}
6618
+
unsafe extern "C" {
6619
+
pub fn i_cal_property_new_summary(v: *const gchar) -> *mut ICalProperty;
6620
+
}
6621
+
unsafe extern "C" {
6622
+
pub fn i_cal_property_set_summary(prop: *mut ICalProperty, v: *const gchar);
6623
+
}
6624
+
unsafe extern "C" {
6625
+
pub fn i_cal_property_get_summary(prop: *mut ICalProperty) -> *const gchar;
6626
+
}
6627
+
unsafe extern "C" {
6628
+
pub fn i_cal_property_new_target(v: *const gchar) -> *mut ICalProperty;
6629
+
}
6630
+
unsafe extern "C" {
6631
+
pub fn i_cal_property_set_target(prop: *mut ICalProperty, v: *const gchar);
6632
+
}
6633
+
unsafe extern "C" {
6634
+
pub fn i_cal_property_get_target(prop: *mut ICalProperty) -> *const gchar;
6635
+
}
6636
+
unsafe extern "C" {
6637
+
pub fn i_cal_property_new_taskmode(v: ICalPropertyTaskmode) -> *mut ICalProperty;
6638
+
}
6639
+
unsafe extern "C" {
6640
+
pub fn i_cal_property_set_taskmode(prop: *mut ICalProperty, v: ICalPropertyTaskmode);
6641
+
}
6642
+
unsafe extern "C" {
6643
+
pub fn i_cal_property_get_taskmode(prop: *mut ICalProperty) -> ICalPropertyTaskmode;
6644
+
}
6645
+
unsafe extern "C" {
6646
+
pub fn i_cal_property_new_transp(v: ICalPropertyTransp) -> *mut ICalProperty;
6647
+
}
6648
+
unsafe extern "C" {
6649
+
pub fn i_cal_property_set_transp(prop: *mut ICalProperty, v: ICalPropertyTransp);
6650
+
}
6651
+
unsafe extern "C" {
6652
+
pub fn i_cal_property_get_transp(prop: *mut ICalProperty) -> ICalPropertyTransp;
6653
+
}
6654
+
unsafe extern "C" {
6655
+
pub fn i_cal_property_new_trigger(v: *mut ICalTrigger) -> *mut ICalProperty;
6656
+
}
6657
+
unsafe extern "C" {
6658
+
pub fn i_cal_property_set_trigger(prop: *mut ICalProperty, v: *mut ICalTrigger);
6659
+
}
6660
+
unsafe extern "C" {
6661
+
pub fn i_cal_property_get_trigger(prop: *mut ICalProperty) -> *mut ICalTrigger;
6662
+
}
6663
+
unsafe extern "C" {
6664
+
pub fn i_cal_property_new_tzid(v: *const gchar) -> *mut ICalProperty;
6665
+
}
6666
+
unsafe extern "C" {
6667
+
pub fn i_cal_property_set_tzid(prop: *mut ICalProperty, v: *const gchar);
6668
+
}
6669
+
unsafe extern "C" {
6670
+
pub fn i_cal_property_get_tzid(prop: *mut ICalProperty) -> *const gchar;
6671
+
}
6672
+
unsafe extern "C" {
6673
+
pub fn i_cal_property_new_tzidaliasof(v: *const gchar) -> *mut ICalProperty;
6674
+
}
6675
+
unsafe extern "C" {
6676
+
pub fn i_cal_property_set_tzidaliasof(prop: *mut ICalProperty, v: *const gchar);
6677
+
}
6678
+
unsafe extern "C" {
6679
+
pub fn i_cal_property_get_tzidaliasof(prop: *mut ICalProperty) -> *const gchar;
6680
+
}
6681
+
unsafe extern "C" {
6682
+
pub fn i_cal_property_new_tzname(v: *const gchar) -> *mut ICalProperty;
6683
+
}
6684
+
unsafe extern "C" {
6685
+
pub fn i_cal_property_set_tzname(prop: *mut ICalProperty, v: *const gchar);
6686
+
}
6687
+
unsafe extern "C" {
6688
+
pub fn i_cal_property_get_tzname(prop: *mut ICalProperty) -> *const gchar;
6689
+
}
6690
+
unsafe extern "C" {
6691
+
pub fn i_cal_property_new_tzoffsetfrom(v: gint) -> *mut ICalProperty;
6692
+
}
6693
+
unsafe extern "C" {
6694
+
pub fn i_cal_property_set_tzoffsetfrom(prop: *mut ICalProperty, v: gint);
6695
+
}
6696
+
unsafe extern "C" {
6697
+
pub fn i_cal_property_get_tzoffsetfrom(prop: *mut ICalProperty) -> gint;
6698
+
}
6699
+
unsafe extern "C" {
6700
+
pub fn i_cal_property_new_tzoffsetto(v: gint) -> *mut ICalProperty;
6701
+
}
6702
+
unsafe extern "C" {
6703
+
pub fn i_cal_property_set_tzoffsetto(prop: *mut ICalProperty, v: gint);
6704
+
}
6705
+
unsafe extern "C" {
6706
+
pub fn i_cal_property_get_tzoffsetto(prop: *mut ICalProperty) -> gint;
6707
+
}
6708
+
unsafe extern "C" {
6709
+
pub fn i_cal_property_new_tzuntil(v: *mut ICalTime) -> *mut ICalProperty;
6710
+
}
6711
+
unsafe extern "C" {
6712
+
pub fn i_cal_property_set_tzuntil(prop: *mut ICalProperty, v: *mut ICalTime);
6713
+
}
6714
+
unsafe extern "C" {
6715
+
pub fn i_cal_property_get_tzuntil(prop: *mut ICalProperty) -> *mut ICalTime;
6716
+
}
6717
+
unsafe extern "C" {
6718
+
pub fn i_cal_property_new_tzurl(v: *const gchar) -> *mut ICalProperty;
6719
+
}
6720
+
unsafe extern "C" {
6721
+
pub fn i_cal_property_set_tzurl(prop: *mut ICalProperty, v: *const gchar);
6722
+
}
6723
+
unsafe extern "C" {
6724
+
pub fn i_cal_property_get_tzurl(prop: *mut ICalProperty) -> *const gchar;
6725
+
}
6726
+
unsafe extern "C" {
6727
+
pub fn i_cal_property_new_uid(v: *const gchar) -> *mut ICalProperty;
6728
+
}
6729
+
unsafe extern "C" {
6730
+
pub fn i_cal_property_set_uid(prop: *mut ICalProperty, v: *const gchar);
6731
+
}
6732
+
unsafe extern "C" {
6733
+
pub fn i_cal_property_get_uid(prop: *mut ICalProperty) -> *const gchar;
6734
+
}
6735
+
unsafe extern "C" {
6736
+
pub fn i_cal_property_new_url(v: *const gchar) -> *mut ICalProperty;
6737
+
}
6738
+
unsafe extern "C" {
6739
+
pub fn i_cal_property_set_url(prop: *mut ICalProperty, v: *const gchar);
6740
+
}
6741
+
unsafe extern "C" {
6742
+
pub fn i_cal_property_get_url(prop: *mut ICalProperty) -> *const gchar;
6743
+
}
6744
+
unsafe extern "C" {
6745
+
pub fn i_cal_property_new_version(v: *const gchar) -> *mut ICalProperty;
6746
+
}
6747
+
unsafe extern "C" {
6748
+
pub fn i_cal_property_set_version(prop: *mut ICalProperty, v: *const gchar);
6749
+
}
6750
+
unsafe extern "C" {
6751
+
pub fn i_cal_property_get_version(prop: *mut ICalProperty) -> *const gchar;
6752
+
}
6753
+
unsafe extern "C" {
6754
+
pub fn i_cal_property_new_voter(v: *const gchar) -> *mut ICalProperty;
6755
+
}
6756
+
unsafe extern "C" {
6757
+
pub fn i_cal_property_set_voter(prop: *mut ICalProperty, v: *const gchar);
6758
+
}
6759
+
unsafe extern "C" {
6760
+
pub fn i_cal_property_get_voter(prop: *mut ICalProperty) -> *const gchar;
6761
+
}
6762
+
unsafe extern "C" {
6763
+
pub fn i_cal_property_new_x(v: *const gchar) -> *mut ICalProperty;
6764
+
}
6765
+
unsafe extern "C" {
6766
+
pub fn i_cal_property_set_x(prop: *mut ICalProperty, v: *const gchar);
6767
+
}
6768
+
unsafe extern "C" {
6769
+
pub fn i_cal_property_get_x(prop: *mut ICalProperty) -> *const gchar;
6770
+
}
6771
+
unsafe extern "C" {
6772
+
pub fn i_cal_property_new_xlicclass(v: ICalPropertyXlicclass) -> *mut ICalProperty;
6773
+
}
6774
+
unsafe extern "C" {
6775
+
pub fn i_cal_property_set_xlicclass(prop: *mut ICalProperty, v: ICalPropertyXlicclass);
6776
+
}
6777
+
unsafe extern "C" {
6778
+
pub fn i_cal_property_get_xlicclass(prop: *mut ICalProperty) -> ICalPropertyXlicclass;
6779
+
}
6780
+
unsafe extern "C" {
6781
+
pub fn i_cal_property_new_xlicclustercount(v: *const gchar) -> *mut ICalProperty;
6782
+
}
6783
+
unsafe extern "C" {
6784
+
pub fn i_cal_property_set_xlicclustercount(prop: *mut ICalProperty, v: *const gchar);
6785
+
}
6786
+
unsafe extern "C" {
6787
+
pub fn i_cal_property_get_xlicclustercount(prop: *mut ICalProperty) -> *const gchar;
6788
+
}
6789
+
unsafe extern "C" {
6790
+
pub fn i_cal_property_new_xlicerror(v: *const gchar) -> *mut ICalProperty;
6791
+
}
6792
+
unsafe extern "C" {
6793
+
pub fn i_cal_property_set_xlicerror(prop: *mut ICalProperty, v: *const gchar);
6794
+
}
6795
+
unsafe extern "C" {
6796
+
pub fn i_cal_property_get_xlicerror(prop: *mut ICalProperty) -> *const gchar;
6797
+
}
6798
+
unsafe extern "C" {
6799
+
pub fn i_cal_property_new_xlicmimecharset(v: *const gchar) -> *mut ICalProperty;
6800
+
}
6801
+
unsafe extern "C" {
6802
+
pub fn i_cal_property_set_xlicmimecharset(prop: *mut ICalProperty, v: *const gchar);
6803
+
}
6804
+
unsafe extern "C" {
6805
+
pub fn i_cal_property_get_xlicmimecharset(prop: *mut ICalProperty) -> *const gchar;
6806
+
}
6807
+
unsafe extern "C" {
6808
+
pub fn i_cal_property_new_xlicmimecid(v: *const gchar) -> *mut ICalProperty;
6809
+
}
6810
+
unsafe extern "C" {
6811
+
pub fn i_cal_property_set_xlicmimecid(prop: *mut ICalProperty, v: *const gchar);
6812
+
}
6813
+
unsafe extern "C" {
6814
+
pub fn i_cal_property_get_xlicmimecid(prop: *mut ICalProperty) -> *const gchar;
6815
+
}
6816
+
unsafe extern "C" {
6817
+
pub fn i_cal_property_new_xlicmimecontenttype(v: *const gchar) -> *mut ICalProperty;
6818
+
}
6819
+
unsafe extern "C" {
6820
+
pub fn i_cal_property_set_xlicmimecontenttype(prop: *mut ICalProperty, v: *const gchar);
6821
+
}
6822
+
unsafe extern "C" {
6823
+
pub fn i_cal_property_get_xlicmimecontenttype(prop: *mut ICalProperty) -> *const gchar;
6824
+
}
6825
+
unsafe extern "C" {
6826
+
pub fn i_cal_property_new_xlicmimeencoding(v: *const gchar) -> *mut ICalProperty;
6827
+
}
6828
+
unsafe extern "C" {
6829
+
pub fn i_cal_property_set_xlicmimeencoding(prop: *mut ICalProperty, v: *const gchar);
6830
+
}
6831
+
unsafe extern "C" {
6832
+
pub fn i_cal_property_get_xlicmimeencoding(prop: *mut ICalProperty) -> *const gchar;
6833
+
}
6834
+
unsafe extern "C" {
6835
+
pub fn i_cal_property_new_xlicmimefilename(v: *const gchar) -> *mut ICalProperty;
6836
+
}
6837
+
unsafe extern "C" {
6838
+
pub fn i_cal_property_set_xlicmimefilename(prop: *mut ICalProperty, v: *const gchar);
6839
+
}
6840
+
unsafe extern "C" {
6841
+
pub fn i_cal_property_get_xlicmimefilename(prop: *mut ICalProperty) -> *const gchar;
6842
+
}
6843
+
unsafe extern "C" {
6844
+
pub fn i_cal_property_new_xlicmimeoptinfo(v: *const gchar) -> *mut ICalProperty;
6845
+
}
6846
+
unsafe extern "C" {
6847
+
pub fn i_cal_property_set_xlicmimeoptinfo(prop: *mut ICalProperty, v: *const gchar);
6848
+
}
6849
+
unsafe extern "C" {
6850
+
pub fn i_cal_property_get_xlicmimeoptinfo(prop: *mut ICalProperty) -> *const gchar;
6851
+
}
6852
+
#[repr(C)]
6853
+
#[derive(Debug, Copy, Clone)]
6854
+
pub struct _ICalComponent {
6855
+
pub parent: ICalObject,
6856
+
}
6857
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6858
+
const _: () = {
6859
+
["Size of _ICalComponent"][::std::mem::size_of::<_ICalComponent>() - 32usize];
6860
+
["Alignment of _ICalComponent"][::std::mem::align_of::<_ICalComponent>() - 8usize];
6861
+
["Offset of field: _ICalComponent::parent"]
6862
+
[::std::mem::offset_of!(_ICalComponent, parent) - 0usize];
6863
+
};
6864
+
pub type ICalComponentForeachTZIDFunc =
6865
+
::std::option::Option<unsafe extern "C" fn(param: *mut ICalParameter, user_data: gpointer)>;
6866
+
pub type ICalComponentForeachRecurrenceFunc = ::std::option::Option<
6867
+
unsafe extern "C" fn(comp: *mut ICalComponent, span: *mut ICalTimeSpan, user_data: gpointer),
6868
+
>;
6869
+
unsafe extern "C" {
6870
+
pub fn i_cal_component_get_type() -> GType;
6871
+
}
6872
+
unsafe extern "C" {
6873
+
pub fn i_cal_component_new(kind: ICalComponentKind) -> *mut ICalComponent;
6874
+
}
6875
+
unsafe extern "C" {
6876
+
pub fn i_cal_component_clone(component: *mut ICalComponent) -> *mut ICalComponent;
6877
+
}
6878
+
unsafe extern "C" {
6879
+
pub fn i_cal_component_new_from_string(str_: *const gchar) -> *mut ICalComponent;
6880
+
}
6881
+
unsafe extern "C" {
6882
+
pub fn i_cal_component_new_x(x_name: *const gchar) -> *mut ICalComponent;
6883
+
}
6884
+
unsafe extern "C" {
6885
+
pub fn i_cal_component_free(component: *mut ICalComponent);
6886
+
}
6887
+
unsafe extern "C" {
6888
+
pub fn i_cal_component_as_ical_string(component: *mut ICalComponent) -> *mut gchar;
6889
+
}
6890
+
unsafe extern "C" {
6891
+
pub fn i_cal_component_is_valid(component: *mut ICalComponent) -> gboolean;
6892
+
}
6893
+
unsafe extern "C" {
6894
+
pub fn i_cal_component_isa(component: *const ICalComponent) -> ICalComponentKind;
6895
+
}
6896
+
unsafe extern "C" {
6897
+
pub fn i_cal_component_isa_component(component: *mut ICalComponent) -> gint;
6898
+
}
6899
+
unsafe extern "C" {
6900
+
pub fn i_cal_component_add_property(component: *mut ICalComponent, property: *mut ICalProperty);
6901
+
}
6902
+
unsafe extern "C" {
6903
+
pub fn i_cal_component_take_property(
6904
+
component: *mut ICalComponent,
6905
+
property: *mut ICalProperty,
6906
+
);
6907
+
}
6908
+
unsafe extern "C" {
6909
+
pub fn i_cal_component_remove_property(
6910
+
component: *mut ICalComponent,
6911
+
property: *mut ICalProperty,
6912
+
);
6913
+
}
6914
+
unsafe extern "C" {
6915
+
pub fn i_cal_component_count_properties(
6916
+
component: *mut ICalComponent,
6917
+
kind: ICalPropertyKind,
6918
+
) -> gint;
6919
+
}
6920
+
unsafe extern "C" {
6921
+
pub fn i_cal_property_get_parent(property: *mut ICalProperty) -> *mut ICalComponent;
6922
+
}
6923
+
unsafe extern "C" {
6924
+
pub fn i_cal_property_set_parent(property: *mut ICalProperty, component: *mut ICalComponent);
6925
+
}
6926
+
unsafe extern "C" {
6927
+
pub fn i_cal_property_get_datetime_with_component(
6928
+
prop: *mut ICalProperty,
6929
+
comp: *mut ICalComponent,
6930
+
) -> *mut ICalTime;
6931
+
}
6932
+
unsafe extern "C" {
6933
+
pub fn i_cal_component_get_current_property(component: *mut ICalComponent)
6934
+
-> *mut ICalProperty;
6935
+
}
6936
+
unsafe extern "C" {
6937
+
pub fn i_cal_component_get_first_property(
6938
+
component: *mut ICalComponent,
6939
+
kind: ICalPropertyKind,
6940
+
) -> *mut ICalProperty;
6941
+
}
6942
+
unsafe extern "C" {
6943
+
pub fn i_cal_component_get_next_property(
6944
+
component: *mut ICalComponent,
6945
+
kind: ICalPropertyKind,
6946
+
) -> *mut ICalProperty;
6947
+
}
6948
+
unsafe extern "C" {
6949
+
pub fn i_cal_component_get_inner(comp: *mut ICalComponent) -> *mut ICalComponent;
6950
+
}
6951
+
unsafe extern "C" {
6952
+
pub fn i_cal_component_add_component(parent: *mut ICalComponent, child: *mut ICalComponent);
6953
+
}
6954
+
unsafe extern "C" {
6955
+
pub fn i_cal_component_take_component(parent: *mut ICalComponent, child: *mut ICalComponent);
6956
+
}
6957
+
unsafe extern "C" {
6958
+
pub fn i_cal_component_remove_component(parent: *mut ICalComponent, child: *mut ICalComponent);
6959
+
}
6960
+
unsafe extern "C" {
6961
+
pub fn i_cal_component_count_components(
6962
+
component: *mut ICalComponent,
6963
+
kind: ICalComponentKind,
6964
+
) -> gint;
6965
+
}
6966
+
unsafe extern "C" {
6967
+
pub fn i_cal_component_get_parent(component: *mut ICalComponent) -> *mut ICalComponent;
6968
+
}
6969
+
unsafe extern "C" {
6970
+
pub fn i_cal_component_set_parent(component: *mut ICalComponent, parent: *mut ICalComponent);
6971
+
}
6972
+
unsafe extern "C" {
6973
+
pub fn i_cal_component_merge_component(
6974
+
comp: *mut ICalComponent,
6975
+
comp_to_merge: *mut ICalComponent,
6976
+
);
6977
+
}
6978
+
unsafe extern "C" {
6979
+
pub fn i_cal_component_get_current_component(
6980
+
component: *mut ICalComponent,
6981
+
) -> *mut ICalComponent;
6982
+
}
6983
+
unsafe extern "C" {
6984
+
pub fn i_cal_component_get_first_component(
6985
+
component: *mut ICalComponent,
6986
+
kind: ICalComponentKind,
6987
+
) -> *mut ICalComponent;
6988
+
}
6989
+
unsafe extern "C" {
6990
+
pub fn i_cal_component_get_next_component(
6991
+
component: *mut ICalComponent,
6992
+
kind: ICalComponentKind,
6993
+
) -> *mut ICalComponent;
6994
+
}
6995
+
unsafe extern "C" {
6996
+
pub fn i_cal_component_begin_component(
6997
+
component: *mut ICalComponent,
6998
+
kind: ICalComponentKind,
6999
+
) -> *mut ICalCompIter;
7000
+
}
7001
+
unsafe extern "C" {
7002
+
pub fn i_cal_component_end_component(
7003
+
component: *mut ICalComponent,
7004
+
kind: ICalComponentKind,
7005
+
) -> *mut ICalCompIter;
7006
+
}
7007
+
unsafe extern "C" {
7008
+
pub fn i_cal_comp_iter_next(i: *mut ICalCompIter) -> *mut ICalComponent;
7009
+
}
7010
+
unsafe extern "C" {
7011
+
pub fn i_cal_comp_iter_prior(i: *mut ICalCompIter) -> *mut ICalComponent;
7012
+
}
7013
+
unsafe extern "C" {
7014
+
pub fn i_cal_comp_iter_deref(i: *mut ICalCompIter) -> *mut ICalComponent;
7015
+
}
7016
+
unsafe extern "C" {
7017
+
pub fn i_cal_component_check_restrictions(comp: *mut ICalComponent) -> gint;
7018
+
}
7019
+
unsafe extern "C" {
7020
+
pub fn i_cal_component_count_errors(comp: *mut ICalComponent) -> gint;
7021
+
}
7022
+
unsafe extern "C" {
7023
+
pub fn i_cal_component_strip_errors(comp: *mut ICalComponent);
7024
+
}
7025
+
unsafe extern "C" {
7026
+
pub fn i_cal_component_convert_errors(comp: *mut ICalComponent);
7027
+
}
7028
+
unsafe extern "C" {
7029
+
pub fn i_cal_component_kind_is_valid(kind: ICalComponentKind) -> gboolean;
7030
+
}
7031
+
unsafe extern "C" {
7032
+
pub fn i_cal_component_kind_from_string(string: *const gchar) -> ICalComponentKind;
7033
+
}
7034
+
unsafe extern "C" {
7035
+
pub fn i_cal_component_kind_to_string(kind: ICalComponentKind) -> *const gchar;
7036
+
}
7037
+
unsafe extern "C" {
7038
+
pub fn i_cal_component_get_first_real_component(c: *mut ICalComponent) -> *mut ICalComponent;
7039
+
}
7040
+
unsafe extern "C" {
7041
+
pub fn i_cal_component_get_span(comp: *mut ICalComponent) -> *mut ICalTimeSpan;
7042
+
}
7043
+
unsafe extern "C" {
7044
+
pub fn i_cal_component_set_dtstart(comp: *mut ICalComponent, v: *mut ICalTime);
7045
+
}
7046
+
unsafe extern "C" {
7047
+
pub fn i_cal_component_get_dtstart(comp: *mut ICalComponent) -> *mut ICalTime;
7048
+
}
7049
+
unsafe extern "C" {
7050
+
pub fn i_cal_component_set_dtend(comp: *mut ICalComponent, v: *mut ICalTime);
7051
+
}
7052
+
unsafe extern "C" {
7053
+
pub fn i_cal_component_get_dtend(comp: *mut ICalComponent) -> *mut ICalTime;
7054
+
}
7055
+
unsafe extern "C" {
7056
+
pub fn i_cal_component_set_due(comp: *mut ICalComponent, v: *mut ICalTime);
7057
+
}
7058
+
unsafe extern "C" {
7059
+
pub fn i_cal_component_get_due(comp: *mut ICalComponent) -> *mut ICalTime;
7060
+
}
7061
+
unsafe extern "C" {
7062
+
pub fn i_cal_component_set_duration(comp: *mut ICalComponent, v: *mut ICalDuration);
7063
+
}
7064
+
unsafe extern "C" {
7065
+
pub fn i_cal_component_get_duration(comp: *mut ICalComponent) -> *mut ICalDuration;
7066
+
}
7067
+
unsafe extern "C" {
7068
+
pub fn i_cal_component_set_method(comp: *mut ICalComponent, method: ICalPropertyMethod);
7069
+
}
7070
+
unsafe extern "C" {
7071
+
pub fn i_cal_component_get_method(comp: *mut ICalComponent) -> ICalPropertyMethod;
7072
+
}
7073
+
unsafe extern "C" {
7074
+
pub fn i_cal_component_set_dtstamp(comp: *mut ICalComponent, v: *mut ICalTime);
7075
+
}
7076
+
unsafe extern "C" {
7077
+
pub fn i_cal_component_get_dtstamp(comp: *mut ICalComponent) -> *mut ICalTime;
7078
+
}
7079
+
unsafe extern "C" {
7080
+
pub fn i_cal_component_set_summary(comp: *mut ICalComponent, v: *const gchar);
7081
+
}
7082
+
unsafe extern "C" {
7083
+
pub fn i_cal_component_get_summary(comp: *mut ICalComponent) -> *const gchar;
7084
+
}
7085
+
unsafe extern "C" {
7086
+
pub fn i_cal_component_set_comment(comp: *mut ICalComponent, v: *const gchar);
7087
+
}
7088
+
unsafe extern "C" {
7089
+
pub fn i_cal_component_get_comment(comp: *mut ICalComponent) -> *const gchar;
7090
+
}
7091
+
unsafe extern "C" {
7092
+
pub fn i_cal_component_set_uid(comp: *mut ICalComponent, v: *const gchar);
7093
+
}
7094
+
unsafe extern "C" {
7095
+
pub fn i_cal_component_get_uid(comp: *mut ICalComponent) -> *const gchar;
7096
+
}
7097
+
unsafe extern "C" {
7098
+
pub fn i_cal_component_set_relcalid(comp: *mut ICalComponent, v: *const gchar);
7099
+
}
7100
+
unsafe extern "C" {
7101
+
pub fn i_cal_component_get_relcalid(comp: *mut ICalComponent) -> *const gchar;
7102
+
}
7103
+
unsafe extern "C" {
7104
+
pub fn i_cal_component_set_recurrenceid(comp: *mut ICalComponent, v: *mut ICalTime);
7105
+
}
7106
+
unsafe extern "C" {
7107
+
pub fn i_cal_component_get_recurrenceid(comp: *mut ICalComponent) -> *mut ICalTime;
7108
+
}
7109
+
unsafe extern "C" {
7110
+
pub fn i_cal_component_set_description(comp: *mut ICalComponent, v: *const gchar);
7111
+
}
7112
+
unsafe extern "C" {
7113
+
pub fn i_cal_component_get_description(comp: *mut ICalComponent) -> *const gchar;
7114
+
}
7115
+
unsafe extern "C" {
7116
+
pub fn i_cal_component_set_location(comp: *mut ICalComponent, v: *const gchar);
7117
+
}
7118
+
unsafe extern "C" {
7119
+
pub fn i_cal_component_get_location(comp: *mut ICalComponent) -> *const gchar;
7120
+
}
7121
+
unsafe extern "C" {
7122
+
pub fn i_cal_component_set_sequence(comp: *mut ICalComponent, v: gint);
7123
+
}
7124
+
unsafe extern "C" {
7125
+
pub fn i_cal_component_get_sequence(comp: *mut ICalComponent) -> gint;
7126
+
}
7127
+
unsafe extern "C" {
7128
+
pub fn i_cal_component_set_status(comp: *mut ICalComponent, status: ICalPropertyStatus);
7129
+
}
7130
+
unsafe extern "C" {
7131
+
pub fn i_cal_component_get_status(comp: *mut ICalComponent) -> ICalPropertyStatus;
7132
+
}
7133
+
unsafe extern "C" {
7134
+
pub fn i_cal_component_foreach_tzid(
7135
+
comp: *mut ICalComponent,
7136
+
callback: ICalComponentForeachTZIDFunc,
7137
+
user_data: gpointer,
7138
+
);
7139
+
}
7140
+
unsafe extern "C" {
7141
+
pub fn i_cal_component_foreach_recurrence(
7142
+
comp: *mut ICalComponent,
7143
+
start: *mut ICalTime,
7144
+
end: *mut ICalTime,
7145
+
callback: ICalComponentForeachRecurrenceFunc,
7146
+
user_data: gpointer,
7147
+
);
7148
+
}
7149
+
unsafe extern "C" {
7150
+
pub fn i_cal_component_get_timezone(
7151
+
comp: *mut ICalComponent,
7152
+
tzid: *const gchar,
7153
+
) -> *mut ICalTimezone;
7154
+
}
7155
+
unsafe extern "C" {
7156
+
pub fn i_cal_property_recurrence_is_excluded(
7157
+
comp: *mut ICalComponent,
7158
+
dtstart: *mut ICalTime,
7159
+
recurtime: *mut ICalTime,
7160
+
) -> gboolean;
7161
+
}
7162
+
unsafe extern "C" {
7163
+
pub fn i_cal_component_new_vcalendar() -> *mut ICalComponent;
7164
+
}
7165
+
unsafe extern "C" {
7166
+
pub fn i_cal_component_new_vevent() -> *mut ICalComponent;
7167
+
}
7168
+
unsafe extern "C" {
7169
+
pub fn i_cal_component_new_vtodo() -> *mut ICalComponent;
7170
+
}
7171
+
unsafe extern "C" {
7172
+
pub fn i_cal_component_new_vjournal() -> *mut ICalComponent;
7173
+
}
7174
+
unsafe extern "C" {
7175
+
pub fn i_cal_component_new_valarm() -> *mut ICalComponent;
7176
+
}
7177
+
unsafe extern "C" {
7178
+
pub fn i_cal_component_new_vfreebusy() -> *mut ICalComponent;
7179
+
}
7180
+
unsafe extern "C" {
7181
+
pub fn i_cal_component_new_vtimezone() -> *mut ICalComponent;
7182
+
}
7183
+
unsafe extern "C" {
7184
+
pub fn i_cal_component_new_xstandard() -> *mut ICalComponent;
7185
+
}
7186
+
unsafe extern "C" {
7187
+
pub fn i_cal_component_new_xdaylight() -> *mut ICalComponent;
7188
+
}
7189
+
unsafe extern "C" {
7190
+
pub fn i_cal_component_new_vagenda() -> *mut ICalComponent;
7191
+
}
7192
+
unsafe extern "C" {
7193
+
pub fn i_cal_component_new_vquery() -> *mut ICalComponent;
7194
+
}
7195
+
unsafe extern "C" {
7196
+
pub fn i_cal_component_new_vavailability() -> *mut ICalComponent;
7197
+
}
7198
+
unsafe extern "C" {
7199
+
pub fn i_cal_component_new_xavailable() -> *mut ICalComponent;
7200
+
}
7201
+
unsafe extern "C" {
7202
+
pub fn i_cal_component_new_vpoll() -> *mut ICalComponent;
7203
+
}
7204
+
unsafe extern "C" {
7205
+
pub fn i_cal_component_new_vvoter() -> *mut ICalComponent;
7206
+
}
7207
+
unsafe extern "C" {
7208
+
pub fn i_cal_component_new_xvote() -> *mut ICalComponent;
7209
+
}
7210
+
#[repr(C)]
7211
+
#[derive(Debug, Copy, Clone)]
7212
+
pub struct _ICalTime {
7213
+
pub parent: ICalObject,
7214
+
}
7215
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7216
+
const _: () = {
7217
+
["Size of _ICalTime"][::std::mem::size_of::<_ICalTime>() - 32usize];
7218
+
["Alignment of _ICalTime"][::std::mem::align_of::<_ICalTime>() - 8usize];
7219
+
["Offset of field: _ICalTime::parent"][::std::mem::offset_of!(_ICalTime, parent) - 0usize];
7220
+
};
7221
+
unsafe extern "C" {
7222
+
pub fn i_cal_time_get_type() -> GType;
7223
+
}
7224
+
unsafe extern "C" {
7225
+
pub fn i_cal_time_new() -> *mut ICalTime;
7226
+
}
7227
+
unsafe extern "C" {
7228
+
pub fn i_cal_time_clone(timetype: *const ICalTime) -> *mut ICalTime;
7229
+
}
7230
+
unsafe extern "C" {
7231
+
pub fn i_cal_time_new_null_time() -> *mut ICalTime;
7232
+
}
7233
+
unsafe extern "C" {
7234
+
pub fn i_cal_time_new_null_date() -> *mut ICalTime;
7235
+
}
7236
+
unsafe extern "C" {
7237
+
pub fn i_cal_time_new_current_with_zone(zone: *mut ICalTimezone) -> *mut ICalTime;
7238
+
}
7239
+
unsafe extern "C" {
7240
+
pub fn i_cal_time_new_today() -> *mut ICalTime;
7241
+
}
7242
+
unsafe extern "C" {
7243
+
pub fn i_cal_time_new_from_timet_with_zone(
7244
+
v: time_t,
7245
+
is_date: gint,
7246
+
zone: *mut ICalTimezone,
7247
+
) -> *mut ICalTime;
7248
+
}
7249
+
unsafe extern "C" {
7250
+
pub fn i_cal_time_new_from_string(str_: *const gchar) -> *mut ICalTime;
7251
+
}
7252
+
unsafe extern "C" {
7253
+
pub fn i_cal_time_new_from_day_of_year(day: gint, year: gint) -> *mut ICalTime;
7254
+
}
7255
+
unsafe extern "C" {
7256
+
pub fn i_cal_time_as_timet(tt: *const ICalTime) -> time_t;
7257
+
}
7258
+
unsafe extern "C" {
7259
+
pub fn i_cal_time_as_timet_with_zone(tt: *const ICalTime, zone: *const ICalTimezone) -> time_t;
7260
+
}
7261
+
unsafe extern "C" {
7262
+
pub fn i_cal_time_as_ical_string(tt: *const ICalTime) -> *mut gchar;
7263
+
}
7264
+
unsafe extern "C" {
7265
+
pub fn i_cal_time_get_timezone(tt: *const ICalTime) -> *mut ICalTimezone;
7266
+
}
7267
+
unsafe extern "C" {
7268
+
pub fn i_cal_time_set_timezone(tt: *mut ICalTime, zone: *const ICalTimezone);
7269
+
}
7270
+
unsafe extern "C" {
7271
+
pub fn i_cal_time_get_tzid(tt: *const ICalTime) -> *const gchar;
7272
+
}
7273
+
unsafe extern "C" {
7274
+
pub fn i_cal_time_day_of_year(tt: *const ICalTime) -> gint;
7275
+
}
7276
+
unsafe extern "C" {
7277
+
pub fn i_cal_time_day_of_week(tt: *const ICalTime) -> gint;
7278
+
}
7279
+
unsafe extern "C" {
7280
+
pub fn i_cal_time_start_doy_week(tt: *const ICalTime, fdow: gint) -> gint;
7281
+
}
7282
+
unsafe extern "C" {
7283
+
pub fn i_cal_time_week_number(tt: *const ICalTime) -> gint;
7284
+
}
7285
+
unsafe extern "C" {
7286
+
pub fn i_cal_time_is_null_time(tt: *const ICalTime) -> gboolean;
7287
+
}
7288
+
unsafe extern "C" {
7289
+
pub fn i_cal_time_is_valid_time(tt: *const ICalTime) -> gboolean;
7290
+
}
7291
+
unsafe extern "C" {
7292
+
pub fn i_cal_time_is_date(tt: *const ICalTime) -> gboolean;
7293
+
}
7294
+
unsafe extern "C" {
7295
+
pub fn i_cal_time_is_utc(tt: *const ICalTime) -> gboolean;
7296
+
}
7297
+
unsafe extern "C" {
7298
+
pub fn i_cal_time_compare(a: *const ICalTime, b: *const ICalTime) -> gint;
7299
+
}
7300
+
unsafe extern "C" {
7301
+
pub fn i_cal_time_compare_date_only(a: *const ICalTime, b: *const ICalTime) -> gint;
7302
+
}
7303
+
unsafe extern "C" {
7304
+
pub fn i_cal_time_compare_date_only_tz(
7305
+
a: *const ICalTime,
7306
+
b: *const ICalTime,
7307
+
zone: *mut ICalTimezone,
7308
+
) -> gint;
7309
+
}
7310
+
unsafe extern "C" {
7311
+
pub fn i_cal_time_adjust(
7312
+
tt: *mut ICalTime,
7313
+
days: gint,
7314
+
hours: gint,
7315
+
minutes: gint,
7316
+
seconds: gint,
7317
+
);
7318
+
}
7319
+
unsafe extern "C" {
7320
+
pub fn i_cal_time_normalize(t: *const ICalTime) -> *mut ICalTime;
7321
+
}
7322
+
unsafe extern "C" {
7323
+
pub fn i_cal_time_normalize_inplace(tt: *mut ICalTime);
7324
+
}
7325
+
unsafe extern "C" {
7326
+
pub fn i_cal_time_convert_to_zone(
7327
+
tt: *const ICalTime,
7328
+
zone: *mut ICalTimezone,
7329
+
) -> *mut ICalTime;
7330
+
}
7331
+
unsafe extern "C" {
7332
+
pub fn i_cal_time_convert_to_zone_inplace(tt: *mut ICalTime, zone: *mut ICalTimezone);
7333
+
}
7334
+
unsafe extern "C" {
7335
+
pub fn i_cal_time_days_in_month(month: gint, year: gint) -> gint;
7336
+
}
7337
+
unsafe extern "C" {
7338
+
pub fn i_cal_time_days_is_leap_year(year: gint) -> gboolean;
7339
+
}
7340
+
unsafe extern "C" {
7341
+
pub fn i_cal_time_days_in_year(year: gint) -> gint;
7342
+
}
7343
+
unsafe extern "C" {
7344
+
pub fn i_cal_time_span_new(
7345
+
dtstart: *mut ICalTime,
7346
+
dtend: *mut ICalTime,
7347
+
is_busy: gint,
7348
+
) -> *mut ICalTimeSpan;
7349
+
}
7350
+
unsafe extern "C" {
7351
+
pub fn i_cal_time_span_overlaps(s1: *mut ICalTimeSpan, s2: *mut ICalTimeSpan) -> gint;
7352
+
}
7353
+
unsafe extern "C" {
7354
+
pub fn i_cal_time_span_contains(s: *mut ICalTimeSpan, container: *mut ICalTimeSpan) -> gint;
7355
+
}
7356
+
unsafe extern "C" {
7357
+
pub fn i_cal_time_add(t: *mut ICalTime, d: *mut ICalDuration) -> *mut ICalTime;
7358
+
}
7359
+
unsafe extern "C" {
7360
+
pub fn i_cal_time_subtract(t1: *mut ICalTime, t2: *mut ICalTime) -> *mut ICalDuration;
7361
+
}
7362
+
unsafe extern "C" {
7363
+
pub fn i_cal_time_get_year(timetype: *const ICalTime) -> gint;
7364
+
}
7365
+
unsafe extern "C" {
7366
+
pub fn i_cal_time_set_year(timetype: *mut ICalTime, year: gint);
7367
+
}
7368
+
unsafe extern "C" {
7369
+
pub fn i_cal_time_get_month(timetype: *const ICalTime) -> gint;
7370
+
}
7371
+
unsafe extern "C" {
7372
+
pub fn i_cal_time_set_month(timetype: *mut ICalTime, month: gint);
7373
+
}
7374
+
unsafe extern "C" {
7375
+
pub fn i_cal_time_get_day(timetype: *const ICalTime) -> gint;
7376
+
}
7377
+
unsafe extern "C" {
7378
+
pub fn i_cal_time_set_day(timetype: *mut ICalTime, day: gint);
7379
+
}
7380
+
unsafe extern "C" {
7381
+
pub fn i_cal_time_get_hour(timetype: *const ICalTime) -> gint;
7382
+
}
7383
+
unsafe extern "C" {
7384
+
pub fn i_cal_time_set_hour(timetype: *mut ICalTime, hour: gint);
7385
+
}
7386
+
unsafe extern "C" {
7387
+
pub fn i_cal_time_get_minute(timetype: *const ICalTime) -> gint;
7388
+
}
7389
+
unsafe extern "C" {
7390
+
pub fn i_cal_time_set_minute(timetype: *mut ICalTime, minute: gint);
7391
+
}
7392
+
unsafe extern "C" {
7393
+
pub fn i_cal_time_get_second(timetype: *const ICalTime) -> gint;
7394
+
}
7395
+
unsafe extern "C" {
7396
+
pub fn i_cal_time_set_second(timetype: *mut ICalTime, second: gint);
7397
+
}
7398
+
unsafe extern "C" {
7399
+
pub fn i_cal_time_set_is_date(timetype: *mut ICalTime, is_date: gboolean);
7400
+
}
7401
+
unsafe extern "C" {
7402
+
pub fn i_cal_time_is_daylight(timetype: *const ICalTime) -> gboolean;
7403
+
}
7404
+
unsafe extern "C" {
7405
+
pub fn i_cal_time_set_is_daylight(timetype: *mut ICalTime, is_daylight: gboolean);
7406
+
}
7407
+
unsafe extern "C" {
7408
+
pub fn i_cal_time_get_date(
7409
+
timetype: *const ICalTime,
7410
+
year: *mut gint,
7411
+
month: *mut gint,
7412
+
day: *mut gint,
7413
+
);
7414
+
}
7415
+
unsafe extern "C" {
7416
+
pub fn i_cal_time_set_date(timetype: *mut ICalTime, year: gint, month: gint, day: gint);
7417
+
}
7418
+
unsafe extern "C" {
7419
+
pub fn i_cal_time_get_time(
7420
+
timetype: *const ICalTime,
7421
+
hour: *mut gint,
7422
+
minute: *mut gint,
7423
+
second: *mut gint,
7424
+
);
7425
+
}
7426
+
unsafe extern "C" {
7427
+
pub fn i_cal_time_set_time(timetype: *mut ICalTime, hour: gint, minute: gint, second: gint);
7428
+
}
7429
+
#[repr(C)]
7430
+
#[derive(Debug, Copy, Clone)]
7431
+
pub struct _ICalPeriod {
7432
+
pub parent: ICalObject,
7433
+
}
7434
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7435
+
const _: () = {
7436
+
["Size of _ICalPeriod"][::std::mem::size_of::<_ICalPeriod>() - 32usize];
7437
+
["Alignment of _ICalPeriod"][::std::mem::align_of::<_ICalPeriod>() - 8usize];
7438
+
["Offset of field: _ICalPeriod::parent"][::std::mem::offset_of!(_ICalPeriod, parent) - 0usize];
7439
+
};
7440
+
unsafe extern "C" {
7441
+
pub fn i_cal_period_get_type() -> GType;
7442
+
}
7443
+
unsafe extern "C" {
7444
+
pub fn i_cal_period_get_start(period: *mut ICalPeriod) -> *mut ICalTime;
7445
+
}
7446
+
unsafe extern "C" {
7447
+
pub fn i_cal_period_set_start(period: *mut ICalPeriod, start: *mut ICalTime);
7448
+
}
7449
+
unsafe extern "C" {
7450
+
pub fn i_cal_period_get_end(period: *mut ICalPeriod) -> *mut ICalTime;
7451
+
}
7452
+
unsafe extern "C" {
7453
+
pub fn i_cal_period_set_end(period: *mut ICalPeriod, end: *mut ICalTime);
7454
+
}
7455
+
unsafe extern "C" {
7456
+
pub fn i_cal_period_get_duration(period: *mut ICalPeriod) -> *mut ICalDuration;
7457
+
}
7458
+
unsafe extern "C" {
7459
+
pub fn i_cal_period_set_duration(period: *mut ICalPeriod, duration: *mut ICalDuration);
7460
+
}
7461
+
unsafe extern "C" {
7462
+
pub fn i_cal_period_new_from_string(str_: *const gchar) -> *mut ICalPeriod;
7463
+
}
7464
+
unsafe extern "C" {
7465
+
pub fn i_cal_period_as_ical_string(p: *mut ICalPeriod) -> *mut gchar;
7466
+
}
7467
+
unsafe extern "C" {
7468
+
pub fn i_cal_period_new_null_period() -> *mut ICalPeriod;
7469
+
}
7470
+
unsafe extern "C" {
7471
+
pub fn i_cal_period_is_null_period(p: *mut ICalPeriod) -> gboolean;
7472
+
}
7473
+
unsafe extern "C" {
7474
+
pub fn i_cal_period_is_valid_period(p: *mut ICalPeriod) -> gboolean;
7475
+
}
7476
+
#[repr(C)]
7477
+
#[derive(Debug, Copy, Clone)]
7478
+
pub struct _ICalDatetimeperiod {
7479
+
pub parent: ICalObject,
7480
+
}
7481
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7482
+
const _: () = {
7483
+
["Size of _ICalDatetimeperiod"][::std::mem::size_of::<_ICalDatetimeperiod>() - 32usize];
7484
+
["Alignment of _ICalDatetimeperiod"][::std::mem::align_of::<_ICalDatetimeperiod>() - 8usize];
7485
+
["Offset of field: _ICalDatetimeperiod::parent"]
7486
+
[::std::mem::offset_of!(_ICalDatetimeperiod, parent) - 0usize];
7487
+
};
7488
+
unsafe extern "C" {
7489
+
pub fn i_cal_datetimeperiod_get_type() -> GType;
7490
+
}
7491
+
unsafe extern "C" {
7492
+
pub fn i_cal_datetimeperiod_new() -> *mut ICalDatetimeperiod;
7493
+
}
7494
+
unsafe extern "C" {
7495
+
pub fn i_cal_datetimeperiod_get_time(dtp: *mut ICalDatetimeperiod) -> *mut ICalTime;
7496
+
}
7497
+
unsafe extern "C" {
7498
+
pub fn i_cal_datetimeperiod_set_time(dtp: *mut ICalDatetimeperiod, time: *mut ICalTime);
7499
+
}
7500
+
unsafe extern "C" {
7501
+
pub fn i_cal_datetimeperiod_get_period(dtp: *mut ICalDatetimeperiod) -> *mut ICalPeriod;
7502
+
}
7503
+
unsafe extern "C" {
7504
+
pub fn i_cal_datetimeperiod_set_period(dtp: *mut ICalDatetimeperiod, period: *mut ICalPeriod);
7505
+
}
7506
+
#[repr(C)]
7507
+
#[derive(Debug, Copy, Clone)]
7508
+
pub struct _ICalDuration {
7509
+
pub parent: ICalObject,
7510
+
}
7511
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7512
+
const _: () = {
7513
+
["Size of _ICalDuration"][::std::mem::size_of::<_ICalDuration>() - 32usize];
7514
+
["Alignment of _ICalDuration"][::std::mem::align_of::<_ICalDuration>() - 8usize];
7515
+
["Offset of field: _ICalDuration::parent"]
7516
+
[::std::mem::offset_of!(_ICalDuration, parent) - 0usize];
7517
+
};
7518
+
unsafe extern "C" {
7519
+
pub fn i_cal_duration_get_type() -> GType;
7520
+
}
7521
+
unsafe extern "C" {
7522
+
pub fn i_cal_duration_is_neg(duration: *mut ICalDuration) -> gboolean;
7523
+
}
7524
+
unsafe extern "C" {
7525
+
pub fn i_cal_duration_set_is_neg(duration: *mut ICalDuration, is_neg: gboolean);
7526
+
}
7527
+
unsafe extern "C" {
7528
+
pub fn i_cal_duration_get_days(duration: *mut ICalDuration) -> guint;
7529
+
}
7530
+
unsafe extern "C" {
7531
+
pub fn i_cal_duration_set_days(duration: *mut ICalDuration, days: guint);
7532
+
}
7533
+
unsafe extern "C" {
7534
+
pub fn i_cal_duration_get_weeks(duration: *mut ICalDuration) -> guint;
7535
+
}
7536
+
unsafe extern "C" {
7537
+
pub fn i_cal_duration_set_weeks(duration: *mut ICalDuration, weeks: guint);
7538
+
}
7539
+
unsafe extern "C" {
7540
+
pub fn i_cal_duration_get_hours(duration: *mut ICalDuration) -> guint;
7541
+
}
7542
+
unsafe extern "C" {
7543
+
pub fn i_cal_duration_set_hours(duration: *mut ICalDuration, hours: guint);
7544
+
}
7545
+
unsafe extern "C" {
7546
+
pub fn i_cal_duration_get_minutes(duration: *mut ICalDuration) -> guint;
7547
+
}
7548
+
unsafe extern "C" {
7549
+
pub fn i_cal_duration_set_minutes(duration: *mut ICalDuration, minutes: guint);
7550
+
}
7551
+
unsafe extern "C" {
7552
+
pub fn i_cal_duration_get_seconds(duration: *mut ICalDuration) -> guint;
7553
+
}
7554
+
unsafe extern "C" {
7555
+
pub fn i_cal_duration_set_seconds(duration: *mut ICalDuration, seconds: guint);
7556
+
}
7557
+
unsafe extern "C" {
7558
+
pub fn i_cal_duration_new_from_int(t: gint) -> *mut ICalDuration;
7559
+
}
7560
+
unsafe extern "C" {
7561
+
pub fn i_cal_duration_new_from_string(str_: *const gchar) -> *mut ICalDuration;
7562
+
}
7563
+
unsafe extern "C" {
7564
+
pub fn i_cal_duration_as_int(duration: *mut ICalDuration) -> gint;
7565
+
}
7566
+
unsafe extern "C" {
7567
+
pub fn i_cal_duration_as_ical_string(duration: *mut ICalDuration) -> *mut gchar;
7568
+
}
7569
+
unsafe extern "C" {
7570
+
pub fn i_cal_duration_new_null_duration() -> *mut ICalDuration;
7571
+
}
7572
+
unsafe extern "C" {
7573
+
pub fn i_cal_duration_new_bad_duration() -> *mut ICalDuration;
7574
+
}
7575
+
unsafe extern "C" {
7576
+
pub fn i_cal_duration_is_null_duration(duration: *mut ICalDuration) -> gboolean;
7577
+
}
7578
+
unsafe extern "C" {
7579
+
pub fn i_cal_duration_is_bad_duration(duration: *mut ICalDuration) -> gboolean;
7580
+
}
7581
+
pub const ICalErrorEnum_I_CAL_NO_ERROR: ICalErrorEnum = 0;
7582
+
pub const ICalErrorEnum_I_CAL_BADARG_ERROR: ICalErrorEnum = 1;
7583
+
pub const ICalErrorEnum_I_CAL_NEWFAILED_ERROR: ICalErrorEnum = 2;
7584
+
pub const ICalErrorEnum_I_CAL_ALLOCATION_ERROR: ICalErrorEnum = 3;
7585
+
pub const ICalErrorEnum_I_CAL_MALFORMEDDATA_ERROR: ICalErrorEnum = 4;
7586
+
pub const ICalErrorEnum_I_CAL_PARSE_ERROR: ICalErrorEnum = 5;
7587
+
pub const ICalErrorEnum_I_CAL_INTERNAL_ERROR: ICalErrorEnum = 6;
7588
+
pub const ICalErrorEnum_I_CAL_FILE_ERROR: ICalErrorEnum = 7;
7589
+
pub const ICalErrorEnum_I_CAL_USAGE_ERROR: ICalErrorEnum = 8;
7590
+
pub const ICalErrorEnum_I_CAL_UNIMPLEMENTED_ERROR: ICalErrorEnum = 9;
7591
+
pub const ICalErrorEnum_I_CAL_UNKNOWN_ERROR: ICalErrorEnum = 10;
7592
+
pub type ICalErrorEnum = ::std::os::raw::c_uint;
7593
+
pub const ICalErrorState_I_CAL_ERROR_FATAL: ICalErrorState = 0;
7594
+
pub const ICalErrorState_I_CAL_ERROR_NONFATAL: ICalErrorState = 1;
7595
+
pub const ICalErrorState_I_CAL_ERROR_DEFAULT: ICalErrorState = 2;
7596
+
pub const ICalErrorState_I_CAL_ERROR_UNKNOWN: ICalErrorState = 3;
7597
+
pub type ICalErrorState = ::std::os::raw::c_uint;
7598
+
unsafe extern "C" {
7599
+
pub fn i_cal_error_stop_here();
7600
+
}
7601
+
unsafe extern "C" {
7602
+
pub fn i_cal_error_crash_here();
7603
+
}
7604
+
unsafe extern "C" {
7605
+
pub fn i_cal_errno_return() -> ICalErrorEnum;
7606
+
}
7607
+
unsafe extern "C" {
7608
+
pub fn i_cal_error_clear_errno();
7609
+
}
7610
+
unsafe extern "C" {
7611
+
pub fn i_cal_error_strerror(e: ICalErrorEnum) -> *const gchar;
7612
+
}
7613
+
unsafe extern "C" {
7614
+
pub fn i_cal_error_perror() -> *const gchar;
7615
+
}
7616
+
unsafe extern "C" {
7617
+
pub fn i_cal_bt();
7618
+
}
7619
+
unsafe extern "C" {
7620
+
pub fn i_cal_error_set_error_state(error: ICalErrorEnum, state: ICalErrorState);
7621
+
}
7622
+
unsafe extern "C" {
7623
+
pub fn i_cal_error_get_error_state(error: ICalErrorEnum) -> ICalErrorState;
7624
+
}
7625
+
unsafe extern "C" {
7626
+
pub fn i_cal_error_set_errno(x: ICalErrorEnum);
7627
+
}
7628
+
unsafe extern "C" {
7629
+
pub fn i_cal_error_supress(error: *const gchar) -> ICalErrorState;
7630
+
}
7631
+
unsafe extern "C" {
7632
+
pub fn i_cal_error_restore(error: *const gchar, es: ICalErrorState);
7633
+
}
7634
+
#[repr(C)]
7635
+
#[derive(Debug, Copy, Clone)]
7636
+
pub struct _ICalGeo {
7637
+
pub parent: ICalObject,
7638
+
}
7639
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7640
+
const _: () = {
7641
+
["Size of _ICalGeo"][::std::mem::size_of::<_ICalGeo>() - 32usize];
7642
+
["Alignment of _ICalGeo"][::std::mem::align_of::<_ICalGeo>() - 8usize];
7643
+
["Offset of field: _ICalGeo::parent"][::std::mem::offset_of!(_ICalGeo, parent) - 0usize];
7644
+
};
7645
+
unsafe extern "C" {
7646
+
pub fn i_cal_geo_get_type() -> GType;
7647
+
}
7648
+
unsafe extern "C" {
7649
+
pub fn i_cal_geo_new(lat: gdouble, lon: gdouble) -> *mut ICalGeo;
7650
+
}
7651
+
unsafe extern "C" {
7652
+
pub fn i_cal_geo_clone(geo: *const ICalGeo) -> *mut ICalGeo;
7653
+
}
7654
+
unsafe extern "C" {
7655
+
pub fn i_cal_geo_get_lat(geo: *mut ICalGeo) -> gdouble;
7656
+
}
7657
+
unsafe extern "C" {
7658
+
pub fn i_cal_geo_set_lat(geo: *mut ICalGeo, lat: gdouble);
7659
+
}
7660
+
unsafe extern "C" {
7661
+
pub fn i_cal_geo_get_lon(geo: *mut ICalGeo) -> gdouble;
7662
+
}
7663
+
unsafe extern "C" {
7664
+
pub fn i_cal_geo_set_lon(geo: *mut ICalGeo, lon: gdouble);
7665
+
}
7666
+
unsafe extern "C" {
7667
+
pub fn i_cal_memory_tmp_buffer(size: usize) -> *mut ::std::os::raw::c_void;
7668
+
}
7669
+
unsafe extern "C" {
7670
+
pub fn i_cal_memory_tmp_copy(str_: *const gchar) -> *mut gchar;
7671
+
}
7672
+
unsafe extern "C" {
7673
+
pub fn i_cal_memory_add_tmp_buffer(buf: *mut ::std::os::raw::c_void);
7674
+
}
7675
+
unsafe extern "C" {
7676
+
pub fn i_cal_memory_free_ring();
7677
+
}
7678
+
unsafe extern "C" {
7679
+
pub fn i_cal_memory_new_buffer(size: usize) -> *mut ::std::os::raw::c_void;
7680
+
}
7681
+
unsafe extern "C" {
7682
+
pub fn i_cal_memory_resize_buffer(
7683
+
buf: *mut ::std::os::raw::c_void,
7684
+
size: usize,
7685
+
) -> *mut ::std::os::raw::c_void;
7686
+
}
7687
+
unsafe extern "C" {
7688
+
pub fn i_cal_memory_free_buffer(buf: *mut ::std::os::raw::c_void);
7689
+
}
7690
+
unsafe extern "C" {
7691
+
pub fn i_cal_memory_append_string(
7692
+
buf: *mut *mut gchar,
7693
+
pos: *mut *mut gchar,
7694
+
buf_size: *mut usize,
7695
+
str_: *const gchar,
7696
+
);
7697
+
}
7698
+
unsafe extern "C" {
7699
+
pub fn i_cal_memory_append_char(
7700
+
buf: *mut *mut gchar,
7701
+
pos: *mut *mut gchar,
7702
+
buf_size: *mut usize,
7703
+
ch: gchar,
7704
+
);
7705
+
}
7706
+
unsafe extern "C" {
7707
+
pub fn i_cal_memory_strdup(s: *const gchar) -> *mut gchar;
7708
+
}
7709
+
pub type ICalMimeParseFunc = ::std::option::Option<
7710
+
unsafe extern "C" fn(bytes: *mut gchar, size: usize, user_data: gpointer) -> *mut gchar,
7711
+
>;
7712
+
unsafe extern "C" {
7713
+
pub fn i_cal_mime_parse(func: ICalMimeParseFunc, user_data: gpointer) -> *mut ICalComponent;
7714
+
}
7715
+
#[repr(C)]
7716
+
#[derive(Debug, Copy, Clone)]
7717
+
pub struct _ICalParser {
7718
+
pub parent: ICalObject,
7719
+
}
7720
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7721
+
const _: () = {
7722
+
["Size of _ICalParser"][::std::mem::size_of::<_ICalParser>() - 32usize];
7723
+
["Alignment of _ICalParser"][::std::mem::align_of::<_ICalParser>() - 8usize];
7724
+
["Offset of field: _ICalParser::parent"][::std::mem::offset_of!(_ICalParser, parent) - 0usize];
7725
+
};
7726
+
pub type ICalParserLineGenFunc = ::std::option::Option<
7727
+
unsafe extern "C" fn(bytes: *mut gchar, size: usize, user_data: gpointer) -> *mut gchar,
7728
+
>;
7729
+
pub const ICalParserState_I_CAL_PARSER_ERROR: ICalParserState = 0;
7730
+
pub const ICalParserState_I_CAL_PARSER_SUCCESS: ICalParserState = 1;
7731
+
pub const ICalParserState_I_CAL_PARSER_BEGIN_COMP: ICalParserState = 2;
7732
+
pub const ICalParserState_I_CAL_PARSER_END_COMP: ICalParserState = 3;
7733
+
pub const ICalParserState_I_CAL_PARSER_IN_PROGRESS: ICalParserState = 4;
7734
+
pub type ICalParserState = ::std::os::raw::c_uint;
7735
+
unsafe extern "C" {
7736
+
pub fn i_cal_parser_get_type() -> GType;
7737
+
}
7738
+
unsafe extern "C" {
7739
+
pub fn i_cal_parser_new() -> *mut ICalParser;
7740
+
}
7741
+
unsafe extern "C" {
7742
+
pub fn i_cal_parser_add_line(parser: *mut ICalParser, str_: *mut gchar) -> *mut ICalComponent;
7743
+
}
7744
+
unsafe extern "C" {
7745
+
pub fn i_cal_parser_clean(parser: *mut ICalParser) -> *mut ICalComponent;
7746
+
}
7747
+
unsafe extern "C" {
7748
+
pub fn i_cal_parser_get_state(parser: *mut ICalParser) -> ICalParserState;
7749
+
}
7750
+
unsafe extern "C" {
7751
+
pub fn i_cal_parser_free(parser: *mut ICalParser);
7752
+
}
7753
+
unsafe extern "C" {
7754
+
pub fn i_cal_parser_parse(
7755
+
parser: *mut ICalParser,
7756
+
func: ICalParserLineGenFunc,
7757
+
user_data: gpointer,
7758
+
) -> *mut ICalComponent;
7759
+
}
7760
+
unsafe extern "C" {
7761
+
pub fn i_cal_parser_parse_string(str_: *const gchar) -> *mut ICalComponent;
7762
+
}
7763
+
unsafe extern "C" {
7764
+
pub fn i_cal_parser_get_line(
7765
+
parser: *mut ICalParser,
7766
+
func: ICalParserLineGenFunc,
7767
+
user_data: gpointer,
7768
+
) -> *mut gchar;
7769
+
}
7770
+
#[repr(C)]
7771
+
#[derive(Debug, Copy, Clone)]
7772
+
pub struct _ICalProperty {
7773
+
pub parent: ICalObject,
7774
+
}
7775
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7776
+
const _: () = {
7777
+
["Size of _ICalProperty"][::std::mem::size_of::<_ICalProperty>() - 32usize];
7778
+
["Alignment of _ICalProperty"][::std::mem::align_of::<_ICalProperty>() - 8usize];
7779
+
["Offset of field: _ICalProperty::parent"]
7780
+
[::std::mem::offset_of!(_ICalProperty, parent) - 0usize];
7781
+
};
7782
+
unsafe extern "C" {
7783
+
pub fn i_cal_property_get_type() -> GType;
7784
+
}
7785
+
unsafe extern "C" {
7786
+
pub fn i_cal_property_new(kind: ICalPropertyKind) -> *mut ICalProperty;
7787
+
}
7788
+
unsafe extern "C" {
7789
+
pub fn i_cal_property_clone(prop: *mut ICalProperty) -> *mut ICalProperty;
7790
+
}
7791
+
unsafe extern "C" {
7792
+
pub fn i_cal_property_new_from_string(str_: *const gchar) -> *mut ICalProperty;
7793
+
}
7794
+
unsafe extern "C" {
7795
+
pub fn i_cal_property_as_ical_string(prop: *mut ICalProperty) -> *mut gchar;
7796
+
}
7797
+
unsafe extern "C" {
7798
+
pub fn i_cal_property_free(prop: *mut ICalProperty);
7799
+
}
7800
+
unsafe extern "C" {
7801
+
pub fn i_cal_property_isa(property: *mut ICalProperty) -> ICalPropertyKind;
7802
+
}
7803
+
unsafe extern "C" {
7804
+
pub fn i_cal_property_isa_property(property: *mut ICalProperty) -> gint;
7805
+
}
7806
+
unsafe extern "C" {
7807
+
pub fn i_cal_property_add_parameter(prop: *mut ICalProperty, parameter: *mut ICalParameter);
7808
+
}
7809
+
unsafe extern "C" {
7810
+
pub fn i_cal_property_take_parameter(prop: *mut ICalProperty, parameter: *mut ICalParameter);
7811
+
}
7812
+
unsafe extern "C" {
7813
+
pub fn i_cal_property_set_parameter(prop: *mut ICalProperty, parameter: *mut ICalParameter);
7814
+
}
7815
+
unsafe extern "C" {
7816
+
pub fn i_cal_property_set_parameter_from_string(
7817
+
prop: *mut ICalProperty,
7818
+
name: *const gchar,
7819
+
value: *const gchar,
7820
+
);
7821
+
}
7822
+
unsafe extern "C" {
7823
+
pub fn i_cal_property_get_parameter_as_string(
7824
+
prop: *mut ICalProperty,
7825
+
name: *const gchar,
7826
+
) -> *mut gchar;
7827
+
}
7828
+
unsafe extern "C" {
7829
+
pub fn i_cal_property_remove_parameter_by_kind(
7830
+
prop: *mut ICalProperty,
7831
+
kind: ICalParameterKind,
7832
+
);
7833
+
}
7834
+
unsafe extern "C" {
7835
+
pub fn i_cal_property_remove_parameter_by_name(prop: *mut ICalProperty, name: *const gchar);
7836
+
}
7837
+
unsafe extern "C" {
7838
+
pub fn i_cal_property_remove_parameter_by_ref(
7839
+
prop: *mut ICalProperty,
7840
+
param: *mut ICalParameter,
7841
+
);
7842
+
}
7843
+
unsafe extern "C" {
7844
+
pub fn i_cal_property_count_parameters(prop: *const ICalProperty) -> gint;
7845
+
}
7846
+
unsafe extern "C" {
7847
+
pub fn i_cal_property_get_first_parameter(
7848
+
prop: *mut ICalProperty,
7849
+
kind: ICalParameterKind,
7850
+
) -> *mut ICalParameter;
7851
+
}
7852
+
unsafe extern "C" {
7853
+
pub fn i_cal_property_get_next_parameter(
7854
+
prop: *mut ICalProperty,
7855
+
kind: ICalParameterKind,
7856
+
) -> *mut ICalParameter;
7857
+
}
7858
+
unsafe extern "C" {
7859
+
pub fn i_cal_property_set_value(prop: *mut ICalProperty, value: *mut ICalValue);
7860
+
}
7861
+
unsafe extern "C" {
7862
+
pub fn i_cal_property_take_value(prop: *mut ICalProperty, value: *mut ICalValue);
7863
+
}
7864
+
unsafe extern "C" {
7865
+
pub fn i_cal_property_set_value_from_string(
7866
+
prop: *mut ICalProperty,
7867
+
value: *const gchar,
7868
+
kind: *const gchar,
7869
+
);
7870
+
}
7871
+
unsafe extern "C" {
7872
+
pub fn i_cal_property_get_value(prop: *const ICalProperty) -> *mut ICalValue;
7873
+
}
7874
+
unsafe extern "C" {
7875
+
pub fn i_cal_property_get_value_as_string(prop: *const ICalProperty) -> *mut gchar;
7876
+
}
7877
+
unsafe extern "C" {
7878
+
pub fn i_cal_value_set_parent(value: *mut ICalValue, property: *mut ICalProperty);
7879
+
}
7880
+
unsafe extern "C" {
7881
+
pub fn i_cal_value_get_parent(value: *mut ICalValue) -> *mut ICalProperty;
7882
+
}
7883
+
unsafe extern "C" {
7884
+
pub fn i_cal_parameter_set_parent(param: *mut ICalParameter, property: *mut ICalProperty);
7885
+
}
7886
+
unsafe extern "C" {
7887
+
pub fn i_cal_parameter_get_parent(param: *mut ICalParameter) -> *mut ICalProperty;
7888
+
}
7889
+
unsafe extern "C" {
7890
+
pub fn i_cal_property_set_x_name(prop: *mut ICalProperty, name: *const gchar);
7891
+
}
7892
+
unsafe extern "C" {
7893
+
pub fn i_cal_property_get_x_name(prop: *mut ICalProperty) -> *const gchar;
7894
+
}
7895
+
unsafe extern "C" {
7896
+
pub fn i_cal_property_get_property_name(prop: *const ICalProperty) -> *mut gchar;
7897
+
}
7898
+
unsafe extern "C" {
7899
+
pub fn i_cal_parameter_value_to_value_kind(value: ICalParameterValue) -> ICalValueKind;
7900
+
}
7901
+
unsafe extern "C" {
7902
+
pub fn i_cal_property_kind_to_value_kind(kind: ICalPropertyKind) -> ICalValueKind;
7903
+
}
7904
+
unsafe extern "C" {
7905
+
pub fn i_cal_value_kind_to_property_kind(kind: ICalValueKind) -> ICalPropertyKind;
7906
+
}
7907
+
unsafe extern "C" {
7908
+
pub fn i_cal_property_kind_to_string(kind: ICalPropertyKind) -> *const gchar;
7909
+
}
7910
+
unsafe extern "C" {
7911
+
pub fn i_cal_property_kind_from_string(string: *const gchar) -> ICalPropertyKind;
7912
+
}
7913
+
unsafe extern "C" {
7914
+
pub fn i_cal_property_kind_is_valid(kind: ICalPropertyKind) -> gboolean;
7915
+
}
7916
+
unsafe extern "C" {
7917
+
pub fn i_cal_property_method_from_string(str_: *const gchar) -> ICalPropertyMethod;
7918
+
}
7919
+
unsafe extern "C" {
7920
+
pub fn i_cal_property_method_to_string(method: ICalPropertyMethod) -> *const gchar;
7921
+
}
7922
+
unsafe extern "C" {
7923
+
pub fn i_cal_property_enum_to_string(e: gint) -> *mut gchar;
7924
+
}
7925
+
unsafe extern "C" {
7926
+
pub fn i_cal_property_kind_and_string_to_enum(kind: gint, str_: *const gchar) -> gint;
7927
+
}
7928
+
unsafe extern "C" {
7929
+
pub fn i_cal_property_status_from_string(str_: *const gchar) -> ICalPropertyStatus;
7930
+
}
7931
+
unsafe extern "C" {
7932
+
pub fn i_cal_property_status_to_string(method: ICalPropertyStatus) -> *const gchar;
7933
+
}
7934
+
unsafe extern "C" {
7935
+
pub fn i_cal_property_kind_has_property(kind: ICalPropertyKind, e: gint) -> gint;
7936
+
}
7937
+
#[repr(C)]
7938
+
#[derive(Debug, Copy, Clone)]
7939
+
pub struct _ICalRecurIterator {
7940
+
pub parent: ICalObject,
7941
+
}
7942
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7943
+
const _: () = {
7944
+
["Size of _ICalRecurIterator"][::std::mem::size_of::<_ICalRecurIterator>() - 32usize];
7945
+
["Alignment of _ICalRecurIterator"][::std::mem::align_of::<_ICalRecurIterator>() - 8usize];
7946
+
["Offset of field: _ICalRecurIterator::parent"]
7947
+
[::std::mem::offset_of!(_ICalRecurIterator, parent) - 0usize];
7948
+
};
7949
+
unsafe extern "C" {
7950
+
pub fn i_cal_recur_iterator_get_type() -> GType;
7951
+
}
7952
+
unsafe extern "C" {
7953
+
pub fn i_cal_recur_iterator_new(
7954
+
rule: *mut ICalRecurrence,
7955
+
dtstart: *mut ICalTime,
7956
+
) -> *mut ICalRecurIterator;
7957
+
}
7958
+
unsafe extern "C" {
7959
+
pub fn i_cal_recur_iterator_next(iterator: *mut ICalRecurIterator) -> *mut ICalTime;
7960
+
}
7961
+
unsafe extern "C" {
7962
+
pub fn i_cal_recur_iterator_set_start(
7963
+
iterator: *mut ICalRecurIterator,
7964
+
start: *mut ICalTime,
7965
+
) -> gint;
7966
+
}
7967
+
unsafe extern "C" {
7968
+
pub fn i_cal_recur_iterator_free(iterator: *mut ICalRecurIterator);
7969
+
}
7970
+
#[repr(C)]
7971
+
#[derive(Debug, Copy, Clone)]
7972
+
pub struct _ICalRecurrence {
7973
+
pub parent: ICalObject,
7974
+
}
7975
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7976
+
const _: () = {
7977
+
["Size of _ICalRecurrence"][::std::mem::size_of::<_ICalRecurrence>() - 32usize];
7978
+
["Alignment of _ICalRecurrence"][::std::mem::align_of::<_ICalRecurrence>() - 8usize];
7979
+
["Offset of field: _ICalRecurrence::parent"]
7980
+
[::std::mem::offset_of!(_ICalRecurrence, parent) - 0usize];
7981
+
};
7982
+
pub const ICalRecurrenceFrequency_I_CAL_SECONDLY_RECURRENCE: ICalRecurrenceFrequency = 0;
7983
+
pub const ICalRecurrenceFrequency_I_CAL_MINUTELY_RECURRENCE: ICalRecurrenceFrequency = 1;
7984
+
pub const ICalRecurrenceFrequency_I_CAL_HOURLY_RECURRENCE: ICalRecurrenceFrequency = 2;
7985
+
pub const ICalRecurrenceFrequency_I_CAL_DAILY_RECURRENCE: ICalRecurrenceFrequency = 3;
7986
+
pub const ICalRecurrenceFrequency_I_CAL_WEEKLY_RECURRENCE: ICalRecurrenceFrequency = 4;
7987
+
pub const ICalRecurrenceFrequency_I_CAL_MONTHLY_RECURRENCE: ICalRecurrenceFrequency = 5;
7988
+
pub const ICalRecurrenceFrequency_I_CAL_YEARLY_RECURRENCE: ICalRecurrenceFrequency = 6;
7989
+
pub const ICalRecurrenceFrequency_I_CAL_NO_RECURRENCE: ICalRecurrenceFrequency = 7;
7990
+
pub type ICalRecurrenceFrequency = ::std::os::raw::c_uint;
7991
+
pub const ICalRecurrenceWeekday_I_CAL_NO_WEEKDAY: ICalRecurrenceWeekday = 0;
7992
+
pub const ICalRecurrenceWeekday_I_CAL_SUNDAY_WEEKDAY: ICalRecurrenceWeekday = 1;
7993
+
pub const ICalRecurrenceWeekday_I_CAL_MONDAY_WEEKDAY: ICalRecurrenceWeekday = 2;
7994
+
pub const ICalRecurrenceWeekday_I_CAL_TUESDAY_WEEKDAY: ICalRecurrenceWeekday = 3;
7995
+
pub const ICalRecurrenceWeekday_I_CAL_WEDNESDAY_WEEKDAY: ICalRecurrenceWeekday = 4;
7996
+
pub const ICalRecurrenceWeekday_I_CAL_THURSDAY_WEEKDAY: ICalRecurrenceWeekday = 5;
7997
+
pub const ICalRecurrenceWeekday_I_CAL_FRIDAY_WEEKDAY: ICalRecurrenceWeekday = 6;
7998
+
pub const ICalRecurrenceWeekday_I_CAL_SATURDAY_WEEKDAY: ICalRecurrenceWeekday = 7;
7999
+
pub type ICalRecurrenceWeekday = ::std::os::raw::c_uint;
8000
+
pub const ICalRecurrenceSkip_I_CAL_SKIP_BACKWARD: ICalRecurrenceSkip = 0;
8001
+
pub const ICalRecurrenceSkip_I_CAL_SKIP_FORWARD: ICalRecurrenceSkip = 1;
8002
+
pub const ICalRecurrenceSkip_I_CAL_SKIP_OMIT: ICalRecurrenceSkip = 2;
8003
+
pub const ICalRecurrenceSkip_I_CAL_SKIP_UNDEFINED: ICalRecurrenceSkip = 3;
8004
+
pub type ICalRecurrenceSkip = ::std::os::raw::c_uint;
8005
+
unsafe extern "C" {
8006
+
pub fn i_cal_recurrence_get_type() -> GType;
8007
+
}
8008
+
unsafe extern "C" {
8009
+
pub fn i_cal_recurrence_rscale_is_supported() -> gboolean;
8010
+
}
8011
+
unsafe extern "C" {
8012
+
pub fn i_cal_recurrence_rscale_supported_calendars() -> *mut ICalArray;
8013
+
}
8014
+
unsafe extern "C" {
8015
+
pub fn i_cal_recurrence_new() -> *mut ICalRecurrence;
8016
+
}
8017
+
unsafe extern "C" {
8018
+
pub fn i_cal_recurrence_clear(r: *mut ICalRecurrence);
8019
+
}
8020
+
unsafe extern "C" {
8021
+
pub fn i_cal_recurrence_day_day_of_week(day: gshort) -> ICalRecurrenceWeekday;
8022
+
}
8023
+
unsafe extern "C" {
8024
+
pub fn i_cal_recurrence_day_position(day: gshort) -> gint;
8025
+
}
8026
+
unsafe extern "C" {
8027
+
pub fn i_cal_recurrence_month_is_leap(month: gshort) -> gboolean;
8028
+
}
8029
+
unsafe extern "C" {
8030
+
pub fn i_cal_recurrence_month_month(month: gshort) -> gint;
8031
+
}
8032
+
unsafe extern "C" {
8033
+
pub fn i_cal_recurrence_new_from_string(str_: *const gchar) -> *mut ICalRecurrence;
8034
+
}
8035
+
unsafe extern "C" {
8036
+
pub fn i_cal_recurrence_to_string(recur: *mut ICalRecurrence) -> *mut gchar;
8037
+
}
8038
+
unsafe extern "C" {
8039
+
pub fn i_cal_recurrence_get_until(recur: *mut ICalRecurrence) -> *mut ICalTime;
8040
+
}
8041
+
unsafe extern "C" {
8042
+
pub fn i_cal_recurrence_set_until(recur: *mut ICalRecurrence, until: *mut ICalTime);
8043
+
}
8044
+
unsafe extern "C" {
8045
+
pub fn i_cal_recurrence_get_freq(recur: *mut ICalRecurrence) -> ICalRecurrenceFrequency;
8046
+
}
8047
+
unsafe extern "C" {
8048
+
pub fn i_cal_recurrence_set_freq(recur: *mut ICalRecurrence, freq: ICalRecurrenceFrequency);
8049
+
}
8050
+
unsafe extern "C" {
8051
+
pub fn i_cal_recurrence_get_count(recur: *mut ICalRecurrence) -> gint;
8052
+
}
8053
+
unsafe extern "C" {
8054
+
pub fn i_cal_recurrence_set_count(recur: *mut ICalRecurrence, count: gint);
8055
+
}
8056
+
unsafe extern "C" {
8057
+
pub fn i_cal_recurrence_get_interval(recur: *mut ICalRecurrence) -> gshort;
8058
+
}
8059
+
unsafe extern "C" {
8060
+
pub fn i_cal_recurrence_set_interval(recur: *mut ICalRecurrence, interval: gshort);
8061
+
}
8062
+
unsafe extern "C" {
8063
+
pub fn i_cal_recurrence_get_week_start(recur: *mut ICalRecurrence) -> ICalRecurrenceWeekday;
8064
+
}
8065
+
unsafe extern "C" {
8066
+
pub fn i_cal_recurrence_set_week_start(
8067
+
recur: *mut ICalRecurrence,
8068
+
week_start: ICalRecurrenceWeekday,
8069
+
);
8070
+
}
8071
+
unsafe extern "C" {
8072
+
pub fn i_cal_recurrence_get_by_second_array(recur: *mut ICalRecurrence) -> *mut GArray;
8073
+
}
8074
+
unsafe extern "C" {
8075
+
pub fn i_cal_recurrence_set_by_second_array(recur: *mut ICalRecurrence, values: *mut GArray);
8076
+
}
8077
+
unsafe extern "C" {
8078
+
pub fn i_cal_recurrence_get_by_second(recur: *mut ICalRecurrence, index: guint) -> gshort;
8079
+
}
8080
+
unsafe extern "C" {
8081
+
pub fn i_cal_recurrence_set_by_second(recur: *mut ICalRecurrence, index: guint, value: gshort);
8082
+
}
8083
+
unsafe extern "C" {
8084
+
pub fn i_cal_recurrence_get_by_minute_array(recur: *mut ICalRecurrence) -> *mut GArray;
8085
+
}
8086
+
unsafe extern "C" {
8087
+
pub fn i_cal_recurrence_set_by_minute_array(recur: *mut ICalRecurrence, values: *mut GArray);
8088
+
}
8089
+
unsafe extern "C" {
8090
+
pub fn i_cal_recurrence_get_by_minute(recur: *mut ICalRecurrence, index: guint) -> gshort;
8091
+
}
8092
+
unsafe extern "C" {
8093
+
pub fn i_cal_recurrence_set_by_minute(recur: *mut ICalRecurrence, index: guint, value: gshort);
8094
+
}
8095
+
unsafe extern "C" {
8096
+
pub fn i_cal_recurrence_get_by_hour_array(recur: *mut ICalRecurrence) -> *mut GArray;
8097
+
}
8098
+
unsafe extern "C" {
8099
+
pub fn i_cal_recurrence_set_by_hour_array(recur: *mut ICalRecurrence, values: *mut GArray);
8100
+
}
8101
+
unsafe extern "C" {
8102
+
pub fn i_cal_recurrence_get_by_hour(recur: *mut ICalRecurrence, index: guint) -> gshort;
8103
+
}
8104
+
unsafe extern "C" {
8105
+
pub fn i_cal_recurrence_set_by_hour(recur: *mut ICalRecurrence, index: guint, value: gshort);
8106
+
}
8107
+
unsafe extern "C" {
8108
+
pub fn i_cal_recurrence_get_by_day_array(recur: *mut ICalRecurrence) -> *mut GArray;
8109
+
}
8110
+
unsafe extern "C" {
8111
+
pub fn i_cal_recurrence_set_by_day_array(recur: *mut ICalRecurrence, values: *mut GArray);
8112
+
}
8113
+
unsafe extern "C" {
8114
+
pub fn i_cal_recurrence_get_by_day(recur: *mut ICalRecurrence, index: guint) -> gshort;
8115
+
}
8116
+
unsafe extern "C" {
8117
+
pub fn i_cal_recurrence_set_by_day(recur: *mut ICalRecurrence, index: guint, value: gshort);
8118
+
}
8119
+
unsafe extern "C" {
8120
+
pub fn i_cal_recurrence_get_by_month_day_array(recur: *mut ICalRecurrence) -> *mut GArray;
8121
+
}
8122
+
unsafe extern "C" {
8123
+
pub fn i_cal_recurrence_set_by_month_day_array(recur: *mut ICalRecurrence, values: *mut GArray);
8124
+
}
8125
+
unsafe extern "C" {
8126
+
pub fn i_cal_recurrence_get_by_month_day(recur: *mut ICalRecurrence, index: guint) -> gshort;
8127
+
}
8128
+
unsafe extern "C" {
8129
+
pub fn i_cal_recurrence_set_by_month_day(
8130
+
recur: *mut ICalRecurrence,
8131
+
index: guint,
8132
+
value: gshort,
8133
+
);
8134
+
}
8135
+
unsafe extern "C" {
8136
+
pub fn i_cal_recurrence_get_by_year_day_array(recur: *mut ICalRecurrence) -> *mut GArray;
8137
+
}
8138
+
unsafe extern "C" {
8139
+
pub fn i_cal_recurrence_set_by_year_day_array(recur: *mut ICalRecurrence, values: *mut GArray);
8140
+
}
8141
+
unsafe extern "C" {
8142
+
pub fn i_cal_recurrence_get_by_year_day(recur: *mut ICalRecurrence, index: guint) -> gshort;
8143
+
}
8144
+
unsafe extern "C" {
8145
+
pub fn i_cal_recurrence_set_by_year_day(
8146
+
recur: *mut ICalRecurrence,
8147
+
index: guint,
8148
+
value: gshort,
8149
+
);
8150
+
}
8151
+
unsafe extern "C" {
8152
+
pub fn i_cal_recurrence_get_by_week_no_array(recur: *mut ICalRecurrence) -> *mut GArray;
8153
+
}
8154
+
unsafe extern "C" {
8155
+
pub fn i_cal_recurrence_set_by_week_no_array(recur: *mut ICalRecurrence, values: *mut GArray);
8156
+
}
8157
+
unsafe extern "C" {
8158
+
pub fn i_cal_recurrence_get_by_week_no(recur: *mut ICalRecurrence, index: guint) -> gshort;
8159
+
}
8160
+
unsafe extern "C" {
8161
+
pub fn i_cal_recurrence_set_by_week_no(recur: *mut ICalRecurrence, index: guint, value: gshort);
8162
+
}
8163
+
unsafe extern "C" {
8164
+
pub fn i_cal_recurrence_get_by_month_array(recur: *mut ICalRecurrence) -> *mut GArray;
8165
+
}
8166
+
unsafe extern "C" {
8167
+
pub fn i_cal_recurrence_set_by_month_array(recur: *mut ICalRecurrence, values: *mut GArray);
8168
+
}
8169
+
unsafe extern "C" {
8170
+
pub fn i_cal_recurrence_get_by_month(recur: *mut ICalRecurrence, index: guint) -> gshort;
8171
+
}
8172
+
unsafe extern "C" {
8173
+
pub fn i_cal_recurrence_set_by_month(recur: *mut ICalRecurrence, index: guint, value: gshort);
8174
+
}
8175
+
unsafe extern "C" {
8176
+
pub fn i_cal_recurrence_get_by_set_pos_array(recur: *mut ICalRecurrence) -> *mut GArray;
8177
+
}
8178
+
unsafe extern "C" {
8179
+
pub fn i_cal_recurrence_set_by_set_pos_array(recur: *mut ICalRecurrence, values: *mut GArray);
8180
+
}
8181
+
unsafe extern "C" {
8182
+
pub fn i_cal_recurrence_get_by_set_pos(recur: *mut ICalRecurrence, index: guint) -> gshort;
8183
+
}
8184
+
unsafe extern "C" {
8185
+
pub fn i_cal_recurrence_set_by_set_pos(recur: *mut ICalRecurrence, index: guint, value: gshort);
8186
+
}
8187
+
unsafe extern "C" {
8188
+
pub fn i_cal_recur_expand_recurrence(
8189
+
rule: *const gchar,
8190
+
start: time_t,
8191
+
count: gint,
8192
+
) -> *mut GArray;
8193
+
}
8194
+
unsafe extern "C" {
8195
+
pub fn i_cal_recurrence_weekday_from_string(str_: *const gchar) -> ICalRecurrenceWeekday;
8196
+
}
8197
+
unsafe extern "C" {
8198
+
pub fn i_cal_recurrence_weekday_to_string(kind: ICalRecurrenceWeekday) -> *const gchar;
8199
+
}
8200
+
unsafe extern "C" {
8201
+
pub fn i_cal_recurrence_frequency_from_string(str_: *const gchar) -> ICalRecurrenceFrequency;
8202
+
}
8203
+
unsafe extern "C" {
8204
+
pub fn i_cal_recurrence_frequency_to_string(kind: ICalRecurrenceFrequency) -> *const gchar;
8205
+
}
8206
+
unsafe extern "C" {
8207
+
pub fn i_cal_recurrence_skip_from_string(str_: *const gchar) -> ICalRecurrenceSkip;
8208
+
}
8209
+
unsafe extern "C" {
8210
+
pub fn i_cal_recurrence_skip_to_string(kind: ICalRecurrenceSkip) -> *const gchar;
8211
+
}
8212
+
#[repr(C)]
8213
+
#[derive(Debug, Copy, Clone)]
8214
+
pub struct _ICalReqstat {
8215
+
pub parent: ICalObject,
8216
+
}
8217
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8218
+
const _: () = {
8219
+
["Size of _ICalReqstat"][::std::mem::size_of::<_ICalReqstat>() - 32usize];
8220
+
["Alignment of _ICalReqstat"][::std::mem::align_of::<_ICalReqstat>() - 8usize];
8221
+
["Offset of field: _ICalReqstat::parent"]
8222
+
[::std::mem::offset_of!(_ICalReqstat, parent) - 0usize];
8223
+
};
8224
+
unsafe extern "C" {
8225
+
pub fn i_cal_reqstat_get_type() -> GType;
8226
+
}
8227
+
unsafe extern "C" {
8228
+
pub fn i_cal_reqstat_new_from_string(str_: *const gchar) -> *mut ICalReqstat;
8229
+
}
8230
+
unsafe extern "C" {
8231
+
pub fn i_cal_reqstat_to_string(stat: *mut ICalReqstat) -> *mut gchar;
8232
+
}
8233
+
unsafe extern "C" {
8234
+
pub fn i_cal_reqstat_get_code(reqstat: *mut ICalReqstat) -> ICalRequestStatus;
8235
+
}
8236
+
unsafe extern "C" {
8237
+
pub fn i_cal_reqstat_set_code(reqstat: *mut ICalReqstat, code: ICalRequestStatus);
8238
+
}
8239
+
unsafe extern "C" {
8240
+
pub fn i_cal_reqstat_get_desc(reqstat: *const ICalReqstat) -> *const gchar;
8241
+
}
8242
+
unsafe extern "C" {
8243
+
pub fn i_cal_reqstat_get_debug(reqstat: *const ICalReqstat) -> *const gchar;
8244
+
}
8245
+
pub const ICalRestrictionKind_I_CAL_RESTRICTION_NONE: ICalRestrictionKind = 0;
8246
+
pub const ICalRestrictionKind_I_CAL_RESTRICTION_ZERO: ICalRestrictionKind = 1;
8247
+
pub const ICalRestrictionKind_I_CAL_RESTRICTION_ONE: ICalRestrictionKind = 2;
8248
+
pub const ICalRestrictionKind_I_CAL_RESTRICTION_ZEROPLUS: ICalRestrictionKind = 3;
8249
+
pub const ICalRestrictionKind_I_CAL_RESTRICTION_ONEPLUS: ICalRestrictionKind = 4;
8250
+
pub const ICalRestrictionKind_I_CAL_RESTRICTION_ZEROORONE: ICalRestrictionKind = 5;
8251
+
pub const ICalRestrictionKind_I_CAL_RESTRICTION_ONEEXCLUSIVE: ICalRestrictionKind = 6;
8252
+
pub const ICalRestrictionKind_I_CAL_RESTRICTION_ONEMUTUAL: ICalRestrictionKind = 7;
8253
+
pub const ICalRestrictionKind_I_CAL_RESTRICTION_UNKNOWN: ICalRestrictionKind = 8;
8254
+
pub type ICalRestrictionKind = ::std::os::raw::c_uint;
8255
+
unsafe extern "C" {
8256
+
pub fn i_cal_restriction_compare(restr: ICalRestrictionKind, count: gint) -> gint;
8257
+
}
8258
+
unsafe extern "C" {
8259
+
pub fn i_cal_restriction_check(comp: *mut ICalComponent) -> gint;
8260
+
}
8261
+
#[repr(C)]
8262
+
#[derive(Debug, Copy, Clone)]
8263
+
pub struct _ICalTimeSpan {
8264
+
pub parent: ICalObject,
8265
+
}
8266
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8267
+
const _: () = {
8268
+
["Size of _ICalTimeSpan"][::std::mem::size_of::<_ICalTimeSpan>() - 32usize];
8269
+
["Alignment of _ICalTimeSpan"][::std::mem::align_of::<_ICalTimeSpan>() - 8usize];
8270
+
["Offset of field: _ICalTimeSpan::parent"]
8271
+
[::std::mem::offset_of!(_ICalTimeSpan, parent) - 0usize];
8272
+
};
8273
+
unsafe extern "C" {
8274
+
pub fn i_cal_time_span_get_type() -> GType;
8275
+
}
8276
+
unsafe extern "C" {
8277
+
pub fn i_cal_time_span_new_timet(
8278
+
start: time_t,
8279
+
end: time_t,
8280
+
is_busy: gboolean,
8281
+
) -> *mut ICalTimeSpan;
8282
+
}
8283
+
unsafe extern "C" {
8284
+
pub fn i_cal_time_span_clone(src: *const ICalTimeSpan) -> *mut ICalTimeSpan;
8285
+
}
8286
+
unsafe extern "C" {
8287
+
pub fn i_cal_time_span_get_start(timespan: *mut ICalTimeSpan) -> time_t;
8288
+
}
8289
+
unsafe extern "C" {
8290
+
pub fn i_cal_time_span_set_start(timespan: *mut ICalTimeSpan, start: time_t);
8291
+
}
8292
+
unsafe extern "C" {
8293
+
pub fn i_cal_time_span_get_end(timespan: *mut ICalTimeSpan) -> time_t;
8294
+
}
8295
+
unsafe extern "C" {
8296
+
pub fn i_cal_time_span_set_end(timespan: *mut ICalTimeSpan, end: time_t);
8297
+
}
8298
+
unsafe extern "C" {
8299
+
pub fn i_cal_time_span_get_is_busy(timespan: *mut ICalTimeSpan) -> gboolean;
8300
+
}
8301
+
unsafe extern "C" {
8302
+
pub fn i_cal_time_span_set_is_busy(timespan: *mut ICalTimeSpan, is_busy: gboolean);
8303
+
}
8304
+
#[repr(C)]
8305
+
#[derive(Debug, Copy, Clone)]
8306
+
pub struct _ICalTimezone {
8307
+
pub parent: ICalObject,
8308
+
}
8309
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8310
+
const _: () = {
8311
+
["Size of _ICalTimezone"][::std::mem::size_of::<_ICalTimezone>() - 32usize];
8312
+
["Alignment of _ICalTimezone"][::std::mem::align_of::<_ICalTimezone>() - 8usize];
8313
+
["Offset of field: _ICalTimezone::parent"]
8314
+
[::std::mem::offset_of!(_ICalTimezone, parent) - 0usize];
8315
+
};
8316
+
unsafe extern "C" {
8317
+
pub fn i_cal_timezone_get_type() -> GType;
8318
+
}
8319
+
unsafe extern "C" {
8320
+
pub fn i_cal_timezone_new() -> *mut ICalTimezone;
8321
+
}
8322
+
unsafe extern "C" {
8323
+
pub fn i_cal_timezone_copy(zone: *const ICalTimezone) -> *mut ICalTimezone;
8324
+
}
8325
+
unsafe extern "C" {
8326
+
pub fn i_cal_timezone_free(zone: *mut ICalTimezone, free_struct: gint);
8327
+
}
8328
+
unsafe extern "C" {
8329
+
pub fn i_cal_timezone_set_tzid_prefix(new_prefix: *const gchar);
8330
+
}
8331
+
unsafe extern "C" {
8332
+
pub fn i_cal_timezone_free_builtin_timezones();
8333
+
}
8334
+
unsafe extern "C" {
8335
+
pub fn i_cal_timezone_get_builtin_timezone(location: *const gchar) -> *mut ICalTimezone;
8336
+
}
8337
+
unsafe extern "C" {
8338
+
pub fn i_cal_timezone_get_builtin_timezone_from_offset(
8339
+
offset: gint,
8340
+
tzname: *const gchar,
8341
+
) -> *mut ICalTimezone;
8342
+
}
8343
+
unsafe extern "C" {
8344
+
pub fn i_cal_timezone_get_builtin_timezone_from_tzid(tzid: *const gchar) -> *mut ICalTimezone;
8345
+
}
8346
+
unsafe extern "C" {
8347
+
pub fn i_cal_timezone_get_builtin_timezones() -> *mut ICalArray;
8348
+
}
8349
+
unsafe extern "C" {
8350
+
pub fn i_cal_timezone_get_utc_timezone() -> *mut ICalTimezone;
8351
+
}
8352
+
unsafe extern "C" {
8353
+
pub fn i_cal_timezone_get_tzid(zone: *const ICalTimezone) -> *const gchar;
8354
+
}
8355
+
unsafe extern "C" {
8356
+
pub fn i_cal_timezone_get_location(zone: *const ICalTimezone) -> *const gchar;
8357
+
}
8358
+
unsafe extern "C" {
8359
+
pub fn i_cal_timezone_get_tznames(zone: *const ICalTimezone) -> *const gchar;
8360
+
}
8361
+
unsafe extern "C" {
8362
+
pub fn i_cal_timezone_get_latitude(zone: *const ICalTimezone) -> gdouble;
8363
+
}
8364
+
unsafe extern "C" {
8365
+
pub fn i_cal_timezone_get_longitude(zone: *const ICalTimezone) -> gdouble;
8366
+
}
8367
+
unsafe extern "C" {
8368
+
pub fn i_cal_timezone_get_component(zone: *const ICalTimezone) -> *mut ICalComponent;
8369
+
}
8370
+
unsafe extern "C" {
8371
+
pub fn i_cal_timezone_set_component(zone: *mut ICalTimezone, comp: *mut ICalComponent) -> gint;
8372
+
}
8373
+
unsafe extern "C" {
8374
+
pub fn i_cal_timezone_get_display_name(zone: *const ICalTimezone) -> *const gchar;
8375
+
}
8376
+
unsafe extern "C" {
8377
+
pub fn i_cal_time_convert_timezone(
8378
+
tt: *mut ICalTime,
8379
+
from_zone: *mut ICalTimezone,
8380
+
to_zone: *mut ICalTimezone,
8381
+
);
8382
+
}
8383
+
unsafe extern "C" {
8384
+
pub fn i_cal_timezone_get_utc_offset(
8385
+
zone: *mut ICalTimezone,
8386
+
tt: *mut ICalTime,
8387
+
is_daylight: *mut gint,
8388
+
) -> gint;
8389
+
}
8390
+
unsafe extern "C" {
8391
+
pub fn i_cal_timezone_get_utc_offset_of_utc_time(
8392
+
zone: *mut ICalTimezone,
8393
+
tt: *mut ICalTime,
8394
+
is_daylight: *mut gint,
8395
+
) -> gint;
8396
+
}
8397
+
unsafe extern "C" {
8398
+
pub fn i_cal_timezone_array_new() -> *mut ICalArray;
8399
+
}
8400
+
unsafe extern "C" {
8401
+
pub fn i_cal_timezone_array_append_from_vtimezone(
8402
+
timezones: *mut ICalArray,
8403
+
child: *mut ICalComponent,
8404
+
);
8405
+
}
8406
+
unsafe extern "C" {
8407
+
pub fn i_cal_timezone_array_free(timezones: *mut ICalArray);
8408
+
}
8409
+
unsafe extern "C" {
8410
+
pub fn i_cal_time_timezone_expand_vtimezone(
8411
+
comp: *mut ICalComponent,
8412
+
end_year: gint,
8413
+
changes: *mut ICalArray,
8414
+
);
8415
+
}
8416
+
unsafe extern "C" {
8417
+
pub fn i_cal_timezone_get_location_from_vtimezone(component: *mut ICalComponent) -> *mut gchar;
8418
+
}
8419
+
unsafe extern "C" {
8420
+
pub fn i_cal_timezone_get_tznames_from_vtimezone(component: *mut ICalComponent) -> *mut gchar;
8421
+
}
8422
+
unsafe extern "C" {
8423
+
pub fn i_cal_timezone_get_zone_directory() -> *const gchar;
8424
+
}
8425
+
unsafe extern "C" {
8426
+
pub fn i_cal_timezone_set_zone_directory(path: *const gchar);
8427
+
}
8428
+
unsafe extern "C" {
8429
+
pub fn i_cal_timezone_free_zone_directory();
8430
+
}
8431
+
unsafe extern "C" {
8432
+
pub fn i_cal_timezone_release_zone_tab();
8433
+
}
8434
+
unsafe extern "C" {
8435
+
pub fn i_cal_timezone_set_builtin_tzdata(set: gboolean);
8436
+
}
8437
+
unsafe extern "C" {
8438
+
pub fn i_cal_timezone_get_builtin_tzdata() -> gboolean;
8439
+
}
8440
+
unsafe extern "C" {
8441
+
pub fn i_cal_timezone_dump_changes(
8442
+
zone: *mut ICalTimezone,
8443
+
max_year: gint,
8444
+
fp: *mut FILE,
8445
+
) -> gint;
8446
+
}
8447
+
unsafe extern "C" {
8448
+
pub fn i_cal_timezone_array_element_at(
8449
+
timezones: *mut ICalArray,
8450
+
index: guint,
8451
+
) -> *mut ICalTimezone;
8452
+
}
8453
+
#[repr(C)]
8454
+
#[derive(Debug, Copy, Clone)]
8455
+
pub struct _ICalTrigger {
8456
+
pub parent: ICalObject,
8457
+
}
8458
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8459
+
const _: () = {
8460
+
["Size of _ICalTrigger"][::std::mem::size_of::<_ICalTrigger>() - 32usize];
8461
+
["Alignment of _ICalTrigger"][::std::mem::align_of::<_ICalTrigger>() - 8usize];
8462
+
["Offset of field: _ICalTrigger::parent"]
8463
+
[::std::mem::offset_of!(_ICalTrigger, parent) - 0usize];
8464
+
};
8465
+
unsafe extern "C" {
8466
+
pub fn i_cal_trigger_get_type() -> GType;
8467
+
}
8468
+
unsafe extern "C" {
8469
+
pub fn i_cal_trigger_new_from_int(reltime: gint) -> *mut ICalTrigger;
8470
+
}
8471
+
unsafe extern "C" {
8472
+
pub fn i_cal_trigger_new_from_string(str_: *const gchar) -> *mut ICalTrigger;
8473
+
}
8474
+
unsafe extern "C" {
8475
+
pub fn i_cal_trigger_is_null_trigger(tr: *mut ICalTrigger) -> gboolean;
8476
+
}
8477
+
unsafe extern "C" {
8478
+
pub fn i_cal_trigger_is_bad_trigger(tr: *mut ICalTrigger) -> gboolean;
8479
+
}
8480
+
unsafe extern "C" {
8481
+
pub fn i_cal_trigger_get_time(trigger: *mut ICalTrigger) -> *mut ICalTime;
8482
+
}
8483
+
unsafe extern "C" {
8484
+
pub fn i_cal_trigger_set_time(trigger: *mut ICalTrigger, time: *mut ICalTime);
8485
+
}
8486
+
unsafe extern "C" {
8487
+
pub fn i_cal_trigger_get_duration(trigger: *mut ICalTrigger) -> *mut ICalDuration;
8488
+
}
8489
+
unsafe extern "C" {
8490
+
pub fn i_cal_trigger_set_duration(trigger: *mut ICalTrigger, duration: *mut ICalDuration);
8491
+
}
8492
+
pub const ICalUnknowntokenhandling_I_CAL_ASSUME_IANA_TOKEN: ICalUnknowntokenhandling = 1;
8493
+
pub const ICalUnknowntokenhandling_I_CAL_DISCARD_TOKEN: ICalUnknowntokenhandling = 2;
8494
+
pub const ICalUnknowntokenhandling_I_CAL_TREAT_AS_ERROR: ICalUnknowntokenhandling = 3;
8495
+
pub type ICalUnknowntokenhandling = ::std::os::raw::c_uint;
8496
+
unsafe extern "C" {
8497
+
pub fn i_cal_get_unknown_token_handling_setting() -> ICalUnknowntokenhandling;
8498
+
}
8499
+
unsafe extern "C" {
8500
+
pub fn i_cal_set_unknown_token_handling_setting(newSetting: ICalUnknowntokenhandling);
8501
+
}
8502
+
#[repr(C)]
8503
+
#[derive(Debug, Copy, Clone)]
8504
+
pub struct _ICalValue {
8505
+
pub parent: ICalObject,
8506
+
}
8507
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8508
+
const _: () = {
8509
+
["Size of _ICalValue"][::std::mem::size_of::<_ICalValue>() - 32usize];
8510
+
["Alignment of _ICalValue"][::std::mem::align_of::<_ICalValue>() - 8usize];
8511
+
["Offset of field: _ICalValue::parent"][::std::mem::offset_of!(_ICalValue, parent) - 0usize];
8512
+
};
8513
+
unsafe extern "C" {
8514
+
pub fn i_cal_value_get_type() -> GType;
8515
+
}
8516
+
unsafe extern "C" {
8517
+
pub fn i_cal_value_new(kind: ICalValueKind) -> *mut ICalValue;
8518
+
}
8519
+
unsafe extern "C" {
8520
+
pub fn i_cal_value_clone(value: *const ICalValue) -> *mut ICalValue;
8521
+
}
8522
+
unsafe extern "C" {
8523
+
pub fn i_cal_value_new_from_string(kind: ICalValueKind, str_: *const gchar) -> *mut ICalValue;
8524
+
}
8525
+
unsafe extern "C" {
8526
+
pub fn i_cal_value_free(value: *mut ICalValue);
8527
+
}
8528
+
unsafe extern "C" {
8529
+
pub fn i_cal_value_is_valid(value: *const ICalValue) -> gboolean;
8530
+
}
8531
+
unsafe extern "C" {
8532
+
pub fn i_cal_value_as_ical_string(value: *const ICalValue) -> *mut gchar;
8533
+
}
8534
+
unsafe extern "C" {
8535
+
pub fn i_cal_value_isa(value: *const ICalValue) -> ICalValueKind;
8536
+
}
8537
+
unsafe extern "C" {
8538
+
pub fn i_cal_value_isa_value(value: *mut ICalValue) -> gint;
8539
+
}
8540
+
unsafe extern "C" {
8541
+
pub fn i_cal_value_compare(
8542
+
a: *const ICalValue,
8543
+
b: *const ICalValue,
8544
+
) -> ICalParameterXliccomparetype;
8545
+
}
8546
+
unsafe extern "C" {
8547
+
pub fn i_cal_value_kind_from_string(str_: *const gchar) -> ICalValueKind;
8548
+
}
8549
+
unsafe extern "C" {
8550
+
pub fn i_cal_value_kind_to_string(kind: ICalValueKind) -> *const gchar;
8551
+
}
8552
+
unsafe extern "C" {
8553
+
pub fn i_cal_value_kind_is_valid(kind: ICalValueKind) -> gboolean;
8554
+
}
8555
+
unsafe extern "C" {
8556
+
pub fn i_cal_value_encode_ical_string(szText: *const gchar) -> *mut gchar;
8557
+
}
8558
+
unsafe extern "C" {
8559
+
pub fn i_cal_value_decode_ical_string(szText: *const gchar) -> *mut gchar;
8560
+
}
8561
+
pub const ECalClientSourceType_E_CAL_CLIENT_SOURCE_TYPE_EVENTS: ECalClientSourceType = 0;
8562
+
pub const ECalClientSourceType_E_CAL_CLIENT_SOURCE_TYPE_TASKS: ECalClientSourceType = 1;
8563
+
pub const ECalClientSourceType_E_CAL_CLIENT_SOURCE_TYPE_MEMOS: ECalClientSourceType = 2;
8564
+
pub const ECalClientSourceType_E_CAL_CLIENT_SOURCE_TYPE_LAST: ECalClientSourceType = 3;
8565
+
#[doc = " ECalClientSourceType:\n @E_CAL_CLIENT_SOURCE_TYPE_EVENTS: Events calander\n @E_CAL_CLIENT_SOURCE_TYPE_TASKS: Task list calendar\n @E_CAL_CLIENT_SOURCE_TYPE_MEMOS: Memo list calendar\n @E_CAL_CLIENT_SOURCE_TYPE_LAST: Artificial 'last' value of the enum\n\n Indicates the type of calendar\n\n Since: 3.2"]
8566
+
pub type ECalClientSourceType = ::std::os::raw::c_uint;
8567
+
pub const ECalObjModType_E_CAL_OBJ_MOD_THIS: ECalObjModType = 1;
8568
+
pub const ECalObjModType_E_CAL_OBJ_MOD_THIS_AND_PRIOR: ECalObjModType = 2;
8569
+
pub const ECalObjModType_E_CAL_OBJ_MOD_THIS_AND_FUTURE: ECalObjModType = 4;
8570
+
pub const ECalObjModType_E_CAL_OBJ_MOD_ALL: ECalObjModType = 7;
8571
+
pub const ECalObjModType_E_CAL_OBJ_MOD_ONLY_THIS: ECalObjModType = 8;
8572
+
#[doc = " ECalObjModType:\n @E_CAL_OBJ_MOD_THIS: Modify this component\n @E_CAL_OBJ_MOD_THIS_AND_PRIOR: Modify this component and all prior occurrances\n @E_CAL_OBJ_MOD_THIS_AND_FUTURE: Modify this component and all future occurrances\n @E_CAL_OBJ_MOD_ALL: Modify all occurrances of this component\n @E_CAL_OBJ_MOD_ONLY_THIS: Modify only this component\n\n Indicates the type of modification made to a calendar\n\n Since: 3.8"]
8573
+
pub type ECalObjModType = ::std::os::raw::c_uint;
8574
+
pub const ECalOperationFlags_E_CAL_OPERATION_FLAG_NONE: ECalOperationFlags = 0;
8575
+
pub const ECalOperationFlags_E_CAL_OPERATION_FLAG_CONFLICT_FAIL: ECalOperationFlags = 1;
8576
+
pub const ECalOperationFlags_E_CAL_OPERATION_FLAG_CONFLICT_USE_NEWER: ECalOperationFlags = 2;
8577
+
pub const ECalOperationFlags_E_CAL_OPERATION_FLAG_CONFLICT_KEEP_SERVER: ECalOperationFlags = 4;
8578
+
pub const ECalOperationFlags_E_CAL_OPERATION_FLAG_CONFLICT_KEEP_LOCAL: ECalOperationFlags = 0;
8579
+
pub const ECalOperationFlags_E_CAL_OPERATION_FLAG_CONFLICT_WRITE_COPY: ECalOperationFlags = 8;
8580
+
pub const ECalOperationFlags_E_CAL_OPERATION_FLAG_DISABLE_ITIP_MESSAGE: ECalOperationFlags = 16;
8581
+
#[doc = " ECalOperationFlags:\n @E_CAL_OPERATION_FLAG_NONE: no operation flags defined\n @E_CAL_OPERATION_FLAG_CONFLICT_FAIL: conflict resolution mode, to fail and do not\n do any changes, when a conflict is detected\n @E_CAL_OPERATION_FLAG_CONFLICT_USE_NEWER: conflict resolution mode, to use newer\n of the local and the server side data, when a conflict is detected\n @E_CAL_OPERATION_FLAG_CONFLICT_KEEP_SERVER: conflict resolution mode, to use\n the server data (and local changed), when a conflict is detected\n @E_CAL_OPERATION_FLAG_CONFLICT_KEEP_LOCAL: conflict resolution mode, to use\n local data (and always overwrite server data), when a conflict is detected\n @E_CAL_OPERATION_FLAG_CONFLICT_WRITE_COPY: conflict resolution mode, to create\n a copy of the data, when a conflict is detected\n @E_CAL_OPERATION_FLAG_DISABLE_ITIP_MESSAGE: request to disable send of an iTip\n message by the server; this works only for servers which support iTip handling\n\n Calendar operation flags, to specify behavior in certain situations. The conflict\n resolution mode flags cannot be combined together, where the @E_CAL_OPERATION_FLAG_CONFLICT_KEEP_LOCAL\n is the default behavior (and it is used when no other conflict resolution flag is set).\n The flags can be ignored when the operation or the backend don't support it.\n\n Since: 3.34"]
8582
+
pub type ECalOperationFlags = ::std::os::raw::c_uint;
8583
+
#[doc = " ECalRecurResolveTimezoneCb:\n @tzid: timezone ID to resolve\n @user_data: user data used for this callback\n @cancellable: optional #GCancellable object, or %NULL\n @error: return location for a #GError, or %NULL\n\n Resolve timezone by its ID provided as @tzid. The returned object,\n if not %NULL, is owned by the callback implementation and should\n not be freed.\n\n Returns: (transfer none) (nullable): an #ICalTimezone object for @tzid,\n or %NULL, on error or if not found.\n\n Since: 3.34"]
8584
+
pub type ECalRecurResolveTimezoneCb = ::std::option::Option<
8585
+
unsafe extern "C" fn(
8586
+
tzid: *const gchar,
8587
+
user_data: gpointer,
8588
+
cancellable: *mut GCancellable,
8589
+
error: *mut *mut GError,
8590
+
) -> *mut ICalTimezone,
8591
+
>;
8592
+
#[doc = " ECalRecurInstanceCb:\n @icomp: an #ICalComponent\n @instance_start: start time of an instance\n @instance_end: end time of an instance\n @user_data: user data used for this callback in e_cal_recur_generate_instances_sync()\n @cancellable: optional #GCancellable object, or %NULL\n @error: return location for a #GError, or %NULL\n\n Callback used by e_cal_recur_generate_instances_sync(), called\n for each instance of a (recurring) component within given time range.\n\n Returns: %TRUE, to continue recurrence generation, %FALSE to stop\n\n Since: 3.34"]
8593
+
pub type ECalRecurInstanceCb = ::std::option::Option<
8594
+
unsafe extern "C" fn(
8595
+
icomp: *mut ICalComponent,
8596
+
instance_start: *mut ICalTime,
8597
+
instance_end: *mut ICalTime,
8598
+
user_data: gpointer,
8599
+
cancellable: *mut GCancellable,
8600
+
error: *mut *mut GError,
8601
+
) -> gboolean,
8602
+
>;
8603
+
unsafe extern "C" {
8604
+
pub fn e_cal_client_check_timezones_sync(
8605
+
vcalendar: *mut ICalComponent,
8606
+
icalcomps: *mut GSList,
8607
+
tzlookup: ECalRecurResolveTimezoneCb,
8608
+
tzlookup_data: gpointer,
8609
+
cancellable: *mut GCancellable,
8610
+
error: *mut *mut GError,
8611
+
) -> gboolean;
8612
+
}
8613
+
unsafe extern "C" {
8614
+
pub fn e_cal_client_tzlookup_cb(
8615
+
tzid: *const gchar,
8616
+
ecalclient: gpointer,
8617
+
cancellable: *mut GCancellable,
8618
+
error: *mut *mut GError,
8619
+
) -> *mut ICalTimezone;
8620
+
}
8621
+
#[repr(C)]
8622
+
#[derive(Debug, Copy, Clone)]
8623
+
pub struct _ECalClientTzlookupICalCompData {
8624
+
_unused: [u8; 0],
8625
+
}
8626
+
#[doc = " ECalClientTzlookupICalCompData:\n\n Contains data used as lookup_data of e_cal_client_tzlookup_icalcomp_cb().\n\n Since: 3.34"]
8627
+
pub type ECalClientTzlookupICalCompData = _ECalClientTzlookupICalCompData;
8628
+
unsafe extern "C" {
8629
+
pub fn e_cal_client_tzlookup_icalcomp_data_get_type() -> GType;
8630
+
}
8631
+
unsafe extern "C" {
8632
+
pub fn e_cal_client_tzlookup_icalcomp_data_new(
8633
+
icomp: *mut ICalComponent,
8634
+
) -> *mut ECalClientTzlookupICalCompData;
8635
+
}
8636
+
unsafe extern "C" {
8637
+
pub fn e_cal_client_tzlookup_icalcomp_data_copy(
8638
+
lookup_data: *const ECalClientTzlookupICalCompData,
8639
+
) -> *mut ECalClientTzlookupICalCompData;
8640
+
}
8641
+
unsafe extern "C" {
8642
+
pub fn e_cal_client_tzlookup_icalcomp_data_free(
8643
+
lookup_data: *mut ECalClientTzlookupICalCompData,
8644
+
);
8645
+
}
8646
+
unsafe extern "C" {
8647
+
pub fn e_cal_client_tzlookup_icalcomp_data_get_icalcomponent(
8648
+
lookup_data: *const ECalClientTzlookupICalCompData,
8649
+
) -> *mut ICalComponent;
8650
+
}
8651
+
unsafe extern "C" {
8652
+
pub fn e_cal_client_tzlookup_icalcomp_cb(
8653
+
tzid: *const gchar,
8654
+
lookup_data: gpointer,
8655
+
cancellable: *mut GCancellable,
8656
+
error: *mut *mut GError,
8657
+
) -> *mut ICalTimezone;
8658
+
}
8659
+
#[doc = " ECalClientView:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.2"]
8660
+
pub type ECalClientView = _ECalClientView;
8661
+
#[repr(C)]
8662
+
#[derive(Debug, Copy, Clone)]
8663
+
pub struct _ECalClientViewPrivate {
8664
+
_unused: [u8; 0],
8665
+
}
8666
+
pub type ECalClientViewPrivate = _ECalClientViewPrivate;
8667
+
pub const ECalClientViewFlags_E_CAL_CLIENT_VIEW_FLAGS_NONE: ECalClientViewFlags = 0;
8668
+
pub const ECalClientViewFlags_E_CAL_CLIENT_VIEW_FLAGS_NOTIFY_INITIAL: ECalClientViewFlags = 1;
8669
+
#[doc = " ECalClientViewFlags:\n @E_CAL_CLIENT_VIEW_FLAGS_NONE:\n Symbolic value for no flags\n @E_CAL_CLIENT_VIEW_FLAGS_NOTIFY_INITIAL:\n If this flag is set then all objects matching the view's query will\n be sent as notifications when starting the view, otherwise only future\n changes will be reported. The default for an #ECalClientView is %TRUE.\n\n Flags that control the behaviour of an #ECalClientView.\n\n Since: 3.6"]
8670
+
pub type ECalClientViewFlags = ::std::os::raw::c_uint;
8671
+
#[doc = " ECalClientView:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.2"]
8672
+
#[repr(C)]
8673
+
#[derive(Debug, Copy, Clone)]
8674
+
pub struct _ECalClientView {
8675
+
pub object: GObject,
8676
+
pub priv_: *mut ECalClientViewPrivate,
8677
+
}
8678
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8679
+
const _: () = {
8680
+
["Size of _ECalClientView"][::std::mem::size_of::<_ECalClientView>() - 32usize];
8681
+
["Alignment of _ECalClientView"][::std::mem::align_of::<_ECalClientView>() - 8usize];
8682
+
["Offset of field: _ECalClientView::object"]
8683
+
[::std::mem::offset_of!(_ECalClientView, object) - 0usize];
8684
+
["Offset of field: _ECalClientView::priv_"]
8685
+
[::std::mem::offset_of!(_ECalClientView, priv_) - 24usize];
8686
+
};
8687
+
unsafe extern "C" {
8688
+
pub fn e_cal_client_view_get_type() -> GType;
8689
+
}
8690
+
unsafe extern "C" {
8691
+
pub fn e_cal_client_view_ref_client(client_view: *mut ECalClientView) -> *mut _ECalClient;
8692
+
}
8693
+
unsafe extern "C" {
8694
+
pub fn e_cal_client_view_get_connection(
8695
+
client_view: *mut ECalClientView,
8696
+
) -> *mut GDBusConnection;
8697
+
}
8698
+
unsafe extern "C" {
8699
+
pub fn e_cal_client_view_get_object_path(client_view: *mut ECalClientView) -> *const gchar;
8700
+
}
8701
+
unsafe extern "C" {
8702
+
pub fn e_cal_client_view_is_running(client_view: *mut ECalClientView) -> gboolean;
8703
+
}
8704
+
unsafe extern "C" {
8705
+
pub fn e_cal_client_view_set_fields_of_interest(
8706
+
client_view: *mut ECalClientView,
8707
+
fields_of_interest: *const GSList,
8708
+
error: *mut *mut GError,
8709
+
);
8710
+
}
8711
+
unsafe extern "C" {
8712
+
pub fn e_cal_client_view_start(client_view: *mut ECalClientView, error: *mut *mut GError);
8713
+
}
8714
+
unsafe extern "C" {
8715
+
pub fn e_cal_client_view_stop(client_view: *mut ECalClientView, error: *mut *mut GError);
8716
+
}
8717
+
unsafe extern "C" {
8718
+
pub fn e_cal_client_view_set_flags(
8719
+
client_view: *mut ECalClientView,
8720
+
flags: ECalClientViewFlags,
8721
+
error: *mut *mut GError,
8722
+
);
8723
+
}
8724
+
pub const ECalClientError_E_CAL_CLIENT_ERROR_NO_SUCH_CALENDAR: ECalClientError = 0;
8725
+
pub const ECalClientError_E_CAL_CLIENT_ERROR_OBJECT_NOT_FOUND: ECalClientError = 1;
8726
+
pub const ECalClientError_E_CAL_CLIENT_ERROR_INVALID_OBJECT: ECalClientError = 2;
8727
+
pub const ECalClientError_E_CAL_CLIENT_ERROR_UNKNOWN_USER: ECalClientError = 3;
8728
+
pub const ECalClientError_E_CAL_CLIENT_ERROR_OBJECT_ID_ALREADY_EXISTS: ECalClientError = 4;
8729
+
pub const ECalClientError_E_CAL_CLIENT_ERROR_INVALID_RANGE: ECalClientError = 5;
8730
+
#[doc = " ECalClientError:\n @E_CAL_CLIENT_ERROR_NO_SUCH_CALENDAR: No such calendar\n @E_CAL_CLIENT_ERROR_OBJECT_NOT_FOUND: Object not found\n @E_CAL_CLIENT_ERROR_INVALID_OBJECT: Invalid object\n @E_CAL_CLIENT_ERROR_UNKNOWN_USER: Unknown user\n @E_CAL_CLIENT_ERROR_OBJECT_ID_ALREADY_EXISTS: Object ID already exists\n @E_CAL_CLIENT_ERROR_INVALID_RANGE: Invalid range\n\n Since: 3.2"]
8731
+
pub type ECalClientError = ::std::os::raw::c_uint;
8732
+
unsafe extern "C" {
8733
+
pub fn e_cal_client_error_quark() -> GQuark;
8734
+
}
8735
+
unsafe extern "C" {
8736
+
pub fn e_cal_client_error_to_string(code: ECalClientError) -> *const gchar;
8737
+
}
8738
+
unsafe extern "C" {
8739
+
pub fn e_cal_client_error_create(
8740
+
code: ECalClientError,
8741
+
custom_msg: *const gchar,
8742
+
) -> *mut GError;
8743
+
}
8744
+
unsafe extern "C" {
8745
+
pub fn e_cal_client_error_create_fmt(
8746
+
code: ECalClientError,
8747
+
format: *const gchar,
8748
+
...
8749
+
) -> *mut GError;
8750
+
}
8751
+
#[doc = " ECalClient:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.2"]
8752
+
pub type ECalClient = _ECalClient;
8753
+
#[repr(C)]
8754
+
#[derive(Debug, Copy, Clone)]
8755
+
pub struct _ECalClientPrivate {
8756
+
_unused: [u8; 0],
8757
+
}
8758
+
pub type ECalClientPrivate = _ECalClientPrivate;
8759
+
#[doc = " ECalClient:\n\n Contains only private data that should be read and manipulated using the\n functions below.\n\n Since: 3.2"]
8760
+
#[repr(C)]
8761
+
#[derive(Debug, Copy, Clone)]
8762
+
pub struct _ECalClient {
8763
+
pub parent: EClient,
8764
+
pub priv_: *mut ECalClientPrivate,
8765
+
}
8766
+
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8767
+
const _: () = {
8768
+
["Size of _ECalClient"][::std::mem::size_of::<_ECalClient>() - 40usize];
8769
+
["Alignment of _ECalClient"][::std::mem::align_of::<_ECalClient>() - 8usize];
8770
+
["Offset of field: _ECalClient::parent"][::std::mem::offset_of!(_ECalClient, parent) - 0usize];
8771
+
["Offset of field: _ECalClient::priv_"][::std::mem::offset_of!(_ECalClient, priv_) - 32usize];
8772
+
};
8773
+
unsafe extern "C" {
8774
+
pub fn e_cal_client_get_type() -> GType;
8775
+
}
8776
+
unsafe extern "C" {
8777
+
pub fn e_cal_client_connect_sync(
8778
+
source: *mut ESource,
8779
+
source_type: ECalClientSourceType,
8780
+
wait_for_connected_seconds: guint32,
8781
+
cancellable: *mut GCancellable,
8782
+
error: *mut *mut GError,
8783
+
) -> *mut EClient;
8784
+
}
8785
+
unsafe extern "C" {
8786
+
pub fn e_cal_client_connect(
8787
+
source: *mut ESource,
8788
+
source_type: ECalClientSourceType,
8789
+
wait_for_connected_seconds: guint32,
8790
+
cancellable: *mut GCancellable,
8791
+
callback: GAsyncReadyCallback,
8792
+
user_data: gpointer,
8793
+
);
8794
+
}
8795
+
unsafe extern "C" {
8796
+
pub fn e_cal_client_connect_finish(
8797
+
result: *mut GAsyncResult,
8798
+
error: *mut *mut GError,
8799
+
) -> *mut EClient;
8800
+
}
8801
+
unsafe extern "C" {
8802
+
pub fn e_cal_client_get_source_type(client: *mut ECalClient) -> ECalClientSourceType;
8803
+
}
8804
+
unsafe extern "C" {
8805
+
pub fn e_cal_client_get_local_attachment_store(client: *mut ECalClient) -> *const gchar;
8806
+
}
8807
+
unsafe extern "C" {
8808
+
pub fn e_cal_client_set_default_timezone(client: *mut ECalClient, zone: *mut ICalTimezone);
8809
+
}
8810
+
unsafe extern "C" {
8811
+
pub fn e_cal_client_get_default_timezone(client: *mut ECalClient) -> *mut ICalTimezone;
8812
+
}
8813
+
unsafe extern "C" {
8814
+
pub fn e_cal_client_check_one_alarm_only(client: *mut ECalClient) -> gboolean;
8815
+
}
8816
+
unsafe extern "C" {
8817
+
pub fn e_cal_client_check_save_schedules(client: *mut ECalClient) -> gboolean;
8818
+
}
8819
+
unsafe extern "C" {
8820
+
pub fn e_cal_client_check_organizer_must_attend(client: *mut ECalClient) -> gboolean;
8821
+
}
8822
+
unsafe extern "C" {
8823
+
pub fn e_cal_client_check_organizer_must_accept(client: *mut ECalClient) -> gboolean;
8824
+
}
8825
+
unsafe extern "C" {
8826
+
pub fn e_cal_client_check_recurrences_no_master(client: *mut ECalClient) -> gboolean;
8827
+
}
8828
+
unsafe extern "C" {
8829
+
pub fn e_cal_client_generate_instances(
8830
+
client: *mut ECalClient,
8831
+
start: time_t,
8832
+
end: time_t,
8833
+
cancellable: *mut GCancellable,
8834
+
cb: ECalRecurInstanceCb,
8835
+
cb_data: gpointer,
8836
+
destroy_cb_data: GDestroyNotify,
8837
+
);
8838
+
}
8839
+
unsafe extern "C" {
8840
+
pub fn e_cal_client_generate_instances_sync(
8841
+
client: *mut ECalClient,
8842
+
start: time_t,
8843
+
end: time_t,
8844
+
cancellable: *mut GCancellable,
8845
+
cb: ECalRecurInstanceCb,
8846
+
cb_data: gpointer,
8847
+
);
8848
+
}
8849
+
unsafe extern "C" {
8850
+
pub fn e_cal_client_generate_instances_for_object(
8851
+
client: *mut ECalClient,
8852
+
icalcomp: *mut ICalComponent,
8853
+
start: time_t,
8854
+
end: time_t,
8855
+
cancellable: *mut GCancellable,
8856
+
cb: ECalRecurInstanceCb,
8857
+
cb_data: gpointer,
8858
+
destroy_cb_data: GDestroyNotify,
8859
+
);
8860
+
}
8861
+
unsafe extern "C" {
8862
+
pub fn e_cal_client_generate_instances_for_object_sync(
8863
+
client: *mut ECalClient,
8864
+
icalcomp: *mut ICalComponent,
8865
+
start: time_t,
8866
+
end: time_t,
8867
+
cancellable: *mut GCancellable,
8868
+
cb: ECalRecurInstanceCb,
8869
+
cb_data: gpointer,
8870
+
);
8871
+
}
8872
+
unsafe extern "C" {
8873
+
pub fn e_cal_client_generate_instances_for_uid_sync(
8874
+
client: *mut ECalClient,
8875
+
uid: *const gchar,
8876
+
start: time_t,
8877
+
end: time_t,
8878
+
cancellable: *mut GCancellable,
8879
+
cb: ECalRecurInstanceCb,
8880
+
cb_data: gpointer,
8881
+
);
8882
+
}
8883
+
unsafe extern "C" {
8884
+
pub fn e_cal_client_get_component_as_string(
8885
+
client: *mut ECalClient,
8886
+
icalcomp: *mut ICalComponent,
8887
+
) -> *mut gchar;
8888
+
}
8889
+
unsafe extern "C" {
8890
+
pub fn e_cal_client_get_default_object(
8891
+
client: *mut ECalClient,
8892
+
cancellable: *mut GCancellable,
8893
+
callback: GAsyncReadyCallback,
8894
+
user_data: gpointer,
8895
+
);
8896
+
}
8897
+
unsafe extern "C" {
8898
+
pub fn e_cal_client_get_default_object_finish(
8899
+
client: *mut ECalClient,
8900
+
result: *mut GAsyncResult,
8901
+
out_icalcomp: *mut *mut ICalComponent,
8902
+
error: *mut *mut GError,
8903
+
) -> gboolean;
8904
+
}
8905
+
unsafe extern "C" {
8906
+
pub fn e_cal_client_get_default_object_sync(
8907
+
client: *mut ECalClient,
8908
+
out_icalcomp: *mut *mut ICalComponent,
8909
+
cancellable: *mut GCancellable,
8910
+
error: *mut *mut GError,
8911
+
) -> gboolean;
8912
+
}
8913
+
unsafe extern "C" {
8914
+
pub fn e_cal_client_get_object(
8915
+
client: *mut ECalClient,
8916
+
uid: *const gchar,
8917
+
rid: *const gchar,
8918
+
cancellable: *mut GCancellable,
8919
+
callback: GAsyncReadyCallback,
8920
+
user_data: gpointer,
8921
+
);
8922
+
}
8923
+
unsafe extern "C" {
8924
+
pub fn e_cal_client_get_object_finish(
8925
+
client: *mut ECalClient,
8926
+
result: *mut GAsyncResult,
8927
+
out_icalcomp: *mut *mut ICalComponent,
8928
+
error: *mut *mut GError,
8929
+
) -> gboolean;
8930
+
}
8931
+
unsafe extern "C" {
8932
+
pub fn e_cal_client_get_object_sync(
8933
+
client: *mut ECalClient,
8934
+
uid: *const gchar,
8935
+
rid: *const gchar,
8936
+
out_icalcomp: *mut *mut ICalComponent,
8937
+
cancellable: *mut GCancellable,
8938
+
error: *mut *mut GError,
8939
+
) -> gboolean;
8940
+
}
8941
+
unsafe extern "C" {
8942
+
pub fn e_cal_client_get_objects_for_uid(
8943
+
client: *mut ECalClient,
8944
+
uid: *const gchar,
8945
+
cancellable: *mut GCancellable,
8946
+
callback: GAsyncReadyCallback,
8947
+
user_data: gpointer,
8948
+
);
8949
+
}
8950
+
unsafe extern "C" {
8951
+
pub fn e_cal_client_get_objects_for_uid_finish(
8952
+
client: *mut ECalClient,
8953
+
result: *mut GAsyncResult,
8954
+
out_ecalcomps: *mut *mut GSList,
8955
+
error: *mut *mut GError,
8956
+
) -> gboolean;
8957
+
}
8958
+
unsafe extern "C" {
8959
+
pub fn e_cal_client_get_objects_for_uid_sync(
8960
+
client: *mut ECalClient,
8961
+
uid: *const gchar,
8962
+
out_ecalcomps: *mut *mut GSList,
8963
+
cancellable: *mut GCancellable,
8964
+
error: *mut *mut GError,
8965
+
) -> gboolean;
8966
+
}
8967
+
unsafe extern "C" {
8968
+
pub fn e_cal_client_get_object_list(
8969
+
client: *mut ECalClient,
8970
+
sexp: *const gchar,
8971
+
cancellable: *mut GCancellable,
8972
+
callback: GAsyncReadyCallback,
8973
+
user_data: gpointer,
8974
+
);
8975
+
}
8976
+
unsafe extern "C" {
8977
+
pub fn e_cal_client_get_object_list_finish(
8978
+
client: *mut ECalClient,
8979
+
result: *mut GAsyncResult,
8980
+
out_icalcomps: *mut *mut GSList,
8981
+
error: *mut *mut GError,
8982
+
) -> gboolean;
8983
+
}
8984
+
unsafe extern "C" {
8985
+
pub fn e_cal_client_get_object_list_sync(
8986
+
client: *mut ECalClient,
8987
+
sexp: *const gchar,
8988
+
out_icalcomps: *mut *mut GSList,
8989
+
cancellable: *mut GCancellable,
8990
+
error: *mut *mut GError,
8991
+
) -> gboolean;
8992
+
}
8993
+
unsafe extern "C" {
8994
+
pub fn e_cal_client_get_object_list_as_comps(
8995
+
client: *mut ECalClient,
8996
+
sexp: *const gchar,
8997
+
cancellable: *mut GCancellable,
8998
+
callback: GAsyncReadyCallback,
8999
+
user_data: gpointer,
9000
+
);
9001
+
}
9002
+
unsafe extern "C" {
9003
+
pub fn e_cal_client_get_object_list_as_comps_finish(
9004
+
client: *mut ECalClient,
9005
+
result: *mut GAsyncResult,
9006
+
out_ecalcomps: *mut *mut GSList,
9007
+
error: *mut *mut GError,
9008
+
) -> gboolean;
9009
+
}
9010
+
unsafe extern "C" {
9011
+
pub fn e_cal_client_get_object_list_as_comps_sync(
9012
+
client: *mut ECalClient,
9013
+
sexp: *const gchar,
9014
+
out_ecalcomps: *mut *mut GSList,
9015
+
cancellable: *mut GCancellable,
9016
+
error: *mut *mut GError,
9017
+
) -> gboolean;
9018
+
}
9019
+
unsafe extern "C" {
9020
+
pub fn e_cal_client_get_free_busy(
9021
+
client: *mut ECalClient,
9022
+
start: time_t,
9023
+
end: time_t,
9024
+
users: *const GSList,
9025
+
cancellable: *mut GCancellable,
9026
+
callback: GAsyncReadyCallback,
9027
+
user_data: gpointer,
9028
+
);
9029
+
}
9030
+
unsafe extern "C" {
9031
+
pub fn e_cal_client_get_free_busy_finish(
9032
+
client: *mut ECalClient,
9033
+
result: *mut GAsyncResult,
9034
+
out_freebusy: *mut *mut GSList,
9035
+
error: *mut *mut GError,
9036
+
) -> gboolean;
9037
+
}
9038
+
unsafe extern "C" {
9039
+
pub fn e_cal_client_get_free_busy_sync(
9040
+
client: *mut ECalClient,
9041
+
start: time_t,
9042
+
end: time_t,
9043
+
users: *const GSList,
9044
+
out_freebusy: *mut *mut GSList,
9045
+
cancellable: *mut GCancellable,
9046
+
error: *mut *mut GError,
9047
+
) -> gboolean;
9048
+
}
9049
+
unsafe extern "C" {
9050
+
pub fn e_cal_client_create_object(
9051
+
client: *mut ECalClient,
9052
+
icalcomp: *mut ICalComponent,
9053
+
opflags: ECalOperationFlags,
9054
+
cancellable: *mut GCancellable,
9055
+
callback: GAsyncReadyCallback,
9056
+
user_data: gpointer,
9057
+
);
9058
+
}
9059
+
unsafe extern "C" {
9060
+
pub fn e_cal_client_create_object_finish(
9061
+
client: *mut ECalClient,
9062
+
result: *mut GAsyncResult,
9063
+
out_uid: *mut *mut gchar,
9064
+
error: *mut *mut GError,
9065
+
) -> gboolean;
9066
+
}
9067
+
unsafe extern "C" {
9068
+
pub fn e_cal_client_create_object_sync(
9069
+
client: *mut ECalClient,
9070
+
icalcomp: *mut ICalComponent,
9071
+
opflags: ECalOperationFlags,
9072
+
out_uid: *mut *mut gchar,
9073
+
cancellable: *mut GCancellable,
9074
+
error: *mut *mut GError,
9075
+
) -> gboolean;
9076
+
}
9077
+
unsafe extern "C" {
9078
+
pub fn e_cal_client_create_objects(
9079
+
client: *mut ECalClient,
9080
+
icalcomps: *mut GSList,
9081
+
opflags: ECalOperationFlags,
9082
+
cancellable: *mut GCancellable,
9083
+
callback: GAsyncReadyCallback,
9084
+
user_data: gpointer,
9085
+
);
9086
+
}
9087
+
unsafe extern "C" {
9088
+
pub fn e_cal_client_create_objects_finish(
9089
+
client: *mut ECalClient,
9090
+
result: *mut GAsyncResult,
9091
+
out_uids: *mut *mut GSList,
9092
+
error: *mut *mut GError,
9093
+
) -> gboolean;
9094
+
}
9095
+
unsafe extern "C" {
9096
+
pub fn e_cal_client_create_objects_sync(
9097
+
client: *mut ECalClient,
9098
+
icalcomps: *mut GSList,
9099
+
opflags: ECalOperationFlags,
9100
+
out_uids: *mut *mut GSList,
9101
+
cancellable: *mut GCancellable,
9102
+
error: *mut *mut GError,
9103
+
) -> gboolean;
9104
+
}
9105
+
unsafe extern "C" {
9106
+
pub fn e_cal_client_modify_object(
9107
+
client: *mut ECalClient,
9108
+
icalcomp: *mut ICalComponent,
9109
+
mod_: ECalObjModType,
9110
+
opflags: ECalOperationFlags,
9111
+
cancellable: *mut GCancellable,
9112
+
callback: GAsyncReadyCallback,
9113
+
user_data: gpointer,
9114
+
);
9115
+
}
9116
+
unsafe extern "C" {
9117
+
pub fn e_cal_client_modify_object_finish(
9118
+
client: *mut ECalClient,
9119
+
result: *mut GAsyncResult,
9120
+
error: *mut *mut GError,
9121
+
) -> gboolean;
9122
+
}
9123
+
unsafe extern "C" {
9124
+
pub fn e_cal_client_modify_object_sync(
9125
+
client: *mut ECalClient,
9126
+
icalcomp: *mut ICalComponent,
9127
+
mod_: ECalObjModType,
9128
+
opflags: ECalOperationFlags,
9129
+
cancellable: *mut GCancellable,
9130
+
error: *mut *mut GError,
9131
+
) -> gboolean;
9132
+
}
9133
+
unsafe extern "C" {
9134
+
pub fn e_cal_client_modify_objects(
9135
+
client: *mut ECalClient,
9136
+
icalcomps: *mut GSList,
9137
+
mod_: ECalObjModType,
9138
+
opflags: ECalOperationFlags,
9139
+
cancellable: *mut GCancellable,
9140
+
callback: GAsyncReadyCallback,
9141
+
user_data: gpointer,
9142
+
);
9143
+
}
9144
+
unsafe extern "C" {
9145
+
pub fn e_cal_client_modify_objects_finish(
9146
+
client: *mut ECalClient,
9147
+
result: *mut GAsyncResult,
9148
+
error: *mut *mut GError,
9149
+
) -> gboolean;
9150
+
}
9151
+
unsafe extern "C" {
9152
+
pub fn e_cal_client_modify_objects_sync(
9153
+
client: *mut ECalClient,
9154
+
icalcomps: *mut GSList,
9155
+
mod_: ECalObjModType,
9156
+
opflags: ECalOperationFlags,
9157
+
cancellable: *mut GCancellable,
9158
+
error: *mut *mut GError,
9159
+
) -> gboolean;
9160
+
}
9161
+
unsafe extern "C" {
9162
+
pub fn e_cal_client_remove_object(
9163
+
client: *mut ECalClient,
9164
+
uid: *const gchar,
9165
+
rid: *const gchar,
9166
+
mod_: ECalObjModType,
9167
+
opflags: ECalOperationFlags,
9168
+
cancellable: *mut GCancellable,
9169
+
callback: GAsyncReadyCallback,
9170
+
user_data: gpointer,
9171
+
);
9172
+
}
9173
+
unsafe extern "C" {
9174
+
pub fn e_cal_client_remove_object_finish(
9175
+
client: *mut ECalClient,
9176
+
result: *mut GAsyncResult,
9177
+
error: *mut *mut GError,
9178
+
) -> gboolean;
9179
+
}
9180
+
unsafe extern "C" {
9181
+
pub fn e_cal_client_remove_object_sync(
9182
+
client: *mut ECalClient,
9183
+
uid: *const gchar,
9184
+
rid: *const gchar,
9185
+
mod_: ECalObjModType,
9186
+
opflags: ECalOperationFlags,
9187
+
cancellable: *mut GCancellable,
9188
+
error: *mut *mut GError,
9189
+
) -> gboolean;
9190
+
}
9191
+
unsafe extern "C" {
9192
+
pub fn e_cal_client_remove_objects(
9193
+
client: *mut ECalClient,
9194
+
ids: *const GSList,
9195
+
mod_: ECalObjModType,
9196
+
opflags: ECalOperationFlags,
9197
+
cancellable: *mut GCancellable,
9198
+
callback: GAsyncReadyCallback,
9199
+
user_data: gpointer,
9200
+
);
9201
+
}
9202
+
unsafe extern "C" {
9203
+
pub fn e_cal_client_remove_objects_finish(
9204
+
client: *mut ECalClient,
9205
+
result: *mut GAsyncResult,
9206
+
error: *mut *mut GError,
9207
+
) -> gboolean;
9208
+
}
9209
+
unsafe extern "C" {
9210
+
pub fn e_cal_client_remove_objects_sync(
9211
+
client: *mut ECalClient,
9212
+
ids: *const GSList,
9213
+
mod_: ECalObjModType,
9214
+
opflags: ECalOperationFlags,
9215
+
cancellable: *mut GCancellable,
9216
+
error: *mut *mut GError,
9217
+
) -> gboolean;
9218
+
}
9219
+
unsafe extern "C" {
9220
+
pub fn e_cal_client_receive_objects(
9221
+
client: *mut ECalClient,
9222
+
icalcomp: *mut ICalComponent,
9223
+
opflags: ECalOperationFlags,
9224
+
cancellable: *mut GCancellable,
9225
+
callback: GAsyncReadyCallback,
9226
+
user_data: gpointer,
9227
+
);
9228
+
}
9229
+
unsafe extern "C" {
9230
+
pub fn e_cal_client_receive_objects_finish(
9231
+
client: *mut ECalClient,
9232
+
result: *mut GAsyncResult,
9233
+
error: *mut *mut GError,
9234
+
) -> gboolean;
9235
+
}
9236
+
unsafe extern "C" {
9237
+
pub fn e_cal_client_receive_objects_sync(
9238
+
client: *mut ECalClient,
9239
+
icalcomp: *mut ICalComponent,
9240
+
opflags: ECalOperationFlags,
9241
+
cancellable: *mut GCancellable,
9242
+
error: *mut *mut GError,
9243
+
) -> gboolean;
9244
+
}
9245
+
unsafe extern "C" {
9246
+
pub fn e_cal_client_send_objects(
9247
+
client: *mut ECalClient,
9248
+
icalcomp: *mut ICalComponent,
9249
+
opflags: ECalOperationFlags,
9250
+
cancellable: *mut GCancellable,
9251
+
callback: GAsyncReadyCallback,
9252
+
user_data: gpointer,
9253
+
);
9254
+
}
9255
+
unsafe extern "C" {
9256
+
pub fn e_cal_client_send_objects_finish(
9257
+
client: *mut ECalClient,
9258
+
result: *mut GAsyncResult,
9259
+
out_users: *mut *mut GSList,
9260
+
out_modified_icalcomp: *mut *mut ICalComponent,
9261
+
error: *mut *mut GError,
9262
+
) -> gboolean;
9263
+
}
9264
+
unsafe extern "C" {
9265
+
pub fn e_cal_client_send_objects_sync(
9266
+
client: *mut ECalClient,
9267
+
icalcomp: *mut ICalComponent,
9268
+
opflags: ECalOperationFlags,
9269
+
out_users: *mut *mut GSList,
9270
+
out_modified_icalcomp: *mut *mut ICalComponent,
9271
+
cancellable: *mut GCancellable,
9272
+
error: *mut *mut GError,
9273
+
) -> gboolean;
9274
+
}
9275
+
unsafe extern "C" {
9276
+
pub fn e_cal_client_get_attachment_uris(
9277
+
client: *mut ECalClient,
9278
+
uid: *const gchar,
9279
+
rid: *const gchar,
9280
+
cancellable: *mut GCancellable,
9281
+
callback: GAsyncReadyCallback,
9282
+
user_data: gpointer,
9283
+
);
9284
+
}
9285
+
unsafe extern "C" {
9286
+
pub fn e_cal_client_get_attachment_uris_finish(
9287
+
client: *mut ECalClient,
9288
+
result: *mut GAsyncResult,
9289
+
out_attachment_uris: *mut *mut GSList,
9290
+
error: *mut *mut GError,
9291
+
) -> gboolean;
9292
+
}
9293
+
unsafe extern "C" {
9294
+
pub fn e_cal_client_get_attachment_uris_sync(
9295
+
client: *mut ECalClient,
9296
+
uid: *const gchar,
9297
+
rid: *const gchar,
9298
+
out_attachment_uris: *mut *mut GSList,
9299
+
cancellable: *mut GCancellable,
9300
+
error: *mut *mut GError,
9301
+
) -> gboolean;
9302
+
}
9303
+
unsafe extern "C" {
9304
+
pub fn e_cal_client_discard_alarm(
9305
+
client: *mut ECalClient,
9306
+
uid: *const gchar,
9307
+
rid: *const gchar,
9308
+
auid: *const gchar,
9309
+
opflags: ECalOperationFlags,
9310
+
cancellable: *mut GCancellable,
9311
+
callback: GAsyncReadyCallback,
9312
+
user_data: gpointer,
9313
+
);
9314
+
}
9315
+
unsafe extern "C" {
9316
+
pub fn e_cal_client_discard_alarm_finish(
9317
+
client: *mut ECalClient,
9318
+
result: *mut GAsyncResult,
9319
+
error: *mut *mut GError,
9320
+
) -> gboolean;
9321
+
}
9322
+
unsafe extern "C" {
9323
+
pub fn e_cal_client_discard_alarm_sync(
9324
+
client: *mut ECalClient,
9325
+
uid: *const gchar,
9326
+
rid: *const gchar,
9327
+
auid: *const gchar,
9328
+
opflags: ECalOperationFlags,
9329
+
cancellable: *mut GCancellable,
9330
+
error: *mut *mut GError,
9331
+
) -> gboolean;
9332
+
}
9333
+
unsafe extern "C" {
9334
+
pub fn e_cal_client_get_view(
9335
+
client: *mut ECalClient,
9336
+
sexp: *const gchar,
9337
+
cancellable: *mut GCancellable,
9338
+
callback: GAsyncReadyCallback,
9339
+
user_data: gpointer,
9340
+
);
9341
+
}
9342
+
unsafe extern "C" {
9343
+
pub fn e_cal_client_get_view_finish(
9344
+
client: *mut ECalClient,
9345
+
result: *mut GAsyncResult,
9346
+
out_view: *mut *mut ECalClientView,
9347
+
error: *mut *mut GError,
9348
+
) -> gboolean;
9349
+
}
9350
+
unsafe extern "C" {
9351
+
pub fn e_cal_client_get_view_sync(
9352
+
client: *mut ECalClient,
9353
+
sexp: *const gchar,
9354
+
out_view: *mut *mut ECalClientView,
9355
+
cancellable: *mut GCancellable,
9356
+
error: *mut *mut GError,
9357
+
) -> gboolean;
9358
+
}
9359
+
unsafe extern "C" {
9360
+
pub fn e_cal_client_get_timezone(
9361
+
client: *mut ECalClient,
9362
+
tzid: *const gchar,
9363
+
cancellable: *mut GCancellable,
9364
+
callback: GAsyncReadyCallback,
9365
+
user_data: gpointer,
9366
+
);
9367
+
}
9368
+
unsafe extern "C" {
9369
+
pub fn e_cal_client_get_timezone_finish(
9370
+
client: *mut ECalClient,
9371
+
result: *mut GAsyncResult,
9372
+
out_zone: *mut *mut ICalTimezone,
9373
+
error: *mut *mut GError,
9374
+
) -> gboolean;
9375
+
}
9376
+
unsafe extern "C" {
9377
+
pub fn e_cal_client_get_timezone_sync(
9378
+
client: *mut ECalClient,
9379
+
tzid: *const gchar,
9380
+
out_zone: *mut *mut ICalTimezone,
9381
+
cancellable: *mut GCancellable,
9382
+
error: *mut *mut GError,
9383
+
) -> gboolean;
9384
+
}
9385
+
unsafe extern "C" {
9386
+
pub fn e_cal_client_add_timezone(
9387
+
client: *mut ECalClient,
9388
+
zone: *mut ICalTimezone,
9389
+
cancellable: *mut GCancellable,
9390
+
callback: GAsyncReadyCallback,
9391
+
user_data: gpointer,
9392
+
);
9393
+
}
9394
+
unsafe extern "C" {
9395
+
pub fn e_cal_client_add_timezone_finish(
9396
+
client: *mut ECalClient,
9397
+
result: *mut GAsyncResult,
9398
+
error: *mut *mut GError,
9399
+
) -> gboolean;
9400
+
}
9401
+
unsafe extern "C" {
9402
+
pub fn e_cal_client_add_timezone_sync(
9403
+
client: *mut ECalClient,
9404
+
zone: *mut ICalTimezone,
9405
+
cancellable: *mut GCancellable,
9406
+
error: *mut *mut GError,
9407
+
) -> gboolean;
9408
+
}
9409
+
unsafe extern "C" {
9410
+
pub fn e_cal_client_source_type_get_type() -> GType;
9411
+
}
9412
+
unsafe extern "C" {
9413
+
pub fn isodate_from_time_t(t: time_t) -> *mut gchar;
9414
+
}
+9
crates/alarma-eds/src/bindings/mod.rs
+9
crates/alarma-eds/src/bindings/mod.rs
···
1
+
//! FFI bindings for Evolution Data Server
2
+
//!
3
+
//! This module contains the raw bindings for EDS C APIs.
4
+
//! Do not use these directly - use the safe wrappers in the ffi module instead.
5
+
//!
6
+
//! To regenerate these bindings, run: ./generate_bindings.sh
7
+
8
+
mod eds_bindings;
9
+
pub use eds_bindings::*;
+384
crates/alarma-eds/src/ffi/mod.rs
+384
crates/alarma-eds/src/ffi/mod.rs
···
1
+
//! Safe FFI wrappers over Evolution Data Server C APIs
2
+
//!
3
+
//! This module provides RAII types and safe abstractions over the raw bindings.
4
+
5
+
use crate::bindings;
6
+
use alarma_core::{AlarmaError, Result};
7
+
use std::ffi::{CStr, CString};
8
+
use std::ptr;
9
+
10
+
/// RAII wrapper for ESourceRegistry
11
+
pub struct SourceRegistry {
12
+
ptr: *mut bindings::ESourceRegistry,
13
+
}
14
+
15
+
impl SourceRegistry {
16
+
/// Creates a new source registry
17
+
pub fn new() -> Result<Self> {
18
+
unsafe {
19
+
let mut error: *mut bindings::GError = ptr::null_mut();
20
+
let registry = bindings::e_source_registry_new_sync(ptr::null_mut(), &mut error);
21
+
22
+
if !error.is_null() {
23
+
let err_msg = if !(*error).message.is_null() {
24
+
CStr::from_ptr((*error).message)
25
+
.to_string_lossy()
26
+
.into_owned()
27
+
} else {
28
+
"Unknown error".to_string()
29
+
};
30
+
glib::ffi::g_error_free(error);
31
+
return Err(AlarmaError::InitializationFailed(err_msg));
32
+
}
33
+
34
+
if registry.is_null() {
35
+
return Err(AlarmaError::InitializationFailed(
36
+
"Failed to create source registry".to_string(),
37
+
));
38
+
}
39
+
40
+
Ok(SourceRegistry { ptr: registry })
41
+
}
42
+
}
43
+
44
+
/// Lists all calendar sources
45
+
pub fn list_calendar_sources(&self) -> Result<Vec<Source>> {
46
+
unsafe {
47
+
let extension_name = CString::new("Calendar").unwrap();
48
+
let sources_list =
49
+
bindings::e_source_registry_list_sources(self.ptr, extension_name.as_ptr());
50
+
51
+
if sources_list.is_null() {
52
+
return Ok(Vec::new());
53
+
}
54
+
55
+
let mut sources = Vec::new();
56
+
let mut current = sources_list;
57
+
58
+
while !current.is_null() {
59
+
let source_ptr = (*current).data as *mut bindings::ESource;
60
+
if !source_ptr.is_null() {
61
+
// Increment reference count since we're keeping it
62
+
glib::gobject_ffi::g_object_ref(source_ptr as *mut _);
63
+
sources.push(Source { ptr: source_ptr });
64
+
}
65
+
current = (*current).next;
66
+
}
67
+
68
+
// Free the list (but not the objects, as we ref'd them)
69
+
glib::ffi::g_list_free(sources_list);
70
+
71
+
Ok(sources)
72
+
}
73
+
}
74
+
75
+
pub fn as_ptr(&self) -> *mut bindings::ESourceRegistry {
76
+
self.ptr
77
+
}
78
+
}
79
+
80
+
impl Drop for SourceRegistry {
81
+
fn drop(&mut self) {
82
+
unsafe {
83
+
if !self.ptr.is_null() {
84
+
glib::gobject_ffi::g_object_unref(self.ptr as *mut _);
85
+
}
86
+
}
87
+
}
88
+
}
89
+
90
+
unsafe impl Send for SourceRegistry {}
91
+
unsafe impl Sync for SourceRegistry {}
92
+
93
+
/// RAII wrapper for ESource
94
+
pub struct Source {
95
+
ptr: *mut bindings::ESource,
96
+
}
97
+
98
+
impl Source {
99
+
/// Gets the display name of the source
100
+
pub fn display_name(&self) -> String {
101
+
unsafe {
102
+
let name_ptr = bindings::e_source_get_display_name(self.ptr);
103
+
if name_ptr.is_null() {
104
+
String::new()
105
+
} else {
106
+
CStr::from_ptr(name_ptr).to_string_lossy().into_owned()
107
+
}
108
+
}
109
+
}
110
+
111
+
/// Gets the UID of the source
112
+
pub fn uid(&self) -> String {
113
+
unsafe {
114
+
let uid_ptr = bindings::e_source_get_uid(self.ptr);
115
+
if uid_ptr.is_null() {
116
+
String::new()
117
+
} else {
118
+
CStr::from_ptr(uid_ptr).to_string_lossy().into_owned()
119
+
}
120
+
}
121
+
}
122
+
123
+
pub fn as_ptr(&self) -> *mut bindings::ESource {
124
+
self.ptr
125
+
}
126
+
}
127
+
128
+
impl Drop for Source {
129
+
fn drop(&mut self) {
130
+
unsafe {
131
+
if !self.ptr.is_null() {
132
+
glib::gobject_ffi::g_object_unref(self.ptr as *mut _);
133
+
}
134
+
}
135
+
}
136
+
}
137
+
138
+
unsafe impl Send for Source {}
139
+
unsafe impl Sync for Source {}
140
+
141
+
/// RAII wrapper for ECalClient
142
+
pub struct CalClient {
143
+
ptr: *mut bindings::EClient, // e_cal_client_connect_sync returns EClient
144
+
}
145
+
146
+
impl CalClient {
147
+
/// Connects to a calendar source
148
+
pub fn connect(source: &Source) -> Result<Self> {
149
+
unsafe {
150
+
let mut error: *mut bindings::GError = ptr::null_mut();
151
+
let client = bindings::e_cal_client_connect_sync(
152
+
source.as_ptr(),
153
+
bindings::ECalClientSourceType_E_CAL_CLIENT_SOURCE_TYPE_EVENTS,
154
+
30, // wait_for_connected_seconds
155
+
ptr::null_mut(),
156
+
&mut error,
157
+
);
158
+
159
+
if !error.is_null() {
160
+
let err_msg = if !(*error).message.is_null() {
161
+
CStr::from_ptr((*error).message)
162
+
.to_string_lossy()
163
+
.into_owned()
164
+
} else {
165
+
"Unknown error".to_string()
166
+
};
167
+
glib::ffi::g_error_free(error);
168
+
return Err(AlarmaError::ConnectionFailed(format!(
169
+
"Failed to connect to '{}': {}",
170
+
source.display_name(),
171
+
err_msg
172
+
)));
173
+
}
174
+
175
+
if client.is_null() {
176
+
return Err(AlarmaError::ConnectionFailed(format!(
177
+
"Failed to connect to '{}': Client pointer is null",
178
+
source.display_name()
179
+
)));
180
+
}
181
+
182
+
Ok(CalClient { ptr: client })
183
+
}
184
+
}
185
+
186
+
/// Lists events within a time range
187
+
pub fn list_events(&self, start_time: i64, end_time: i64) -> Result<Vec<ICalComponent>> {
188
+
unsafe {
189
+
// Create ISO date strings
190
+
let iso_start = bindings::isodate_from_time_t(start_time);
191
+
let iso_end = bindings::isodate_from_time_t(end_time);
192
+
193
+
if iso_start.is_null() || iso_end.is_null() {
194
+
return Err(AlarmaError::QueryFailed(
195
+
"Failed to convert timestamps to ISO dates".to_string(),
196
+
));
197
+
}
198
+
199
+
// Build S-expression query
200
+
let query_fmt =
201
+
CString::new("(occur-in-time-range? (make-time \"%s\") (make-time \"%s\"))")
202
+
.unwrap();
203
+
let query = glib::ffi::g_strdup_printf(query_fmt.as_ptr(), iso_start, iso_end);
204
+
205
+
let mut ical_components: *mut bindings::GSList = ptr::null_mut();
206
+
let mut error: *mut bindings::GError = ptr::null_mut();
207
+
208
+
let success = bindings::e_cal_client_get_object_list_sync(
209
+
self.ptr as *mut bindings::ECalClient, // Cast EClient to ECalClient
210
+
query,
211
+
&mut ical_components,
212
+
ptr::null_mut(),
213
+
&mut error,
214
+
);
215
+
216
+
// Clean up query strings
217
+
glib::ffi::g_free(query as *mut _);
218
+
glib::ffi::g_free(iso_start as *mut _);
219
+
glib::ffi::g_free(iso_end as *mut _);
220
+
221
+
if !error.is_null() {
222
+
let err_msg = if !(*error).message.is_null() {
223
+
CStr::from_ptr((*error).message)
224
+
.to_string_lossy()
225
+
.into_owned()
226
+
} else {
227
+
"Unknown error".to_string()
228
+
};
229
+
glib::ffi::g_error_free(error);
230
+
return Err(AlarmaError::QueryFailed(err_msg));
231
+
}
232
+
233
+
let mut components = Vec::new();
234
+
235
+
if success != 0 && !ical_components.is_null() {
236
+
let mut current = ical_components;
237
+
while !current.is_null() {
238
+
let icalcomp = (*current).data as *mut bindings::ICalComponent;
239
+
if !icalcomp.is_null() {
240
+
// Ref the component before taking ownership
241
+
glib::gobject_ffi::g_object_ref(icalcomp as *mut _);
242
+
components.push(ICalComponent { ptr: icalcomp });
243
+
}
244
+
current = (*current).next;
245
+
}
246
+
247
+
// Free the list (components are ref'd separately)
248
+
// Cast g_object_unref to the function pointer type expected by g_slist_free_full
249
+
glib::ffi::g_slist_free_full(
250
+
ical_components,
251
+
Some(std::mem::transmute::<
252
+
unsafe extern "C" fn(*mut glib::gobject_ffi::GObject),
253
+
unsafe extern "C" fn(*mut libc::c_void),
254
+
>(glib::gobject_ffi::g_object_unref as _))
255
+
);
256
+
}
257
+
258
+
Ok(components)
259
+
}
260
+
}
261
+
}
262
+
263
+
impl Drop for CalClient {
264
+
fn drop(&mut self) {
265
+
unsafe {
266
+
if !self.ptr.is_null() {
267
+
glib::gobject_ffi::g_object_unref(self.ptr as *mut _);
268
+
}
269
+
}
270
+
}
271
+
}
272
+
273
+
unsafe impl Send for CalClient {}
274
+
unsafe impl Sync for CalClient {}
275
+
276
+
/// RAII wrapper for ICalComponent
277
+
pub struct ICalComponent {
278
+
ptr: *mut bindings::ICalComponent,
279
+
}
280
+
281
+
impl ICalComponent {
282
+
pub fn summary(&self) -> Option<String> {
283
+
unsafe {
284
+
let ptr = bindings::i_cal_component_get_summary(self.ptr);
285
+
if ptr.is_null() {
286
+
None
287
+
} else {
288
+
Some(CStr::from_ptr(ptr).to_string_lossy().into_owned())
289
+
}
290
+
}
291
+
}
292
+
293
+
pub fn description(&self) -> Option<String> {
294
+
unsafe {
295
+
let ptr = bindings::i_cal_component_get_description(self.ptr);
296
+
if ptr.is_null() {
297
+
None
298
+
} else {
299
+
let desc = CStr::from_ptr(ptr).to_string_lossy().into_owned();
300
+
if desc.is_empty() {
301
+
None
302
+
} else {
303
+
Some(desc)
304
+
}
305
+
}
306
+
}
307
+
}
308
+
309
+
pub fn location(&self) -> Option<String> {
310
+
unsafe {
311
+
let ptr = bindings::i_cal_component_get_location(self.ptr);
312
+
if ptr.is_null() {
313
+
None
314
+
} else {
315
+
let loc = CStr::from_ptr(ptr).to_string_lossy().into_owned();
316
+
if loc.is_empty() {
317
+
None
318
+
} else {
319
+
Some(loc)
320
+
}
321
+
}
322
+
}
323
+
}
324
+
325
+
pub fn uid(&self) -> String {
326
+
unsafe {
327
+
let ptr = bindings::i_cal_component_get_uid(self.ptr);
328
+
if ptr.is_null() {
329
+
String::new()
330
+
} else {
331
+
CStr::from_ptr(ptr).to_string_lossy().into_owned()
332
+
}
333
+
}
334
+
}
335
+
336
+
pub fn dtstart(&self) -> ICalTime {
337
+
unsafe {
338
+
let ptr = bindings::i_cal_component_get_dtstart(self.ptr);
339
+
ICalTime { ptr }
340
+
}
341
+
}
342
+
343
+
pub fn dtend(&self) -> ICalTime {
344
+
unsafe {
345
+
let ptr = bindings::i_cal_component_get_dtend(self.ptr);
346
+
ICalTime { ptr }
347
+
}
348
+
}
349
+
}
350
+
351
+
impl Drop for ICalComponent {
352
+
fn drop(&mut self) {
353
+
unsafe {
354
+
if !self.ptr.is_null() {
355
+
glib::gobject_ffi::g_object_unref(self.ptr as *mut _);
356
+
}
357
+
}
358
+
}
359
+
}
360
+
361
+
/// RAII wrapper for ICalTime
362
+
pub struct ICalTime {
363
+
ptr: *mut bindings::ICalTime,
364
+
}
365
+
366
+
impl ICalTime {
367
+
pub fn is_date(&self) -> bool {
368
+
unsafe { bindings::i_cal_time_is_date(self.ptr) != 0 }
369
+
}
370
+
371
+
pub fn as_timet(&self) -> i64 {
372
+
unsafe { bindings::i_cal_time_as_timet(self.ptr) }
373
+
}
374
+
}
375
+
376
+
impl Drop for ICalTime {
377
+
fn drop(&mut self) {
378
+
unsafe {
379
+
if !self.ptr.is_null() {
380
+
glib::gobject_ffi::g_object_unref(self.ptr as *mut _);
381
+
}
382
+
}
383
+
}
384
+
}
+31
crates/alarma-eds/src/lib.rs
+31
crates/alarma-eds/src/lib.rs
···
1
+
//! Alarma EDS (Evolution Data Server) Implementation
2
+
//!
3
+
//! This crate provides an implementation of the `CalendarRepository` trait
4
+
//! using Evolution Data Server as the backend.
5
+
//!
6
+
//! # Example
7
+
//!
8
+
//! ```rust,no_run
9
+
//! use alarma_core::{CalendarService, repository::DateRange};
10
+
//! use alarma_eds::EdsRepository;
11
+
//!
12
+
//! fn main() -> alarma_core::Result<()> {
13
+
//! // Create EDS repository
14
+
//! let repository = EdsRepository::new()?;
15
+
//!
16
+
//! // Create service with the repository
17
+
//! let service = CalendarService::new(Box::new(repository));
18
+
//!
19
+
//! // Use the service
20
+
//! let sources = service.list_sources()?;
21
+
//! println!("Found {} calendar sources", sources.len());
22
+
//!
23
+
//! Ok(())
24
+
//! }
25
+
//! ```
26
+
27
+
mod bindings;
28
+
mod ffi;
29
+
pub mod repository;
30
+
31
+
pub use repository::EdsRepository;
+127
crates/alarma-eds/src/repository.rs
+127
crates/alarma-eds/src/repository.rs
···
1
+
//! Evolution Data Server repository implementation
2
+
//!
3
+
//! This module implements the CalendarRepository trait using EDS as the backend.
4
+
5
+
use alarma_core::{
6
+
domain::{CalendarEvent, CalendarSource, EventTime},
7
+
repository::{CalendarRepository, DateRange},
8
+
AlarmaError, Result,
9
+
};
10
+
use chrono::{Local, TimeZone};
11
+
12
+
use crate::ffi::{CalClient, SourceRegistry};
13
+
14
+
/// Repository implementation using Evolution Data Server
15
+
pub struct EdsRepository {
16
+
registry: SourceRegistry,
17
+
}
18
+
19
+
impl EdsRepository {
20
+
/// Creates a new EDS repository
21
+
pub fn new() -> Result<Self> {
22
+
let registry = SourceRegistry::new()?;
23
+
Ok(Self { registry })
24
+
}
25
+
26
+
/// Converts an ICalComponent to a CalendarEvent
27
+
fn ical_to_event(
28
+
component: &crate::ffi::ICalComponent,
29
+
source_uid: String,
30
+
) -> Option<CalendarEvent> {
31
+
let summary = component
32
+
.summary()
33
+
.unwrap_or_else(|| "(No title)".to_string());
34
+
let description = component.description();
35
+
let location = component.location();
36
+
let uid = component.uid();
37
+
38
+
let start_time = component.dtstart();
39
+
let end_time = component.dtend();
40
+
41
+
let is_all_day = start_time.is_date();
42
+
43
+
let (start_event_time, end_event_time) = if is_all_day {
44
+
// All-day event - use date only
45
+
let start_timestamp = start_time.as_timet();
46
+
let end_timestamp = end_time.as_timet();
47
+
48
+
let start_dt = Local.timestamp_opt(start_timestamp, 0).single()?;
49
+
let end_dt = Local.timestamp_opt(end_timestamp, 0).single()?;
50
+
51
+
(
52
+
EventTime::Date(start_dt.date_naive()),
53
+
EventTime::Date(end_dt.date_naive()),
54
+
)
55
+
} else {
56
+
// Timed event - use full datetime
57
+
let start_timestamp = start_time.as_timet();
58
+
let end_timestamp = end_time.as_timet();
59
+
60
+
(
61
+
EventTime::DateTime(Local.timestamp_opt(start_timestamp, 0).single()?),
62
+
EventTime::DateTime(Local.timestamp_opt(end_timestamp, 0).single()?),
63
+
)
64
+
};
65
+
66
+
Some(
67
+
CalendarEvent::new(uid, summary, start_event_time, end_event_time, source_uid)
68
+
.with_description(description)
69
+
.with_location(location),
70
+
)
71
+
}
72
+
}
73
+
74
+
impl CalendarRepository for EdsRepository {
75
+
fn list_sources(&self) -> Result<Vec<CalendarSource>> {
76
+
let eds_sources = self.registry.list_calendar_sources()?;
77
+
78
+
Ok(eds_sources
79
+
.iter()
80
+
.map(|source| CalendarSource::new(source.uid(), source.display_name()))
81
+
.collect())
82
+
}
83
+
84
+
fn list_events(&self, source_uid: &str, range: DateRange) -> Result<Vec<CalendarEvent>> {
85
+
// First, find the source
86
+
let eds_sources = self.registry.list_calendar_sources()?;
87
+
let source = eds_sources
88
+
.iter()
89
+
.find(|s| s.uid() == source_uid)
90
+
.ok_or_else(|| AlarmaError::SourceNotFound(source_uid.to_string()))?;
91
+
92
+
// Connect to the calendar
93
+
let client = CalClient::connect(source)?;
94
+
95
+
// Query events
96
+
let components = client.list_events(range.start_timestamp(), range.end_timestamp())?;
97
+
98
+
// Convert to domain events
99
+
Ok(components
100
+
.iter()
101
+
.filter_map(|comp| Self::ical_to_event(comp, source_uid.to_string()))
102
+
.collect())
103
+
}
104
+
}
105
+
106
+
#[cfg(test)]
107
+
mod tests {
108
+
use super::*;
109
+
110
+
#[test]
111
+
#[ignore] // Requires EDS to be available
112
+
fn test_create_repository() {
113
+
let result = EdsRepository::new();
114
+
assert!(result.is_ok());
115
+
}
116
+
117
+
#[test]
118
+
#[ignore] // Requires EDS to be available
119
+
fn test_list_sources() {
120
+
let repo = EdsRepository::new().unwrap();
121
+
let sources = repo.list_sources().unwrap();
122
+
println!("Found {} calendar sources", sources.len());
123
+
for source in sources {
124
+
println!(" - {} ({})", source.display_name, source.uid);
125
+
}
126
+
}
127
+
}
-9
crates/eds-cal-cli/Cargo.toml
-9
crates/eds-cal-cli/Cargo.toml
-250
crates/eds-cal-cli/src/main.rs
-250
crates/eds-cal-cli/src/main.rs
···
1
-
use chrono::{Local, NaiveDate};
2
-
use clap::{Args, Parser, Subcommand};
3
-
use eds_cal_rs::{CalendarClient, EventTime, GLibVersion, SourceRegistry};
4
-
5
-
#[derive(Parser)]
6
-
#[command(name = "eds-cli")]
7
-
#[command(about = "Evolution Data Server Calendar CLI tool", long_about = None)]
8
-
#[command(version)]
9
-
struct Cli {
10
-
#[command(subcommand)]
11
-
command: Commands,
12
-
}
13
-
14
-
#[derive(Subcommand)]
15
-
enum Commands {
16
-
/// Show library version information
17
-
Version,
18
-
/// Calendar sources operations
19
-
Sources {
20
-
#[command(subcommand)]
21
-
action: SourcesCommands,
22
-
},
23
-
/// Calendar events operations
24
-
Events {
25
-
#[command(subcommand)]
26
-
action: EventsCommands,
27
-
},
28
-
}
29
-
30
-
#[derive(Subcommand)]
31
-
enum SourcesCommands {
32
-
/// List available calendar sources
33
-
List,
34
-
}
35
-
36
-
#[derive(Subcommand)]
37
-
enum EventsCommands {
38
-
/// List events from now to 60 days ahead
39
-
List(ListEventsArgs),
40
-
}
41
-
42
-
#[derive(Args)]
43
-
struct ListEventsArgs {
44
-
/// Filter events by source UID
45
-
#[arg(long)]
46
-
source: Option<String>,
47
-
48
-
/// Start date (YYYY-MM-DD format). Defaults to now
49
-
#[arg(long)]
50
-
date_from: Option<String>,
51
-
52
-
/// End date (YYYY-MM-DD format). Defaults to 60 days from now
53
-
#[arg(long)]
54
-
date_until: Option<String>,
55
-
}
56
-
57
-
fn parse_date(date_str: &str) -> Result<i64, String> {
58
-
let date = NaiveDate::parse_from_str(date_str, "%Y-%m-%d")
59
-
.map_err(|e| format!("Invalid date format (expected YYYY-MM-DD): {}", e))?;
60
-
61
-
// Convert to Unix timestamp at midnight in local timezone
62
-
let datetime = date.and_hms_opt(0, 0, 0).unwrap();
63
-
Ok(datetime.and_local_timezone(Local).unwrap().timestamp())
64
-
}
65
-
66
-
fn print_version() {
67
-
let version = GLibVersion::get();
68
-
println!("Evolution Data Server Calendar");
69
-
println!("Library version info:");
70
-
println!(
71
-
" GLib version: {}.{}.{}",
72
-
version.major, version.minor, version.micro
73
-
);
74
-
}
75
-
76
-
fn list_sources() -> i32 {
77
-
let registry = match SourceRegistry::new() {
78
-
Ok(reg) => reg,
79
-
Err(e) => {
80
-
eprintln!("Failed to create source registry: {}", e);
81
-
return 1;
82
-
}
83
-
};
84
-
85
-
println!("Successfully connected to Evolution Data Server");
86
-
87
-
let sources = match registry.list_sources() {
88
-
Ok(srcs) => srcs,
89
-
Err(e) => {
90
-
eprintln!("Failed to list sources: {}", e);
91
-
return 1;
92
-
}
93
-
};
94
-
95
-
println!("Found {} calendar source(s)", sources.len());
96
-
97
-
for source in sources {
98
-
println!(" - {} (UID: {})", source.display_name(), source.uid());
99
-
}
100
-
101
-
0
102
-
}
103
-
104
-
fn list_events(args: &ListEventsArgs) -> i32 {
105
-
let registry = match SourceRegistry::new() {
106
-
Ok(reg) => reg,
107
-
Err(e) => {
108
-
eprintln!("Failed to create source registry: {}", e);
109
-
return 1;
110
-
}
111
-
};
112
-
113
-
// Parse date_from or default to now
114
-
let start_time = if let Some(date_str) = &args.date_from {
115
-
match parse_date(date_str) {
116
-
Ok(ts) => ts,
117
-
Err(e) => {
118
-
eprintln!("Invalid date-from format: {}", e);
119
-
return 1;
120
-
}
121
-
}
122
-
} else {
123
-
std::time::SystemTime::now()
124
-
.duration_since(std::time::UNIX_EPOCH)
125
-
.expect("System time is before Unix epoch")
126
-
.as_secs() as i64
127
-
};
128
-
129
-
// Parse date_until or default to 60 days from start
130
-
let end_time = if let Some(date_str) = &args.date_until {
131
-
match parse_date(date_str) {
132
-
Ok(ts) => ts,
133
-
Err(e) => {
134
-
eprintln!("Invalid date-until format: {}", e);
135
-
return 1;
136
-
}
137
-
}
138
-
} else {
139
-
start_time + (60 * 24 * 60 * 60)
140
-
};
141
-
142
-
let sources = match registry.list_sources() {
143
-
Ok(srcs) => srcs,
144
-
Err(e) => {
145
-
eprintln!("Failed to list sources: {}", e);
146
-
return 1;
147
-
}
148
-
};
149
-
150
-
// Filter sources if --source is specified
151
-
let sources: Vec<_> = if let Some(filter_uid) = &args.source {
152
-
sources
153
-
.into_iter()
154
-
.filter(|s| s.uid() == filter_uid)
155
-
.collect()
156
-
} else {
157
-
sources
158
-
};
159
-
160
-
if sources.is_empty() {
161
-
if args.source.is_some() {
162
-
eprintln!(
163
-
"No source found with UID: {}",
164
-
args.source.as_ref().unwrap()
165
-
);
166
-
} else {
167
-
eprintln!("No calendar sources found");
168
-
}
169
-
return 1;
170
-
}
171
-
172
-
let mut total_events = 0;
173
-
174
-
for source in sources {
175
-
let display_name = source.display_name();
176
-
177
-
let client = match CalendarClient::connect(&source) {
178
-
Ok(client) => client,
179
-
Err(e) => {
180
-
eprintln!("Failed to connect to calendar '{}': {}", display_name, e);
181
-
continue;
182
-
}
183
-
};
184
-
185
-
let events = match client.list_events(start_time, end_time) {
186
-
Ok(evts) => evts,
187
-
Err(e) => {
188
-
eprintln!("Failed to query events from '{}': {}", display_name, e);
189
-
continue;
190
-
}
191
-
};
192
-
193
-
for event in events {
194
-
let (start_str, end_str) = match (&event.start, &event.end) {
195
-
(EventTime::Date(start_date), EventTime::Date(end_date)) => {
196
-
// All-day event
197
-
let start = start_date.format("%Y-%m-%d").to_string();
198
-
let end = if start_date == end_date {
199
-
"(all day)".to_string()
200
-
} else {
201
-
format!("to {}", end_date.format("%Y-%m-%d"))
202
-
};
203
-
(start, end)
204
-
}
205
-
(EventTime::DateTime(start_dt), EventTime::DateTime(end_dt)) => {
206
-
// Timed event
207
-
let start = start_dt.format("%Y-%m-%d %H:%M").to_string();
208
-
let end = end_dt.format("%H:%M").to_string();
209
-
(start, end)
210
-
}
211
-
_ => {
212
-
// Mixed types - shouldn't happen but handle gracefully
213
-
(
214
-
event.start.format("%Y-%m-%d %H:%M"),
215
-
event.end.format("%H:%M"),
216
-
)
217
-
}
218
-
};
219
-
220
-
println!(
221
-
"[{}] {} | {} - {}",
222
-
display_name, event.summary, start_str, end_str
223
-
);
224
-
total_events += 1;
225
-
}
226
-
}
227
-
228
-
println!("\nTotal events: {}", total_events);
229
-
230
-
0
231
-
}
232
-
233
-
fn main() {
234
-
let cli = Cli::parse();
235
-
236
-
let exit_code = match cli.command {
237
-
Commands::Version => {
238
-
print_version();
239
-
0
240
-
}
241
-
Commands::Sources { action } => match action {
242
-
SourcesCommands::List => list_sources(),
243
-
},
244
-
Commands::Events { action } => match action {
245
-
EventsCommands::List(args) => list_events(&args),
246
-
},
247
-
};
248
-
249
-
std::process::exit(exit_code);
250
-
}
-13
crates/eds-cal-rs/Cargo.toml
-13
crates/eds-cal-rs/Cargo.toml
-8
crates/eds-cal-rs/build.rs
-8
crates/eds-cal-rs/build.rs
-11
crates/eds-cal-rs/src/constants.rs
-11
crates/eds-cal-rs/src/constants.rs
···
1
-
// Constants from Evolution Data Server C headers
2
-
//
3
-
// To regenerate, run:
4
-
// bindgen /usr/include/evolution-data-server/libedataserver/libedataserver.h \
5
-
// --allowlist-var E_SOURCE_EXTENSION_CALENDAR --no-layout-tests \
6
-
// -- $(pkg-config --cflags libedataserver-1.2) \
7
-
// > src/constants.rs
8
-
9
-
/* automatically generated by rust-bindgen 0.72.1 */
10
-
11
-
pub const E_SOURCE_EXTENSION_CALENDAR: &[u8; 9] = b"Calendar\0";
-243
crates/eds-cal-rs/src/core.rs
-243
crates/eds-cal-rs/src/core.rs
···
1
-
// Safe Rust abstractions over Evolution Data Server C APIs
2
-
3
-
use crate::event::Event;
4
-
use crate::ffi;
5
-
use std::ffi::{CStr, CString};
6
-
use std::fmt;
7
-
use std::os::raw::c_char;
8
-
use std::ptr;
9
-
10
-
// Error handling
11
-
#[derive(Debug)]
12
-
pub struct EdsError {
13
-
message: String,
14
-
}
15
-
16
-
impl fmt::Display for EdsError {
17
-
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
18
-
write!(f, "{}", self.message)
19
-
}
20
-
}
21
-
22
-
impl std::error::Error for EdsError {}
23
-
24
-
impl EdsError {
25
-
fn from_gerror(error: *mut ffi::GError) -> Self {
26
-
unsafe {
27
-
let message = if !error.is_null() && !(*error).message.is_null() {
28
-
CStr::from_ptr((*error).message)
29
-
.to_string_lossy()
30
-
.into_owned()
31
-
} else {
32
-
"Unknown error".to_string()
33
-
};
34
-
ffi::g_error_free(error);
35
-
EdsError { message }
36
-
}
37
-
}
38
-
}
39
-
40
-
pub type Result<T> = std::result::Result<T, EdsError>;
41
-
42
-
// GLib version info
43
-
pub struct GLibVersion {
44
-
pub major: u32,
45
-
pub minor: u32,
46
-
pub micro: u32,
47
-
}
48
-
49
-
impl GLibVersion {
50
-
pub fn get() -> Self {
51
-
unsafe {
52
-
GLibVersion {
53
-
major: ffi::glib_major_version,
54
-
minor: ffi::glib_minor_version,
55
-
micro: ffi::glib_micro_version,
56
-
}
57
-
}
58
-
}
59
-
}
60
-
61
-
// Source Registry
62
-
pub struct SourceRegistry {
63
-
ptr: *mut ffi::ESourceRegistry,
64
-
}
65
-
66
-
impl SourceRegistry {
67
-
pub fn new() -> Result<Self> {
68
-
unsafe {
69
-
let mut error: *mut ffi::GError = ptr::null_mut();
70
-
let registry = ffi::e_source_registry_new_sync(ptr::null_mut(), &mut error);
71
-
72
-
if !error.is_null() {
73
-
return Err(EdsError::from_gerror(error));
74
-
}
75
-
76
-
if registry.is_null() {
77
-
return Err(EdsError {
78
-
message: "Failed to create source registry".to_string(),
79
-
});
80
-
}
81
-
82
-
Ok(SourceRegistry { ptr: registry })
83
-
}
84
-
}
85
-
86
-
pub fn list_sources(&self) -> Result<Vec<Source>> {
87
-
unsafe {
88
-
let sources_list = ffi::e_source_registry_list_sources(
89
-
self.ptr,
90
-
ffi::E_SOURCE_EXTENSION_CALENDAR.as_ptr() as *const c_char,
91
-
);
92
-
93
-
let mut sources = Vec::new();
94
-
let mut current = sources_list;
95
-
96
-
while !current.is_null() {
97
-
let source_ptr = (*current).data as *mut ffi::ESource;
98
-
sources.push(Source {
99
-
ptr: source_ptr,
100
-
_owned: false,
101
-
});
102
-
current = (*current).next;
103
-
}
104
-
105
-
ffi::g_list_free_full(sources_list, Some(ffi::glib_object_unref_wrapper));
106
-
107
-
Ok(sources)
108
-
}
109
-
}
110
-
}
111
-
112
-
impl Drop for SourceRegistry {
113
-
fn drop(&mut self) {
114
-
unsafe {
115
-
ffi::g_object_unref(self.ptr as *mut std::os::raw::c_void);
116
-
}
117
-
}
118
-
}
119
-
120
-
// Source
121
-
pub struct Source {
122
-
ptr: *mut ffi::ESource,
123
-
_owned: bool,
124
-
}
125
-
126
-
impl Source {
127
-
pub fn display_name(&self) -> &str {
128
-
unsafe {
129
-
let name_ptr = ffi::e_source_get_display_name(self.ptr);
130
-
if name_ptr.is_null() {
131
-
""
132
-
} else {
133
-
CStr::from_ptr(name_ptr).to_str().unwrap_or("")
134
-
}
135
-
}
136
-
}
137
-
138
-
pub fn uid(&self) -> &str {
139
-
unsafe {
140
-
let uid_ptr = ffi::e_source_get_uid(self.ptr);
141
-
if uid_ptr.is_null() {
142
-
""
143
-
} else {
144
-
CStr::from_ptr(uid_ptr).to_str().unwrap_or("")
145
-
}
146
-
}
147
-
}
148
-
149
-
pub(crate) fn as_ptr(&self) -> *mut ffi::ESource {
150
-
self.ptr
151
-
}
152
-
}
153
-
154
-
// Calendar Client
155
-
pub struct CalendarClient {
156
-
client_ptr: *mut ffi::EClient,
157
-
}
158
-
159
-
impl CalendarClient {
160
-
pub fn connect(source: &Source) -> Result<Self> {
161
-
unsafe {
162
-
let mut error: *mut ffi::GError = ptr::null_mut();
163
-
let client = ffi::e_cal_client_connect_sync(
164
-
source.as_ptr(),
165
-
ffi::ECalClientSourceType::Events,
166
-
30,
167
-
ptr::null_mut(),
168
-
&mut error,
169
-
);
170
-
171
-
if !error.is_null() {
172
-
return Err(EdsError::from_gerror(error));
173
-
}
174
-
175
-
if client.is_null() {
176
-
return Err(EdsError {
177
-
message: "Failed to connect to calendar".to_string(),
178
-
});
179
-
}
180
-
181
-
Ok(CalendarClient { client_ptr: client })
182
-
}
183
-
}
184
-
185
-
pub fn list_events(&self, start_time: i64, end_time: i64) -> Result<Vec<Event>> {
186
-
unsafe {
187
-
let iso_start = ffi::isodate_from_time_t(start_time);
188
-
let iso_end = ffi::isodate_from_time_t(end_time);
189
-
let query_fmt =
190
-
CString::new("(occur-in-time-range? (make-time \"%s\") (make-time \"%s\"))")
191
-
.unwrap();
192
-
let query = ffi::g_strdup_printf(query_fmt.as_ptr(), iso_start, iso_end);
193
-
194
-
let mut ical_components: *mut ffi::GSList = ptr::null_mut();
195
-
let mut error: *mut ffi::GError = ptr::null_mut();
196
-
197
-
let success = ffi::e_cal_client_get_object_list_sync(
198
-
self.client_ptr as *mut ffi::ECalClient,
199
-
query,
200
-
&mut ical_components,
201
-
ptr::null_mut(),
202
-
&mut error,
203
-
);
204
-
205
-
ffi::g_free(query as *mut std::os::raw::c_void);
206
-
ffi::g_free(iso_start as *mut std::os::raw::c_void);
207
-
ffi::g_free(iso_end as *mut std::os::raw::c_void);
208
-
209
-
if !error.is_null() {
210
-
return Err(EdsError::from_gerror(error));
211
-
}
212
-
213
-
let mut events = Vec::new();
214
-
215
-
if success != 0 && !ical_components.is_null() {
216
-
let mut current = ical_components;
217
-
while !current.is_null() {
218
-
let icalcomp = (*current).data as *mut ffi::ICalComponent;
219
-
220
-
if !icalcomp.is_null() {
221
-
if let Some(event) = Event::from_ical_component(icalcomp) {
222
-
events.push(event);
223
-
}
224
-
}
225
-
226
-
current = (*current).next;
227
-
}
228
-
229
-
ffi::g_slist_free_full(ical_components, Some(ffi::glib_object_unref_wrapper));
230
-
}
231
-
232
-
Ok(events)
233
-
}
234
-
}
235
-
}
236
-
237
-
impl Drop for CalendarClient {
238
-
fn drop(&mut self) {
239
-
unsafe {
240
-
ffi::g_object_unref(self.client_ptr as *mut std::os::raw::c_void);
241
-
}
242
-
}
243
-
}
-113
crates/eds-cal-rs/src/event.rs
-113
crates/eds-cal-rs/src/event.rs
···
1
-
// Event types and implementations
2
-
3
-
use crate::ffi;
4
-
use chrono::{DateTime, Local, NaiveDate, TimeZone};
5
-
use std::ffi::CStr;
6
-
7
-
// Event time representation
8
-
#[derive(Debug, Clone)]
9
-
pub enum EventTime {
10
-
DateTime(DateTime<Local>),
11
-
Date(NaiveDate),
12
-
}
13
-
14
-
impl EventTime {
15
-
pub fn format(&self, fmt: &str) -> String {
16
-
match self {
17
-
EventTime::DateTime(dt) => dt.format(fmt).to_string(),
18
-
EventTime::Date(date) => date.format(fmt).to_string(),
19
-
}
20
-
}
21
-
}
22
-
23
-
// Event
24
-
pub struct Event {
25
-
pub summary: String,
26
-
pub description: Option<String>,
27
-
pub location: Option<String>,
28
-
pub start: EventTime,
29
-
pub end: EventTime,
30
-
pub uid: String,
31
-
}
32
-
33
-
impl Event {
34
-
pub(crate) fn from_ical_component(comp: *mut ffi::ICalComponent) -> Option<Self> {
35
-
unsafe {
36
-
let summary_ptr = ffi::i_cal_component_get_summary(comp);
37
-
let summary = if !summary_ptr.is_null() {
38
-
CStr::from_ptr(summary_ptr).to_string_lossy().into_owned()
39
-
} else {
40
-
"(No title)".to_string()
41
-
};
42
-
43
-
let description_ptr = ffi::i_cal_component_get_description(comp);
44
-
let description = if !description_ptr.is_null() {
45
-
let desc = CStr::from_ptr(description_ptr)
46
-
.to_string_lossy()
47
-
.into_owned();
48
-
if desc.is_empty() {
49
-
None
50
-
} else {
51
-
Some(desc)
52
-
}
53
-
} else {
54
-
None
55
-
};
56
-
57
-
let location_ptr = ffi::i_cal_component_get_location(comp);
58
-
let location = if !location_ptr.is_null() {
59
-
let loc = CStr::from_ptr(location_ptr).to_string_lossy().into_owned();
60
-
if loc.is_empty() {
61
-
None
62
-
} else {
63
-
Some(loc)
64
-
}
65
-
} else {
66
-
None
67
-
};
68
-
69
-
let uid_ptr = ffi::i_cal_component_get_uid(comp);
70
-
let uid = if !uid_ptr.is_null() {
71
-
CStr::from_ptr(uid_ptr).to_string_lossy().into_owned()
72
-
} else {
73
-
String::new()
74
-
};
75
-
76
-
let start = ffi::i_cal_component_get_dtstart(comp);
77
-
let end = ffi::i_cal_component_get_dtend(comp);
78
-
79
-
let is_all_day = ffi::i_cal_time_is_date(start) != 0;
80
-
81
-
let start_time_t = ffi::i_cal_time_as_timet(start);
82
-
let end_time_t = ffi::i_cal_time_as_timet(end);
83
-
84
-
let (start_event_time, end_event_time) = if is_all_day {
85
-
// For all-day events, use just the date
86
-
let start_dt = Local.timestamp_opt(start_time_t, 0).unwrap();
87
-
let end_dt = Local.timestamp_opt(end_time_t, 0).unwrap();
88
-
(
89
-
EventTime::Date(start_dt.date_naive()),
90
-
EventTime::Date(end_dt.date_naive()),
91
-
)
92
-
} else {
93
-
// For timed events, use full datetime
94
-
(
95
-
EventTime::DateTime(Local.timestamp_opt(start_time_t, 0).unwrap()),
96
-
EventTime::DateTime(Local.timestamp_opt(end_time_t, 0).unwrap()),
97
-
)
98
-
};
99
-
100
-
ffi::g_object_unref(start as *mut std::os::raw::c_void);
101
-
ffi::g_object_unref(end as *mut std::os::raw::c_void);
102
-
103
-
Some(Event {
104
-
summary,
105
-
description,
106
-
location,
107
-
start: start_event_time,
108
-
end: end_event_time,
109
-
uid,
110
-
})
111
-
}
112
-
}
113
-
}
-113
crates/eds-cal-rs/src/ffi.rs
-113
crates/eds-cal-rs/src/ffi.rs
···
1
-
// Raw FFI bindings to C libraries
2
-
// This module contains all unsafe extern "C" declarations
3
-
4
-
#![allow(non_camel_case_types)]
5
-
#![allow(dead_code)]
6
-
7
-
use std::os::raw::{c_char, c_int, c_uint, c_void};
8
-
9
-
// Opaque C types
10
-
#[repr(C)]
11
-
pub struct GError {
12
-
pub domain: u32,
13
-
pub code: c_int,
14
-
pub message: *mut c_char,
15
-
}
16
-
17
-
#[repr(C)]
18
-
pub struct GList {
19
-
pub data: *mut c_void,
20
-
pub next: *mut GList,
21
-
pub prev: *mut GList,
22
-
}
23
-
24
-
#[repr(C)]
25
-
pub struct GSList {
26
-
pub data: *mut c_void,
27
-
pub next: *mut GSList,
28
-
}
29
-
30
-
pub enum ESourceRegistry {}
31
-
pub enum ESource {}
32
-
pub enum EClient {}
33
-
pub enum ECalClient {}
34
-
pub enum ICalComponent {}
35
-
pub enum ICalTime {}
36
-
37
-
#[repr(C)]
38
-
pub enum ECalClientSourceType {
39
-
Events = 0,
40
-
}
41
-
42
-
// GLib functions
43
-
#[link(name = "glib-2.0")]
44
-
extern "C" {
45
-
pub fn g_list_length(list: *mut GList) -> u32;
46
-
pub fn g_list_free_full(list: *mut GList, free_func: Option<extern "C" fn(*mut c_void)>);
47
-
pub fn g_slist_free_full(list: *mut GSList, free_func: Option<extern "C" fn(*mut c_void)>);
48
-
pub fn g_object_unref(object: *mut c_void);
49
-
pub fn g_error_free(error: *mut GError);
50
-
pub fn g_clear_error(error: *mut *mut GError);
51
-
pub fn g_strdup_printf(format: *const c_char, ...) -> *mut c_char;
52
-
pub fn g_free(mem: *mut c_void);
53
-
54
-
pub static glib_major_version: c_uint;
55
-
pub static glib_minor_version: c_uint;
56
-
pub static glib_micro_version: c_uint;
57
-
}
58
-
59
-
// Evolution Data Server functions
60
-
#[link(name = "edataserver-1.2")]
61
-
extern "C" {
62
-
pub fn e_source_registry_new_sync(
63
-
cancellable: *mut c_void,
64
-
error: *mut *mut GError,
65
-
) -> *mut ESourceRegistry;
66
-
pub fn e_source_registry_list_sources(
67
-
registry: *mut ESourceRegistry,
68
-
extension_name: *const c_char,
69
-
) -> *mut GList;
70
-
pub fn e_source_get_display_name(source: *mut ESource) -> *const c_char;
71
-
pub fn e_source_get_uid(source: *mut ESource) -> *const c_char;
72
-
}
73
-
74
-
// Evolution Calendar functions
75
-
#[link(name = "ecal-2.0")]
76
-
extern "C" {
77
-
pub fn e_cal_client_connect_sync(
78
-
source: *mut ESource,
79
-
source_type: ECalClientSourceType,
80
-
wait_for_connected_seconds: u32,
81
-
cancellable: *mut c_void,
82
-
error: *mut *mut GError,
83
-
) -> *mut EClient;
84
-
pub fn e_cal_client_get_object_list_sync(
85
-
client: *mut ECalClient,
86
-
sexp: *const c_char,
87
-
out_icalcomps: *mut *mut GSList,
88
-
cancellable: *mut c_void,
89
-
error: *mut *mut GError,
90
-
) -> c_int;
91
-
pub fn isodate_from_time_t(t: libc::time_t) -> *mut c_char;
92
-
}
93
-
94
-
// libical-glib functions
95
-
#[link(name = "ical-glib")]
96
-
extern "C" {
97
-
pub fn i_cal_component_get_summary(comp: *mut ICalComponent) -> *const c_char;
98
-
pub fn i_cal_component_get_description(comp: *mut ICalComponent) -> *const c_char;
99
-
pub fn i_cal_component_get_location(comp: *mut ICalComponent) -> *const c_char;
100
-
pub fn i_cal_component_get_uid(comp: *mut ICalComponent) -> *const c_char;
101
-
pub fn i_cal_component_get_dtstart(comp: *mut ICalComponent) -> *mut ICalTime;
102
-
pub fn i_cal_component_get_dtend(comp: *mut ICalComponent) -> *mut ICalTime;
103
-
pub fn i_cal_time_as_timet(tt: *mut ICalTime) -> libc::time_t;
104
-
pub fn i_cal_time_is_date(tt: *mut ICalTime) -> c_int;
105
-
}
106
-
107
-
// Helper for GObject unrefs
108
-
pub extern "C" fn glib_object_unref_wrapper(ptr: *mut c_void) {
109
-
unsafe { g_object_unref(ptr) }
110
-
}
111
-
112
-
// Generated constants from C headers
113
-
pub use crate::constants::*;
-13
crates/eds-cal-rs/src/lib.rs
-13
crates/eds-cal-rs/src/lib.rs
···
1
-
//! EDS (Evolution Data Server) Rust bindings and utilities
2
-
//!
3
-
//! This library provides safe Rust wrappers around Evolution Data Server
4
-
//! C APIs for calendar and event management.
5
-
6
-
pub mod constants;
7
-
mod core;
8
-
mod event;
9
-
mod ffi;
10
-
11
-
// Re-export commonly used types for convenience
12
-
pub use core::{CalendarClient, EdsError, GLibVersion, Result, Source, SourceRegistry};
13
-
pub use event::{Event, EventTime};